As a native french speaker, I feel so uneasy reading source code in french. It feels very very uncanny. I've often wondered if English native speakers feel the same when reading normal source code which is always in English. They probably don't. But how? I've always associated the "other language-ness" to correctness and technicality. It must be so weird to code in your own language. Feels like reading bad pseudo code. It's very nice to be able to map "english" to "technical, correct" and "native language" to "descriptive, approximate, comments, pseudo-code". Having only a single language to work with is like removing a color from the rainbow.
I'm a native English speaker. I do actually remember programming languages feeling a little uncanny at first. Like you can tell that it's "computery" and that the language author tried to make it English-like and only sorta succeeded.
So I think at this point, for me, programming languages just aren't English. One odd thing I've noticed is that in Ruby the `unless` keyword confuses the hell out of me, and yet when speaking English I never get tripped up on the actual word "unless". So I guess it's handy that the keywords in programming happen to be English words, but my comprehension of programming languages seems to occupy another region of my brain.
I'm quite fluent in english and "unless" is also weird to me, for some reason, "when" in ansible is also very weird, I don't know why. Back to the original post, I would never work for my (French) government again if they adopt something like rouille ; just reading the README felt very weird.
But rust lets you use unicode for identifiers. Just make every variable its own greek letter. Or Tamil, plenty of languages available. Why waste screen space by using entire words? That is mostly sarcasm, maybe?
Didn't someone say something about using French to speak of love and german to speak of science? Maybe english is getting it's use.
> But rust lets you use unicode for identifiers. Just make every variable its own greek letter.
This can actually be useful for locally-defined variables. Even more so if you're using an editor with LSP support where it's trivial to bring up the doc comments for an identifier as a tooltip - with some added support, you could even write these doc comments in multiple natural languages, while keeping the code itself quite linguistically neutral.
(Brit here) My first encounter with a foreign PL was a French Prolog implementation in the mid 80s whose only compiler error message was IIRC something like 'Erreur syntactique'. This seemed superbly Gallic, if somewhat less than helpful.
Two of the best things I learned in French class (which was basically “Parisian culture of 1982” class) was that “impossible” in French meant “I don’t feel like it”, and if someone shrugged in a way where the edges of their mouth touched the top of their shoulders, you were shit out of luck with whatever you were asking for.
Off-topic but that reminds me of the quote from "Stand on Zanzibar" where 'impossible' is defined as IIRC "1) I can't be bothered or 2) I don't approve or 3) God can't be bothered"
The closest I've ever felt to this as a native English speaker is reading words in music scores in English. I'm a classically trained cellist, and grew up learning notation with Italian and French words for directions and expression. I've never learned either of those languages, save the words used in music notation. Seeing a score with those words in English just feels... wrong. Not in any big way, but as you said: uncanny. Definitely get the "bad psuedocode" vibe, because to me it English in music notation feels similar -- like the person who wrote it didn't know what they were doing, even though the notation makes perfect sense and the music is good. It removes some of the flair of the art of the notation itself for me.
For anything vaguely technical, I use the English term. I don't feel comfortable in any other language, no matter how well I speak it. It just doesn't sit right with me to use eg a Danish term for density, or power, or eigenvalue, or anything programming.
Part of it is that even though I might know the term, it won't be long before I need to bring in something where I don't know the term. At that point I'll be inventing a local term, when I know what the English term is.
In this particular case, it might also feel uncanny because the keywords were merely translated; but the grammar (most notably word order) doesn't (always) match.
`asynchrone fonction` feels wrong because it's the wrong word order for French; it should be `fonction asynchrone`...
I'm a native Portuguese speaker. Here, when people are first starting to learn programming, it's very common for them to write code in Portuguese. For example, they would write this simple age verification algorithm:
  int verifica_idade(int idade) {
    if (idade < 18) { return -1; }
    return 1;
  }
  int main() {
    int idade;
    scanf("%d", &idade);
    int verificacao = verifica_idade(idade);
  
    if (verificacao < 0) { printf("Acesso negado\n"); }
    else { printf("Acesso liberado\n"); }
    return 0;
  }
> Do French (or other languages) speakers also do this?
I don't know anything about the Portuguese script. But your example seems to be made entirely of regular Latin alphabets. Now imagine another language where that isn't the case. Just switching the layout even on a programmable keyboard is going to be a major annoyance. I can touch type on two layouts (English Qwerty and Malayalam Poorna Inscript, in case you're wondering). Occasionally switching between the two layouts is the biggest distraction while typing prose - even with convenient layer switchers programmed in. Programming is going to be hell if the keywords and identifiers are in different scripts. I reckon that it would slow me down to about one-third of my full speed.
There are genuine reasons why identifiers could be in another language - like programming for linguistics (spelling and grammar checkers, morphology analyzers, etc) or while dealing with regional concepts. But even in those cases, programmers simply transliterate it into Latin script, rather than use the original script. Their sound roughly the same. But full fidelity is not possible (there are sounds that you may not have even imagined before). Even so, it's easier to just compromise on fidelity rather than do constant layout switching.
And then there is the reality that many language scripts are simply unusable for programming. My own language is agglutinative - meaning that multiple words fuse into one (even 4 words combining is not unusual). The same thing can be written in a dozen different ways. This isn't a big issue if you're reading or listening. It won't confuse you. But the moment you start applying formal rules like in a computer, it's a dozen different ways to type it wrong! I like my script for anything other than programming. It's very expressive. But the anemic simplicity of the Latin script is actually a big advantage when it comes to things like programming and mathematics. I believe that you will find many such peculiarities and nuances with other scripts if you go searching.
Yeah it's quite common in French (for learners). At least in part because French people aren't very good at English, it'd add more friction to the learning process (and even for the ones who aren't bad at english, it's a whole new vocabulary to learn).
I'm not sure when I did the switch myself! Maybe as late as my first professional experience, or maybe a bit later in my studies
Yes we do this while learning programming. Then it quickly becomes a sign of being a novice programmer that we look down on.
Should it be looked down on?
It did not feel odd to me.
Possibly a remnant of being bilingual as a child (I am not anymore, and was not by the time I learned programming later in my childhood)?
I do not think I ever really thought of programming languages as being English, but English like/derived from English.
As a native french speaker, I have the same feeling when reading code written with french keywords, except that since I learned boolean and arithmetic in french, it makes more sense to me to read them in french. As others have pointed out, it seems to only be a matter of how you learn to read and write code.
For comparison, in mathematics I learned to read all the symbols in french, and only learned their english equivalent much later, so it feels uneasy for me when i read their english version. So it is clearly a matter of habit that took its root when you learned reading.
It is uncanny but in that case I had a fun feeling reading usual abstraction (maybe types, self traits) in French, it tapped into a different part of the brain, that helps thinking about what the code means less mechanically
Yes it's so strange, like bad and unreadable pseudocode.
I could see myself coding in Latin though: https://github.com/pianoman911/ferrugo. Something about the prepositions tickles my brain the right way.
For real though! I could get used to &ipse.
As an American...no uncanniness to English. I guess because it was always the default and what was taught.
The first time I encountered a non English PL, I did feel the same uncanniness you spoke of. It felt... wrong? I wish I remembered which one it was. It was probably the first time I realized how prevelant English was, and that PLs could even be written in any language .
The words may be English but it doesn’t feel like English at all because it’s but structured like natural language.
How's Microsoft Excel for you?
Salutations,
I always felt the same and one theory I have is because the imperative nature of source code feels rude if you try and put it in French. It feels like yelling orders to a dog.
Then I don't know if it's just because in French, despite everyone calling us rude, we are usually quite polite. Or if it's the same for every ESL.
It looks more elegant than English.
i thought the verbs in English-programming were meant to be infinitive and not imperative?
The complete dictionary is here: https://github.com/bnjbvr/rouille/blob/principale/rouille_co...
I just can't stop laughing at the "génial" => "super" https://github.com/bnjbvr/rouille/blob/principale/rouille_co...
I've notice there is "merde" method which is available in the example like in https://github.com/bnjbvr/rouille/blob/7e9523fe24026bff1a3a7...
Merde is an alias for "calisse" and "oups" , see https://github.com/bnjbvr/rouille/blob/7e9523fe24026bff1a3a7...
Haha the translation is so funny. But I confess, as a native french speaker, I could not code in that language. It is so weird because I am used to english for coding now. Sometimes I write my variable names in french and I think I even used accented letters one time. What is worse, is that I tend to mix english and fench variable names in my code, but anyway english is way more common in the code base.
I find it slightly disappointing that they haven't stuck with the Rust practice of picking short or abbreviated words when they're clearly unambiguous - such as "fn" instead of "func" or "function". E.g. why Résultat<...> when you can write just Résu? Why PeutÊtre and not Ptêt, very common in quick language, e.g. for texting or chatting?
fk lese(&selbst, schlsl: Zeichenkette) -> Ergebnis<Möglichkeit<&Zeichenkette>, Zeichenkette> { wenn lass Etwas(wöbu) = gefährlich { WÖRTERBUCH.als_ref() } { Gut(wöbu.hole(&schlsl)) } anderenfalls { Fehler("Holt das Wörterbuch".hinein()) } }
As a non-Bavarian German, I'm offended by the German = Bavarian stereotype! (jk, it's just mildly annoying sometimes and this is meant to be silly)
Almost perfect. I'm missing the Schwabacher typeface rendering.
I don't like the non-Germanic ref here in als_ref is not Germanic enough. als_ver (from Verweis) would be nicer.
I read it as als_referenz, which arguably makes sense!
For sure it's valid German but for maximum fun it's nice to have it be as Germanic as possible and avoid words that share roots with the standard English programming terms.
Indent with two spaces for code formatting.
  fk lese(&selbst, schlsl: Zeichenkette) -> Ergebnis<Möglichkeit<&Zeichenkette>, Zeichenkette> {
            wenn lass Etwas(wöbu) = gefährlich { WÖRTERBUCH.als_ref() } {
                Gut(wöbu.hole(&schlsl))
            } anderenfalls {
                Fehler("Holt das Wörterbuch".hinein())
            }
        }
This absolutely is not readable to me. But woerterbuch and schluessel should of course not be abbreviated, for legibility.
If German was seriously used in programming languages, I'd hope for some better and shorter terms. Some here might be intentionally too literal translations anyway. "Let" is from mathematics, it's called "Sei" in German. "Sei x = 5". "Anderenfalls" could be "sonst". "Zeichenkette" is just too long and would require some thinking or a historical accident to find a shorter term.
Ready surprisingly nice to me anyway.
I like to imagine a world, a worse one, where programming languages were localised. This might initially have been a versioning nightmare, with different compiler binaries for each localisation. Later, it could become standard practice to ship a single compiler containing all supported localisations, the correct one being chosen from either system language, a project-wide setting, a preprocessor flag in each file, or some combination of these. Everyone would have to learn a little Polish, and "Source Code Translator" would be a profession.
You must learn about Baguette#.
An implementation of OCaml (similar to Haskell, but from France instead of UK), but with french pastries name. It was half a joke, half a serious study project.
https://github.com/vanilla-extracts/ocaml-baguettesharp-inte...
Years ago the research team behind OCaml released Chamelle, a version of the language localized in French, as an April fool's joke:
Previously discussed:
Rouille (338 points, 144 comments, Sept 11, 2021) https://news.ycombinator.com/item?id=28490935
Rost – Write rust code in German (55 points, 16 comments, Nov 9 2021) https://news.ycombinator.com/item?id=29159077
Rost – Rust Programming in German (161 points, 115 comments, Mar 25, 2025) https://news.ycombinator.com/item?id=43488490
Listen, if you didn’t just spend at least 5 minutes trying to make random foreign accents reading the code to yourself out loud trying to figure out what the code does…
We’re different people.
Related: Non-English-based programming languages https://en.wikipedia.org/wiki/Non-English-based_programming_... (not really up to date though)
It's interesting how coding in your own language can make the logic feel completely different.
There were actually localized version of Visual Basic for Applications.
https://de.wikipedia.org/wiki/Visual_Basic_for_Applications?...
That reminds me of LSE, a French BASIC-like programming language.
This is hilarious, thank you for your effort good sir, this is what I pay the internet for! :)
Fantastique !
Let's create "Piaf" to see la vie en rose, the French à la https://codewithrockstar.com/.
This is very lenient French: "fetchez le dico"
Is the compiler now gonna scream at me for using the wrong gender?
This is actually in a very aproachable and lenient french. The compiler will offer you a smoke to cool down and think about your syntax from some distance.
> Arf("fetchez le dico".vers())
Missing!! They should've translated `let` to `le` and `la`.
lol, it'll just say 'Noh!' and then ignore any further input. Especially if you forget the --bonjour flag.
Without the proper -—bonjour flag as first argument, I expect the compiler to work against me, pretending to compile fine while introducing subtle users bugs
Name conflict with the OG rust synchronous web framework: https://github.com/tomaka/rouille
The Russian version linked there is, uh, underwhelming. That whole gopnik vibe is entirely unwarranted. I understand a bit of Spanish and that one is much better in comparison.
I don't know russian, so I can't judge the quality, but Tsoding's lang might suit you better:
This is excellent.
I thought the Russian version was pretty funny. Thanks for calling it out.
idk, as I see it - it's funny if you are 14 years old or non native, so the whole vibe is a bit amusing.
Just like it may be amusing to watch "Don't Be a Menace to South Central While Drinking Your Juice in the Hood" as long as you understand satire.
I wish the Greek one had a vibe at all, past putting the Rust logo on a gyro. Not even a curse word. You could have some fun with compiler errors and allusions to Oxi Day (which was two days ago).
Slovak one does not use diacritics so it’s quite hard to read.
Not surprised this sort of thing pops up specifically for french. France is known to not speak English in some situations even though they know English.
Just wait until the Quebecois government here in Canada hears about this. They are militant about avoiding english at all costs. They changed all the STOP signs in Quebec to ARRET because STOP was too english.
What's wrong with that? You want more Anglomania?
There is also a Rust minimal HTTP server by this name. (Incidentally, one of the few that isn't Async.)
I like the translation of the WTFPL as « la license rien a branler »
If you don’t know the idiom, you should check it out, it’s both particularly vulgar and very commonly used.
"Nothing to wank license", too literally translated
French has so many perfectly normal looking words for sexual stuff. Not particularly long or short, not a compound of other words or a circumscription... nope, just a word for a thing, like table or house or tree.
But is it more vulgar than the English version? Deep question.
L'Horrible
hahaha j'adore que le mot québécois "calisse" est inclus
Be sure to look at the "other languages" section; and then wonder whether all of it was generated by AI.
I can tell you that github.com/jeroenhd/roest was all done manually.
If I'd used AI, I probably would've included grammatical gender for nouns.
The Russian version seems to be handcrafted with humor
It definitely was.
I doubt it. Rouille uses a very simple "word to other word" map that anyone with an hour of free time can fill out for their own language.
The implementation is also rather inefficient, but it's not like such a translated macro will be used for anything serious.
I don‘t think so. At least the french one is quite old and was discussed here before AI was in wide use: https://news.ycombinator.com/item?id=28490935
I remember that many of the other languages popped up a little later.
This is fun. My son is learning esperanto, is there a version for that, maybe a weekend projekto for him.