Le meilleur de chaque langage.
Compilé en binaire natif.
Pattern matching d'OCaml. Null-safety de Kotlin. Comprehensions de Python. Pipeline d'Elixir. String interpolation de C#. ADTs d'Haskell. Sans VM, sans runtime lourd, sans fork à mille features qui s'empilent. Un langage statiquement typé qui se compile en C portable et qui se rebuild lui-même en 5 secondes.
Tu connais déjà Amalgame
Chaque feature qu'on a piochée a un parent connu. Voici les correspondances directes.
T?, ??, ?.)
Python →List comprehensions [x*2 for x in xs if x > 0]
Elixir / F# →Pipeline operator x |> f |> g
C# / Kotlin →String interpolation "hello {name}"
Haskell →Enums algébriques (tagged unions) avec destructuring
Swift →Guard clauses guard cond else { return }
C# / Java →Génériques avec interfaces vérifiées à la compilation
JavaScript →Closures capturantes, lambdas multi-paramètres
C →Sortie compilée, binaire natif gcc -O2, pas de VM
Fondations
Ce qu'Amalgame est, dans le noyau.
Self-hosted & hackable
L'amc est écrit en Amalgame. Il se rebuild lui-même en 5 secondes — modifie le langage, teste, modifie encore. Là où Rust prend une heure et Go plusieurs minutes, ici la boucle « j'ai une idée, je l'essaye » reste fluide. Et si tu casses le binaire en plein dev, un snapshot/amc_lib.c known-good te ramène un compilateur fonctionnel en un gcc.
Compile vers C, binaire natif auto-généré
Pipeline complet en une commande : ton .am devient du C lisible, puis un binaire natif gcc -O2, sans étape manuelle. Source mappée 1:1 : string → char*, List → void**, int → i64. Pas de VM, pas d'allocation cachée hors GC (Boehm). Prêt à déployer.
Multi-plateforme
Linux, macOS et Windows (via MinGW) — chaque tag v* produit les trois binaires. CI verte sur les trois OS à chaque commit. Le runtime tient dans un #ifdef _WIN32 bien posé sur le réseau (Winsock vs POSIX).
(vs ~1h pour Rust)
Tout ce qu'un dev attend en 2026, dans un seul langage
Aucune feature qui demande de « patienter une release ». Tout est là, dès aujourd'hui.
Match comme expression, avec guards et destructuring
Le match est une expression — tu peux l'affecter à un let. Il supporte les guards (x if x > 0), les ranges (1..9), les binders, et le destructuring d'ADTs.
let bucket = match n { 0 => "zero" x if x < 0 => "negative" 1..9 => "small" 10..99 => "medium" _ => "large" } match shape { Circle(r) => Console.WriteLine("r={r}") Rect(w, h) => Console.WriteLine("rect") }
Le compilateur t'empêche de déréférencer null
Les types nullable sont distincts (T? vs T). L'accès safe (?.) et l'opérateur de coalescing (??) sont built-in — comme en Kotlin, sans le folklore des Java nullable annotations.
let maybe: Greeter? = null let label = maybe?.Hello() // null-safe let name = user?.Name ?? "anon" guard name != null else { return }
Le code lit dans le sens où tu le penses
List comprehensions (Python), pipeline operator (Elixir/F#), higher-order list methods (Filter, Map, Reduce, Any, All, CountIf) avec closures capturantes.
// Comprehension let squares = [i * i for i in 0..10 if i % 2 == 0] // Higher-order chain let total = numbers .Filter(n => n > 0) .Map(n => n * 2) .Reduce(0, (acc, n) => acc + n) // Pipeline let shouted = name |> String.ToUpper |> String.Trim
Interpolation native, multilignes incluses
Pas de concat à la pelle. Les expressions sont interpolées entre {}, et les triple-quoted """...""" couvrent les templates multilignes. Les escapes \xHH et \uHHHH sont supportés.
let msg = "Bonjour {user.Name}, tu as {orders.Count()} commandes" let sql = """ SELECT id, name FROM users WHERE created_at > '{since.Format()}' ORDER BY name """
Tagged unions avec payload, vérifiées par le compilateur
Comme en OCaml, Rust ou Haskell. Chaque variant peut porter ses propres données. Le pattern matching destructure proprement, le typechecker te rappelle les variants oubliés.
public enum Result { Ok(int) Err(string) } match compute() { Ok(v) => Console.WriteLine("value: {v}") Err(msg) => Console.WriteLine("error: {msg}") }
Compile-time checking, erasure runtime
Les génériques sont effacés à void* au niveau C (binaire compact, pas d'explosion de symboles), mais leur signature est vérifiée par le compilateur. Les interfaces génériques substituent les paramètres et imposent les contrats.
public class Box<T> implements IComparable<int> { public Value: T public int CompareTo(int other) { return 0 } }
Capture par valeur, multi-paramètres, blocks
Les lambdas (x, y) => expr capturent le scope environnant dans une struct d'environnement allouée par le GC. Les corps en bloc x => { ... } sont supportés. Tout fonctionne dans les higher-order list methods.
let threshold = 10 let big = xs.Filter(x => x > threshold) let combine = (a, b) => { let sum = a + b return sum * 2 }
Tuples + destructuring · guard clauses · decorators @inline/@deprecated · bitwise ops · compound assignments · range 0..n · try/catch/throw · classes, héritage, interfaces, data classes, records
Tout l'outillage moderne, dans ton éditeur préféré
Extension officielle livrée dans le repo. LSP workspace-aware, DAP natif avec breakpoints sur .am. Tout est là, à l'install.
Démo vidéo de l'expérience VSCode arrive bientôt.
Autocomplete LSP en action, diagnostic en direct, breakpoint sur .am via DAP.
Extension VSCode officielle
Vendue dans editors/vscode/ du repo. Syntax highlighting + client LSP + type de debug amc pré-configuré. Install en une commande : amc new --vscode scaffolde même un .vscode/launch.json prêt à F5.
amc lsp — Language Server
Workspace-aware : scanne tous les .am sous la racine pour résoudre les types cross-fichiers. Diagnostics live (didOpen/didChange), hover avec type inféré, completion globale, signatureHelp.
amc dap — Debug Adapter
Proxy DAP qui détecte lldb-dap (LLVM 18+) ou gdb --dap (gdb 14+). Les directives #line émises par la cgen font que tes breakpoints posés sur .am résolvent nativement via DWARF — pas de source maps, pas de path translation.
amc fmt — Formatter
Re-émet l'AST canoniquement, préserve les commentaires. Idempotent sur chaque source du compilateur lui-même. amc fmt -w pour réécrire en place.
amc --lint — Linter statique
Détecte code unreachable, locals inutilisés (préfixe _ pour ignorer), noms shadowed. Warnings non-fatals — pas de friction pour démarrer.
amc test — Test runner
Aucun framework. Découvre *_test.am, compile, exécute, agrège [PASS]/[FAIL]/[SKIP]. Exit non-zero si quoi que ce soit pète.
amc lsp · amc dap · amc fmt -w src/ · amc --lint · amc test
L'extension marche aussi avec Neovim, Helix, Emacs (eglot) et tout client LSP/DAP standard.
Multiplicateurs LLM
Trois commandes pour migrer, générer et expliquer du code. Ta clé, ta data, ton provider.
amc migrate
21 langues sources auto-détectées (TS, Python, Java, C#, Go, Rust...). Cache SHA-256, estimation de coût en --dry-run, validation auto avec amc --check.
amc generate
Prose → Amalgame. Idéal pour scaffolder un point de départ. --stream pour le passthrough stdout direct via la CLI claude.
amc explain
Code → prose. --lang French (ou n'importe quelle langue) traduit l'explication.
Provider au choix : Anthropic (Claude), OpenAI (ChatGPT), Google (Gemini), ou CLI claude en fallback. Détection auto depuis ANTHROPIC_API_KEY / OPENAI_API_KEY / GEMINI_API_KEY. Aucun serveur que nous contrôlons dans le pipeline — HTTPS direct de ta machine au provider.
Une bibliothèque, modulaire, qui s'enrichit chaque semaine
22 packages officiels disponibles aujourd'hui, 15 sur la roadmap. Tous Apache-2.0, tous gérés via amc package add <nom>.
🗄️ Bases de données SQL + NoSQL
libpq système, no vendored lib. Premier package du pattern dynamic-link.libmariadbclient.libmongoc + BSON.📡 Messaging & réseau
librdkafka.librabbitmq.🎨 UI & graphics
🎵 Multimédia
🛠️ Framework standard
amc package add duckdb · amc package search ui · amc package versions kafka
Le manifest des packages officiels est amalgame-lang/packages-index. Les packages tiers fonctionnent en URL directe.
Confiance & qualité
Zéro telemetry
L'amc tourne entièrement sur ta machine. Pas de phone-home, pas de stats d'usage, pas de pixel tracker dans les binaires. Le site amalgame.me sert de la doc statique, point.
Ta clé, ta data
Les commandes LLM (migrate / generate / explain) appellent ton provider directement avec ta clé. Aucun serveur amalgame.me dans le pipeline — pas d'intermédiaire, pas de cache distant.
CI multi-OS verte
Chaque commit tourne sur Linux + macOS + Windows MSYS2. Les releases sont produites automatiquement à chaque tag v* via GitHub Actions.
Apache-2.0 partout
Compilateur, runtime, stdlib, tous les packages officiels : Apache 2.0. Pas de double-license commercial, pas de zone grise contributeur.
Diagnostics rustc-style
Erreurs avec source snippet + caret pointant le token. Resolver et type-checker ont chacun leur catégorie. Pas de « syntax error at line 42 » générique.
Bootstrap récupérable
Si ./amc casse en plein dev, snapshot/amc_lib.c + un gcc te ramène un compilateur fonctionnel. Pas de cassette mystérieuse, pas de dépendance circulaire opaque.
Prêt à essayer ?
L'install prend 30 secondes. Le langage est jeune — ta contribution compte.