🔬 Le labo — la preuve par l'usage

Amalgame Lab

Un langage ne vaut que par ce qu'on construit avec. Voici l'atelier : des projets réels, certains en production, d'autres encore sur l'établi — chacun choisi pour prouver un point précis. Le serveur web qui sert cette page. Un orchestrateur P2P. Une station météo sur Raspberry Pi. Le même amc, du datacenter au capteur.

Mosaic
🟢 En production — ce site tourne dessus

Mosaic — le web, servi par Amalgame

amalgame.me · docs.amalgame.me · demo.amalgame.me · sites clients

La page que tu lis est servie par un unique binaire natif écrit en Amalgame. Pas de Node, pas de nginx devant, pas de reverse proxy : le binaire termine le TLS lui-même, choisit le bon site d'après le Host (SNI), et sert le tout sur le port 443. Le certificat HTTPS est obtenu et renouvelé par une state machine ACME pure-Amalgame (RFC 8555, Let's Encrypt) — sans certbot, sans sous-process.

Un seul process, plusieurs domaines, contenu statique et dynamique (la page Versions est remplie en direct depuis l'API GitHub, le formulaire de contact vérifie un reCAPTCHA côté serveur puis envoie un mail SMTP/TLS). C'est le dogfooding ultime : si Mosaic ne tenait pas, ce site tomberait.

HTTPS automatique via ACME natif — un domaine, un email, le binaire gère le reste
Multi-sites SNI — un listener 443, N domaines, un certificat par domaine
Statique + dynamique — fichiers servis avec ETag/304, routes applicatives à côté
Sécurité L7 — en-têtes stricts (HSTS/CSP), CSRF, rate-limit, anti-slowloris
Formulaire de contact — reCAPTCHA vérifié serveur + envoi mail SMTP/TLS, bout en bout
Zéro dépendance lourde — OpenSSL 3.x, et c'est tout. Pas de runtime mystère

L'ossature, telle qu'elle tourne ici — un binaire, plusieurs hôtes. (Le code sensible — clés reCAPTCHA, identifiants SMTP — vit hors source, jamais dans le dépôt.)

let server = SiteServer.New()

// Un site = un dossier. Plusieurs domaines peuvent pointer dessus.
server.Register(["docs.amalgame.me"], "sites/docs.amalgame.me")
server.Register(["demo.amalgame.me"], "sites/demo.amalgame.me")
server.RegisterAmalgameWithContact(
    ["amalgame.me", "www.amalgame.me"], "sites/www.amalgame.me", releases,
    cfg)   // cfg = secrets chargés à l'exécution, hors dépôt

// ACME natif par domaine, puis un seul listener HTTPS + SNI.
server.EnsureCerts()
server.ListenHttps(443)   // le :80 redirige en 301 vers https://
Pollen
🟡 En chantier — déjà fonctionnel

Pollen — orchestration P2P, sans broker

bus pair-à-pair · workflow déclaratif · zéro infra centrale

Là où Mosaic prouve qu'Amalgame fait du web, Pollen prouve qu'il fait du système distribué. C'est un bus de données pair-à-pair et son orchestrateur : pas de broker à provisionner, pas de cluster à maintenir. Les nœuds se parlent en direct (TCP + ACK applicatif), et un fichier workflow.json partagé dit à chacun quoi faire à chaque étape — call, if, for, while, goto, état persistant.

Pollen est un projet exigeant — concurrence, réseau bas niveau, machine à états — exactement le genre de chose pour laquelle on choisit habituellement Go ou Rust. Le fait qu'il avance en Amalgame, package après package, est la démonstration. Le runtime vit dans amalgame-pollen ; une interface web (elle-même en Mosaic) édite les workflows visuellement.

Transport TCP + ACK applicatif, un message JSON par ligne
Moteur de workflow déclaratif — call / if / for / while / goto + état
Registre de capacités + load balancing power-of-two
Éditeur visuel — une web app Mosaic dessine et publie le workflow
Zéro broker, zéro cluster — pas de Kafka, pas de Zookeeper à opérer
🔧 Réalisation en cours — du matériel, pour de vrai

Station météo — Amalgame sur Raspberry Pi

Raspberry Pi Zero W · capteurs · binaire natif ARM64

Le web et le distribué, c'est du logiciel. Restait à prouver qu'Amalgame descend jusqu'au matériel. Le banc d'essai : une station météo bâtie sur un Raspberry Pi Zero W et ses capteurs (température, humidité, pression), pilotés directement depuis Amalgame. Le même .am que tu écris sur ton poste se compile en binaire natif ARM64 et tourne sur le Pi — pas d'interpréteur embarqué, pas de couche Python.

Les broches passent par amalgame-hardware-gpio, premier package de la famille Amalgame.Hardware : GPIO numérique via libgpiod v2 (l'API noyau, valable du Pi 1 au Pi 5), avec une forme d'API calquée sur le futur HAL bare-metal MCU. I2C, SPI, PWM et UART — donc les capteurs de la station — arrivent dans les phases suivantes. La réalisation est en cours ; le pipeline ARM64 (CI + releases) est déjà vert.

Releases ARM64 natives — Raspberry Pi OS 64-bit, buildées + testées en CI
amalgame-hardware-gpio v0.1 — GPIO numérique via libgpiod v2, Pi 1→5
Un seul code — du poste de dev au Pi, le même .am
À venir — I2C / SPI / PWM, package capteurs, et la station qui publie sa météo en ligne

Le GPIO, à la HAL — la même API lira un capteur sur le Pi aujourd'hui et un MCU bare-metal demain.

import Amalgame.Hardware

let gpio = Gpio.New().AutoChip()      // détecte RP1 (Pi 5) vs Pi 4-
gpio.PinMode(17, PinMode.Output)
gpio.DigitalWrite(17, Level.High)   // LED témoin : mesure en cours

// I2C arrive en phase 2 → lecture directe d'un capteur T°/humidité.

Ce que l'atelier démontre

Trois projets, trois niveaux de la pile, un seul langage et un seul compilateur. C'est l'argument : Amalgame n'est pas une démo de syntaxe, c'est un outil avec lequel on livre.

Web · en prod

Ça sert des sites

Ce site, sa doc, sa démo et des sites clients tournent sur un binaire Mosaic unique, HTTPS automatique compris.

Distribué · en chantier

Ça orchestre

Pollen fait du pair-à-pair et du workflow sans broker — le terrain habituel de Go/Rust, en Amalgame.

Embarqué · en cours

Ça pilote du matériel

Binaire natif ARM64 sur Raspberry Pi, GPIO via libgpiod — du datacenter au capteur, un seul code.

Envie d'ajouter ton projet à l'atelier ?

Amalgame est libre (Apache-2.0) et s'installe en 30 secondes. Construis quelque chose — et raconte-le.