Linotte

Linotte is a French programming language in the most literal sense: not a language from France that happens to use English keywords, but one whose every keyword, concept, and error message is in French. Created by Ronan Mounès and first released in October 2005, Linotte was built on a wager summed up by its motto - “Tu sais lire un livre, alors tu peux écrire un programme informatique” (“You know how to read a book, so you can write a computer program”). To hold up its end of that wager, the language discards the traditional vocabulary of programming for one borrowed from literature and cinema: a program is a livre (book), a method is a paragraphe (paragraph), a variable is an acteur (actor), and the screen is a toile (canvas). Written in Java, GPL-licensed, and aimed at francophone children and beginners from primary school onward, Linotte spent nearly two decades as arguably the best-known francophone answer to a stubborn question: why should a French eight-year-old have to learn English before learning to program?

Not to be confused with: the Linotype typesetting machine. Linotte is French for the linnet, a small songbird - and the idiom tête de linotte (“linnet head”) affectionately means “scatterbrain,” a fittingly modest name for a language that asks nothing of its users but the ability to read.

History & Origins

Ronan Mounès - who signs his work cpc6128, after the Amstrad CPC 6128 home computer - reportedly began building Linotte around 2004 and published the first release on October 22, 2005. When he presented version 0.5.1 to the LinuxFr community in June 2008, he described the project as four years old and gave a clear motivation: there was no French-language programming language suitable for teaching children, and the mental overhead of English keywords was a real barrier for young francophone learners. His stated requirement for a Linotte programmer was simply knowing how to read and write - no mathematics, no prior computing experience.

Rather than translate an existing language keyword-for-keyword, Mounès rethought the vocabulary entirely. Drawing on the foundations of Java (the implementation language and runtime), BASIC (the tradition of beginner-friendly interpreted languages), and Logo (graphics-first pedagogy), he replaced programming’s technical register with a literary one. The result read less like source code and more like stage directions, and it came packaged in the Atelier Linotte (Linotte Workshop), a complete GPL-licensed desktop environment with an editor, interpreter, examples, and graphics canvas.

The language grew steadily through the late 2000s and 2010s, with releases announced to the French free-software community on LinuxFr. Version 1.6 (January 2012) brought surprisingly modern features - functions as values, a ternary operator, type inference, string interpolation. Version 2.0 (November 2012) was pitched as the language’s coming-of-age, offering both a concise and a verbose syntax. Version 2.6 (October 2015) responded to the Scratch era with a visual block-programming module whose blocks translated live into textual Linotte - positioned, characteristically, not as a replacement for text but as a bridge toward it.

The end, and the afterlife

In May 2019, Mounès posted “Clap de fin” (roughly, “that’s a wrap”) on LinuxFr, announcing the end of the project after nearly fifteen years. His reasons were candid: solo maintenance of an open-source language consumed evenings and weekends indefinitely; he had spent years on forums defending the very idea of programming in French; his hosting provider had cut off the project’s website and he could not get it restored; and when French schools finally did embrace teaching algorithms, “Scratch arrived and Linotte was left behind.”

But the curtain call was not quite final. In November 2019 the source code moved to a new GitHub repository, and from September 2020 a revived 3.x line shipped release after release - notably version 3.11 (December 2021), which permanently removed the Java 3D universes and the Webonotte web server to refocus on the pedagogical core, version 3.12 (January 2022), which made variable declaration automatic, and Atelier Linotte 3.14 (September 2022), the latest release, which bundles its own Java 19 runtime so students can install it in one click. Repository activity trails off after April 2024, and the project is best described today as dormant - finished software, freely available, quietly maintained by its creator when time allows.

Design Philosophy

Linotte’s design begins from a piece of empathy most languages skip: for a French child, while, print, and if are not neutral symbols but words in a foreign language. Removing that barrier was the first principle. The second was to remove programming’s own foreign language - the jargon of variables, functions, and classes - by systematically renaming every concept after something a reader already knows:

A Linotte “Hello, World” is a one-paragraph book:

1
2
3

BonjourLeMonde:
   début
     affiche "Bonjour le monde!"

début marks the start of the paragraph’s body and the verb affiche (“display”) does the printing. Control can flow between paragraphs explicitly with va vers (“go to”), a deliberately story-like construct:

1
2
3
4
5
6
7
8

spaghetti :
 début
   affiche "I am here."
   va vers second

second :
  début
   affiche "Now I am here!"

The philosophy extends past syntax into the environment. The Atelier ships graphics as a first-class citizen - actors can be placed and moved on the toile, in the Logo tradition of making the screen the reward - and later versions layered on event handling, so a button actor can be made to react to a mouse click with the wonderfully plain Fais réagir b1 à "clic souris" (“Make b1 react to ‘mouse click’”).

Key Features

French from top to bottom

Every keyword, every role, every verb is a French word used close to its everyday meaning. Declarations read like a casting call - cat est un animal (“cat is an animal”) - and object fields are reached with the possessive de, as in meal de chat (“chat’s meal”). Species (espèces) give Linotte a lightweight, prototype-flavored object system:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

espèces
 foot est un nombre
 color est un texte
 meal est un texte
 espèce animal contient foot, color, meal

main:
 cat est un animal, foot vaut 4, color vaut "black", meal vaut "mouse"
 début
  affiche meal de chat

Event-driven and concurrent, in plain words

Graphical books compose interface actors - formulaire (form), boite (box), bouton (button), étiquette (label) - and wire them to events with the Fais réagir ... à ... construct. Concurrency gets the same treatment: a paragraph marked asynchrone runs in parallel, and waiting is spelled exactly as a child would say it:

1
2
3
4
5
6

traitements asynchrone :
 début
  appelle traitement
  affiche "Wait 3 seconds"
  attends 3 secondes
  affiche "End of 3 seconds"

A language that grew real features

For a beginner’s language, Linotte accumulated a serious feature set over its 1.x and 2.x lines: functions as first-class values, a ternary conditional, type inference so simple actors need no explicit role, string interpolation, a plugin manager, and a pilcrow (¶) prefix syntax that let one-liners run without declaring a book at all. Webonotte, the embedded Jetty-based HTTP server carried until version 3.11, served “web books” (.wliv files) that mixed HTML with Linotte between <% and %> delimiters - server-side scripting in French. And the 2.6-era block module let learners build conditions and loops visually, always showing the equivalent Linotte text alongside.

The Atelier

Linotte was never distributed as a bare interpreter. The Atelier Linotte bundles the editor, the interpreter, a library of example books, and the graphics canvas into a single Java application, with installers for Windows, macOS, Ubuntu/Debian, Fedora, and Raspberry Pi, plus packaging through channels like Chocolatey and the Snap Store; recent releases include their own Java runtime so nothing needs installing first. Over the years it was also distributed on Framasoft’s Framakey portable USB collection - a practical detail that mattered in French classrooms with locked-down machines.

Evolution

Linotte’s two-decade arc splits cleanly into three acts. The first act (2005-2012) built the language: the literary metaphor, the roles and verbs, the canvas, and a rising floor of features culminating in the expressive 1.6 and the dual-syntax 2.0, which Mounès framed as the moment Linotte became “a true programming language” rather than a toy. The second act (2012-2019) was consolidation against headwinds - fewer structural changes, better documentation, the block module as an answer to Scratch - ending with the 2019 farewell post, a rare, frank public accounting of what solo language maintenance actually costs. The third act (2019-present) is the GitHub revival: a 3.x line that ran against the usual direction of language evolution by deleting features (Java 3D, Webonotte, the tube plugin system, mandatory declarations) to make the language smaller, simpler, and easier to install - a beginner’s language re-centered on beginners.

Current Relevance

Linotte today is dormant but intact. The complete source, documentation wiki, and multi-platform installers remain freely available from the official GitHub repository under GPL-3.0, and the bundled-runtime 3.14 release still installs and runs on current systems. No release has appeared since September 2022 and repository activity stops in April 2024, so newcomers should treat it as finished software rather than a living project.

Its historical position, though, has only sharpened. Linotte is arguably one of the most complete non-English programming languages ever built - not a keyword translation layer, but a full environment with its own conceptual vocabulary, maintained for nearly twenty years. In discussions of language localization and of natural-language programming, it is a natural francophone example to set alongside efforts like the Arabic قلب (Qalb) or Chinese-language BASICs whenever the anglocentrism of programming comes up.

Why It Matters

Programming languages are overwhelmingly written in English, and the standard defense is that keywords are “just symbols.” Linotte is the long-running counter-experiment. By rebuilding the entire conceptual stack in French - not only affiche for print but book for program and actor for variable - it tested whether a child’s native language and native metaphors could carry them into real programming, and for a community of French learners and teachers, it worked. Its trajectory is also an unusually honest case study in what becomes of such efforts: years of solo labor, a rueful farewell explaining exactly why (“Scratch arrived…”), and then a quiet revival that spent its remaining energy making the language smaller instead of bigger. The linnet is a modest bird, but Linotte’s question - who gets to learn programming without learning English first? - is one the industry still has not answered.