Open Source — Licence MIT

SharpTS

Un interpréteur TypeScript et compilateur AOT pour .NET

Exécutez-le comme un script pour un retour immédiat, ou compilez-le en assembly .NET natif — avec un accès complet à l'écosystème .NET.

curl -fsSL https://sharpts.dev/setup.sh | sh
Mettre une étoile sur GitHub
example.ts
// Exécutez du TypeScript directement sur .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.

Ce que fait SharpTS

Écrivez du TypeScript qui s'exécute sur le runtime .NET — interprété pour une itération rapide, ou compilé en assemblys .NET natifs.

Exécution instantanée

Pointez SharpTS vers un fichier .ts et il s'exécute — sans étape de build ni configuration. Idéal pour les scripts, l'automatisation et l'exploration d'idées dans le REPL.

Compiler vers .NET

Compilation anticipée vers un véritable assembly .NET — une DLL, un exécutable autonome ou un paquet NuGet — s'exécutant à la vitesse native du CLR.

Interop dans les deux sens

Appelez des bibliothèques .NET depuis TypeScript avec @DotNetType, et utilisez votre TypeScript compilé depuis C#. Réutilisez la BCL, les paquets NuGet et le code que vous avez déjà.

Large prise en charge de TypeScript

Utilisez le TypeScript que vous connaissez — génériques, classes, décorateurs, async, modules et plus encore — avec une vérification des types avant l’exécution. Consultez l’aperçu pratique de compatibilité ci-dessous.

S'intègre à votre build .NET

Ajoutez le SharpTS.Sdk à un projet .NET et dotnet build compile votre TypeScript aux côtés de votre C# — même chaîne d'outils, même résultat.

Prise en charge de l'éditeur

Un serveur de langage apporte l'autocomplétion, la vérification de types et le « aller à la définition » à VS Code et Visual Studio.

Voir en action

Du vrai TypeScript exécuté sur le runtime .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}`));
Sortie
Hello from SharpTS! v1
  ✓ TypeScript
  ✓ C#
  ✓ .NET

Envie d'exécuter le vôtre ? Ouvrez le Playground ↓

Quand SharpTS est le bon choix

Des situations concrètes où TypeScript sur .NET l'emporte sur Node — ou sur C#.

Scripts et automatisation pour les équipes .NET

Écrivez des scripts de build, des outils de dev et de l'automatisation ponctuelle en TypeScript avec toute la BCL à disposition — sur des machines qui ont déjà le SDK .NET et aucune chaîne d'outils Node. Pas de package.json, pas d'étape de build : pointez sharpts vers le fichier.

Terminal
sharpts rotate-logs.ts

Livrer de la logique TypeScript comme bibliothèque .NET

Compilez un module TypeScript en véritable assembly et publiez-le comme paquet NuGet versionné. Avec un assembly de référence, les appelants C# instancient vos classes et appellent vos méthodes de façon entièrement typée.

Terminal
sharpts --compile pricing.ts --ref-asm
sharpts --compile pricing.ts --pack

Des développeurs TypeScript dans une base de code .NET

Laissez vos collègues venus de TypeScript contribuer dans le langage qu'ils maîtrisent le mieux. Avec SharpTS.Sdk, leurs fichiers .ts sont compilés dans le même dotnet build que les projets C# qui les entourent — une seule chaîne d'outils, un seul pipeline CI.

app.csproj
<Project Sdk="SharpTS.Sdk/1.0.0">
  <PropertyGroup>
    <TargetFramework>net10.0</TargetFramework>
    <SharpTSEntryPoint>src/main.ts</SharpTSEntryPoint>
  </PropertyGroup>
</Project>

Outils en ligne de commande autonomes

Compilez vers un exécutable autonome unique qui s'exécute sans installation de runtime séparée — pas de Node sur la machine cible, pas de dossier node_modules livré à côté de votre outil.

Terminal
sharpts --compile tool.ts -t exe
./tool

Comment ça marche

Un pipeline multi-étapes, de la source à l'exécution

SourceLexerAnalyseurVérificateur de typesInterpréteurCompilateur IL
Découvrir le fonctionnement

Bac à sable interactif

Écrivez du TypeScript et exécutez-le sur .NET — directement dans votre navigateur

Sortie
Cliquez sur Exécuter ou appuyez sur Ctrl+Entrée pour exécuter

Ce qui est pris en charge

Un aperçu pratique des fonctionnalités TypeScript et d’exécution disponibles aujourd’hui. Pour des résultats mesurés, explorez la conformité.

TypeScript au quotidien

Les classes, génériques, unions, décorateurs, modules, async/await et fonctionnalités modernes du système de types sont pris en charge dans les flux SharpTS.

Runtime standard

Les API courantes d’Array, String, collections, Promise, Date, RegExp, JSON, Symbol et tableaux typés sont disponibles.

Paquets et Node.js

Les imports nus et les champs exports/imports des paquets peuvent être résolus, mais les paquets dépendent toujours d’une syntaxe et d’API d’exécution compatibles avec SharpTS. Les paquets livrant leur source TypeScript sont les mieux adaptés.

Limites connues

Proxy et WeakRef ne sont pas implémentés. Les résultats de l’interpréteur et de l’AOT peuvent aussi différer sur certains cas limites de la spécification.

Questions fréquentes

Les questions qui viennent en premier — avec des réponses directes.

En quoi SharpTS diffère-t-il de tsc ?

tsc vérifie les types de votre code et émet du JavaScript qu'un moteur comme Node exécute. SharpTS ne produit jamais de JavaScript : il vérifie les types du même TypeScript, puis l'exécute directement ou le compile en assembly .NET. Il n'y a aucun Node dans la chaîne. Le script d'installation utilise le SDK .NET lorsqu'il est disponible, sinon il installe une version autonome.

Pourquoi ne pas intégrer un moteur JavaScript comme Jint ou ClearScript ?

Ces projets exécutent du JavaScript brut, non typé, dans un hôte .NET — très bien pour de petits scripts embarqués. SharpTS exécute TypeScript lui-même, vérifié avant l'exécution, et ajoute ce qu'un moteur JS embarqué ne peut pas offrir : la compilation anticipée vers IL, l'empaquetage NuGet et l'interop typée dans les deux sens entre TypeScript et C#.

Puis-je utiliser des paquets npm ?

Partiellement. Les imports nus se résolvent via node_modules, et les modes de résolution pris en charge peuvent appliquer les champs exports/imports et les cibles conditionnelles des paquets. Un paquet peut néanmoins échouer s’il dépend d’une syntaxe non prise en charge, d’extensions natives, de globales du navigateur ou d’API d’exécution manquantes. Les paquets livrant leur source TypeScript sont les mieux adaptés.

Voir le suivi de compatibilité Node.js →
Est-ce rapide ?

Chaque mode répond différemment. L'interpréteur parcourt l'arbre syntaxique et vise un démarrage instantané — idéal pour les scripts et le REPL, pas pour le calcul intensif. Le mode compilé émet de l'IL que le CLR compile à la volée comme n'importe quel assembly C# : il s'exécute comme du code .NET natif. Dans les deux modes, les types sont vérifiés en amont puis effacés — ils ne coûtent rien à l'exécution.

Quelle est la maturité de SharpTS ?

C’est un projet jeune, sous licence MIT et en développement actif. L’aperçu de compatibilité ci-dessus résume les capacités courantes, la conformité mesurée en publie les preuves détaillées et STATUS.md suit les manques d’implémentation.

Suivre l'avancement dans STATUS.md →

Démarrer

Opérationnel en trois étapes

1

Installer

Exécutez le script d'installation pour installer la version de SharpTS adaptée à cette machine

curl -fsSL https://sharpts.dev/setup.sh | sh
2

Écrire

Créez un fichier TypeScript

hello.ts
interface Config {
    name: string;
    debug: boolean;
}

const config: Config = { name: "MyApp", debug: true };
console.log(`Starting ${config.name}...`);
3

Exécuter

Interprétez directement ou compilez vers un assembly .NET

Terminal
# Interpréter (démarrage instantané)
sharpts hello.ts

# Compiler vers un assembly .NET
sharpts --compile hello.ts -o hello