Marimo : le notebook Python réactif qui ringardise Jupyter

# Exporter le notebook en HTML autonome (rapport, partage)
marimo export html notebook.py -o rapport.html

# Exporter en script Python pur (réutilisable hors notebook)
marimo export ipynb notebook.py -o notebook.ipynb   # vers Jupyter
marimo export script notebook.py -o script.py       # vers .py

# Lancer un notebook comme une application web (sans éditeur)
marimo run notebook.py

# Déployer gratuitement sur le cloud Marimo
marimo deploy notebook.py

marimo run transforme ton notebook en app web : les widgets restent interactifs, mais l'éditeur disparaît, ce qui donne un outil propre à mettre entre les mains d'un collègue ou d'un client. marimo deploy pousse le tout sur le cloud Marimo avec une URL publique, gratuitement pour les projets ouverts.

Les pièges à connaître

• Variable définie deux fois : Marimo refuse les définitions dupliquées. Si tu veux itérer sur une valeur, crée une nouvelle variable plutôt que de réaffecter.
• Oubli du .value : un widget n'est pas sa valeur. Écris slider.value, pas slider, dans tes calculs.
• Cellules trop grosses : découpe tes cellules en unités logiques. La réactivité ne recalculera que ce qui est nécessaire, et le notebook restera lisible.
• Dépendance circulaire : si deux cellules dépendent l'une de l'autre, Marimo le signale. Restructure pour briser le cycle.
• Performance : une cellule coûteuse (chargement d'un gros fichier) se réexécute à chaque changement de ses dépendances. Utilise mo.cache pour mémoïser les calculs lourds.

Reproductibilité : un état qui ne ment pas

Le plus grand bénéfice de la réactivité, c'est la reproductibilité. Dans Jupyter, l'état d'un notebook dépend de l'ordre dans lequel tu as cliqué sur les cellules ; rouvrir le fichier ne te dit rien de cet historique, et relancer les cellules dans un autre ordre peut produire un résultat différent. Dans Marimo, l'état est entièrement déterminé par le code : exécuter le notebook de haut en bas donne toujours le même résultat.

Cette propriété change la donne pour le travail en équipe. Un notebook Marimo est une description déclarative de ton analyse : pas d'étape cachée, pas de variable fantôme, pas de cellule oubliée. Si deux personnes ouvrent le même fichier avec le même environnement, elles voient exactement la même chose. C'est aussi une exigence de plus en plus fréquente dans les contextes réglementés, où l'on doit pouvoir prouver comment un résultat a été obtenu.

Les cellules sont des fonctions

Pour tirer le meilleur parti de Marimo, pense à chaque cellule comme à une fonction : elle lit des variables en entrée et produit une sortie. Les fonctions Python classiques restent évidemment disponibles, et c'est une bonne pratique de factoriser la logique réutilisable dans des fonctions, appelées ensuite par les cellules réactives.

import marimo as mo

# La logique métier vit dans une fonction classique, testable et réutilisable
def prix_ttc(prix_ht, taux=0.2):
    return round(prix_ht * (1 + taux), 2)

montant = mo.ui.number(value=100, label="Montant HT")
montant

# La cellule réactive ne fait qu'afficher le résultat de la fonction
mo.md(f"Montant TTC : **{prix_ttc(montant.value)}** euros")

Cette séparation entre logique (les fonctions) et interface (les cellules) rend ton notebook plus lisible et plus facile à maintenir. Les fonctions peuvent être extraites dans un module séparé et testées unitairement, tandis que le notebook se concentre sur l'exploration et la présentation.

mo.md et le Markdown enrichi

Pour composer du texte, des titres, des listes ou des citations, mo.md rend du Markdown enrichi, y compris du LaTeX pour les mathématiques (entre deux paires de dollars). C'est ton outil de base pour structurer la narration d'un notebook et le transformer en un véritable rapport.

import marimo as mo

# mo.md rend du Markdown enrichi (titres, listes, citations)
mo.md("# Bilan trimestriel")

mo.md("Un **chiffre clé** : `revenu = prix * volume`")

mo.md("- Un point à retenir
- Un second point")

Contrairement aux cellules Markdown de Jupyter qui sont statiques, le Markdown de Marimo est réactif : tu peux y interpoler la valeur d'un widget ou d'un calcul, et le texte se met à jour en direct. C'est ce qui permet de construire des tableaux de bord narratifs où le texte reflète toujours les données affichées.

Exécuter un notebook comme un script

Un notebook Marimo est un fichier Python ordinaire, pas un format propriétaire. Conséquence pratique : tu peux l'exécuter de haut en bas comme n'importe quel programme, ce qui en fait un excellent support pour l'automatisation.

# Un notebook Marimo est un programme Python valide :
# on peut l'exécuter de haut en bas, sans interface.
python notebook.py

# marimo run le sert comme application web (widgets interactifs)
marimo run notebook.py

Ce double visage est rare : le même fichier sert à la fois de cahier d'exploration interactif et de job reproductible que tu peux glisser dans un pipeline ou une tâche planifiée. Pas de conversion, pas de dérive entre ce que tu explores et ce que tu exécutes en production.

Marimo vs Jupyter : le bilan

Pour récapituler ce qui sépare les deux outils, voici une comparaison point par point :

• Exécution : Jupyter exécute manuellement, dans l'ordre de ton choix ; Marimo exécute automatiquement, dans un ordre déduit des dépendances.
• État : Jupyter garde un état caché et fragile ; Marimo déduit l'état du code, donc toujours cohérent.
• Reproductibilité : Jupyter dépend de l'historique d'exécution ; Marimo la garantit par construction.
• Interactivité : Jupyter s'appuie sur des extensions (ipywidgets) ; Marimo l'a nativement via mo.ui.
• Partage : Jupyter passe par nbconvert ou Voila ; Marimo exporte en HTML et se lance en app web d'un coup.
• Dépendances : Jupyter partage l'environnement Python global ; Marimo isole les paquets par notebook.

Les formulaires avec mo.ui.form

Pour collecter plusieurs champs et les valider ensemble, mo.ui.form regroupe des widgets dans un formulaire qui se soumet d'un coup. C'est la brique qui permet de construire de vrais écrans de saisie.

import marimo as mo

# Un formulaire regroupe plusieurs champs et se valide d'un seul clic
form = mo.ui.form(
    nom=mo.ui.text(label="Nom"),
    age=mo.ui.number(start=0, stop=120, label="Âge"),
)
form

# À la soumission, form.value contient un dict des valeurs saisies
if form.value is not None:
    mo.md(f"Enregistré : **{form.value['nom']}**, {form.value['age']} ans")

La valeur n'est disponible qu'après soumission, ce qui évite les réactions prématurées à chaque frappe. C'est exactement le comportement attendu d'un formulaire classique, et cela rend Marimo adapté à la saisie de paramètres ou de données structurées.

mo.cache pour les calculs lourds

La réactivité a un coût : une cellule qui charge un gros fichier se réexécute dès qu'une de ses dépendances change. Pour les opérations coûteuses et déterministes, mo.cache mémoïse le résultat : il n'est recalculé que si les arguments changent.

import marimo as mo

@mo.cache
def charger_donnees(chemin):
    # Simulation d'un chargement long (fichier volumineux, requête API...)
    import time
    time.sleep(2)
    return {"lignes": 1000}

donnees = charger_donnees("donnees.csv")
mo.md(f"{donnees['lignes']} lignes chargées")

Tant que le chemin passé en argument ne change pas, la fonction n'est pas réexécutée : tu modifies une autre cellule sans subir le délai de chargement. C'est le réflexe à adopter dès qu'un notebook commence à devenir lent.

Les composants avancés

Au-delà des widgets de base, Marimo embarque des composants prêts pour la donnée et le multimédia :

• mo.ui.table et mo.ui.dataframe : tableaux interactifs avec tri, filtrage et recherche.
• mo.ui.altair_chart, mo.ui.plotly : graphiques réactifs reliés à tes données.
• mo.ui.file : upload de fichiers directement depuis le navigateur.
• mo.ui.batch : un seul widget pour manipuler plusieurs valeurs d'un coup.
• mo.ui.anywidget : intégrer n'importe quel widget JavaScript personnalisé.

Cette richesse fait de Marimo bien plus qu'un carnet de notes : c'est un véritable atelier de construction d'interfaces, où la frontière entre analyse et application s'estompe naturellement.

Versionner et collaborer avec Git

Parce qu'un notebook Marimo est un simple fichier .py, il se prête naturellement au versionnement. Là où les notebooks Jupyter (.ipynb) produisent des diffs illisibles mêlant code, sorties et métadonnées, un notebook Marimo génère un diff propre, limité à ce qui a réellement changé.

# Un notebook Marimo est un fichier .py : le diff Git est lisible
git add notebook.py
git commit -m "Ajout de l'analyse des ventes trimestrielles"

# Revenir en arrière ou comparer deux versions se fait naturellement
git diff HEAD~1 notebook.py

Cette propriété facilite la revue de code, le travail à plusieurs sur une même analyse, et l'intégration de tes notebooks dans des pipelines de CI. C'est un argument de poids pour les équipes data qui souffrent de la friction du format .ipynb dans leurs dépôts.

Autre conséquence : pas de sorties stockées dans le fichier. Le notebook ne contient que le code et la structure, jamais les résultats, ce qui évite les diffs gonflés par des images ou des tableaux régénérés à chaque exécution.

Quand privilégier Marimo ?

Marimo brille particulièrement dans quelques situations précises, où il fait gagner un temps considérable :

• Tu explores des données et veux des widgets interactifs sans rien configurer.
• Tu dois partager une analyse sous forme d'application web sans réécrire de code.
• Ton travail doit être reproductible et versionné proprement avec Git.
• Tu en as assez des bugs d'état caché qui plombent tes notebooks Jupyter.
• Tu veux un seul fichier qui serve à la fois de cahier d'exploration et de job exécutable.

Conclusion

Marimo reprend ce que Jupyter a de meilleur, l'exploration interactive, et y ajoute ce qui lui manquait : la réactivité, la reproductibilité et une vraie voie de passage vers l'application. Le modèle mental change, celui du tableur plutôt que du script, mais une fois la règle de la définition unique intégrée, on ne veut plus revenir en arrière.

Pour aller plus loin, explore les composants avancés (formulaires, routes multi-pages avec marimo islands), le cache, et les notebooks exécutés comme des pipelines avec marimo run en mode non interactif. La documentation officielle est remarquablement claire et bourrée d'exemples exécutables.

Sources

• Documentation officielle de Marimo
• Dépôt GitHub marimo-team/marimo
• Guide des widgets (mo.ui)
• Marimo vs Jupyter (comparatif)
• Déploiement cloud (marimo deploy)