Journal Amalgame : un langage à typage statique qui compile vers du C natif

Présentation d'un langage compilé, self-hosted, qui transpile vers du C portable puis vers un vrai binaire — sans runtime ni machine virtuelle.

En une phrase

Amalgame est un langage à typage statique dont le compilateur émet du C portable, ensuite transformé en exécutable natif par gcc. Pas de VM, pas de runtime à installer chez l'utilisateur final : le binaire produit se déploie comme n'importe quel programme C. Le compilateur, amc, est lui-même écrit en Amalgame (il est self-hosted) et se recompile, suite de tests comprise, en quelques secondes.

L'objectif assumé : retrouver le confort syntaxique des langages modernes (pattern matching, null-safety, lambdas, génériques, compréhensions de listes) tout en conservant la vitesse et la portabilité d'un binaire C classique.

Le principe : C comme cible d'assemblage portable

L'idée n'est pas neuve — Nim, V, ou historiquement Vala l'ont exploitée — mais elle reste pertinente. Plutôt que de cibler directement un jeu d'instructions ou de s'appuyer sur LLVM, Amalgame génère du C lisible, puis délègue à gcc toute l'optimisation et la portabilité (Linux, macOS, Windows). Les avantages concrets :

• Portabilité maximale : partout où il y a un compilateur C, le code tourne.
• Interopérabilité native : lier une bibliothèque C/C++ (SQLite, DuckDB…) ne demande pas de FFI complexe, puisqu'on est déjà en C en sortie.
• Pas de runtime imposé : le livrable est un exécutable autonome, pas un bundle accompagné d'un interpréteur.

Le revers, comme pour tout langage transpilé vers C, c'est que le débogage au niveau du C généré peut être déroutant, et qu'on hérite des contraintes de la chaîne C sous-jacente. Le pari d'Amalgame est que le C lisible émis limite cette friction.

Un aperçu de la syntaxe

La syntaxe puise dans C# et Kotlin. Voici un exemple complet, tiré de la documentation :

namespace App
import Amalgame.IO

public class Greeter {
  public Name: string

  public Greeter(string name) {
    this.Name = name
  }

  public string Hello() {
    guard String.Length(this.Name) > 0 else {
      return "Hello, stranger!"
    }
    return "Hello, {this.Name}!"
  }
}

On y reconnaît plusieurs choix de conception :

• les namespaces et un système d'import explicite ;
• la clause guard … else (familière aux développeurs Swift) pour sortir tôt d'une fonction et garder le chemin nominal à plat ;
• l'interpolation de chaînes avec la syntaxe {expression} ;
• une déclaration de type postfixée (Name: string).

Au-delà de cet exemple, le langage propose pattern matching, sûreté face au null, lambdas, génériques et compréhensions de listes — l'ergonomie attendue d'un langage récent, mais résolue à la compilation et sans coût à l'exécution.

Un compilateur self-hosted

C'est sans doute le point le plus parlant pour un public technique : amc est écrit en Amalgame. Le langage est donc capable de se compiler lui-même, ce qui constitue une preuve de maturité (le fameux bootstrap). Le cycle complet — recompilation du compilateur et exécution de la suite de tests — tient en quelques secondes, ce qui rend les itérations confortables.

La suite de tests qui valide le compilateur compte près de 480 cas à l'heure où j'écris ces lignes. Le langage en est encore à une version 0.8.x : il est utilisable et éprouvé sur lui-même, mais pas encore stabilisé en 1.0.

L'outillage : tout dans amc

Plutôt que d'éparpiller les fonctions dans une constellation d'outils, Amalgame regroupe l'essentiel dans le binaire amc :

• Tests : amc test parcourt le dossier, repère les fichiers *_test.am, les compile et les exécute en parallèle, puis agrège les résultats. Pas de framework à apprendre : chaque fichier de test est un programme Amalgame normal qui imprime [PASS]/[FAIL]/[SKIP], et le code de sortie se propage à n'importe quel pipeline CI (GitHub Actions, GitLab CI…).
• Formatage : amc fmt -w src/ réémet l'AST de façon canonique (idempotent).
• Lint : amc --lint src/main.am.
• Gestion de paquets : amc package (alias amc pkg) fonctionne comme cargo ou npm — manifeste TOML, lockfile (amalgame.lock), index curé, résolution automatique de la dernière version compatible. Les paquets embarquent leur propre runtime C/C++, ce qui permet de lier un backend comme SQLite ou DuckDB sans effort de configuration.

amc test
amc fmt -w src/
amc --lint src/main.am
amc package add duckdb

L'angle « ère des agents »

Amalgame intègre trois sous-commandes pilotées par LLM, avec votre propre clé d'API (Anthropic, OpenAI ou Google), sans serveur intermédiaire :

amc migrate app.ts          # migration depuis 21 langages sources vers Amalgame
amc generate "REST CRUD users"  # génération de code à partir d'un prompt
amc explain main.am         # explication en langage naturel d'un fichier

amc migrate auto-détecte 21 langages sources (TypeScript, Python, Java, C#, Go, Rust…) à partir de l'extension, avec récursion sur dossier, cache SHA-256 et validation automatique du résultat via amc --check.

L'argument de fond mérite d'être posé clairement, car c'est là que le typage statique reprend du sens à l'heure des assistants de code : un modèle qui génère du code « halluciné » produit, dans un langage strictement typé compilé, une erreur de compilation plutôt qu'un bug silencieux à l'exécution. Le compilateur devient un garde-fou pour le code produit par une IA. C'est un positionnement, pas une démonstration définitive — mais l'argument est cohérent.

Site et documentation : amalgame.me
Dépôt et binaires (publiés à chaque tag) : github.com/amalgame-lang/Amalgame

Le projet est open source ; les retours, issues et PR (notamment sur la stdlib) sont les bienvenus.