[Question]
  [
This challenge is inspired by my earlier challenge "Create a program that prints the amount of characters it has, in words".
This challenge's rules are simple: make a program that prints its character count, in words, which works in as many languages as possible.
Each programming language the program works in must make the program print its char count in a different natural language.
E.g. you can make a polyglot which prints "fifty" (suppose this is its char count) in one language and "pedeset" (Serbocroatian for 50) in another, but not a polyglot printing "fifty" in both languages.
An extension to the "don't invent languages to solve the task" rule also applies here: don't make a constructed language just to validate your otherwise nonsense output in some language.
If the polyglot printing "fifty" in one language was tested in another and printed (prant?) "Aijsisdjdsl", it's illegal to make a conlang using "Aijsisdjdsl" as the word for "fifty".
Capitalization is ignored: in case you're printing "one" (somehow) you can print "one", "oNe", "ONE" or anything else.
Base ten is required.
Proper spacing is also required.
In the (unlikely but just for specification) case your program reaches one billion characters or more, use the American number scale. A billion here is 10^9 and a million is 10^6.
Do not use "one hundred and one": use "one hundred one".
Do not use the hyphen. Print forty four, not forty-four.
If the language you use has another script, use it instead of the romanization of it. If your program prints Arabic in some language, it should print (yet again, example with 50) "ÿÆŸÖÿ≥ŸàŸÜ" and not "khamsun".
Use the grammatically correct translation.
For our purposes, we use [Ethnologue](https://www.ethnologue.com) to determine what is and isn't a language in this challenge. It's the most widely used so we'll just go with that.
For simplicity, any languages with identical numerals will be considered the same for this challenge. Using any Japanese/Chinese numeral gives you a score of 1.
If a word is spelled the same in multiple languages, e.g. English and French's "six", it counts as one point toward your score.
Dialects Ethnologue differentiates will be considered different languages as long as they don't fall in the two rules above.
Different compilers of the same programming languages are not differentiated here.
Your score is the amount of languages your program works in, per standard rosetta-stone rules. 
If the two (or more) best answers are tying, the one with the lowest byte count wins.
The encoding used to determine byte count for tiebreakers is UTF-8.
The highest score wins (in case of tie see above). Have fun.
  
[Answer]
# ~~9~~ ~~10~~ ~~12~~ ~~13~~ ~~16~~ ~~18~~ ~~21~~ 23 languages, 1000 bytes
* Bash (prints "duizend", Dutch)
* Zsh (prints "een Dausend", Luxembourgish)
* Dash (and other true POSIX shells) (prints "nje mije", Albanian)
* C (prints "et tusind", Danish)
* C++ (prints "ib txhiab", Hmong)
* [brainfuck](https://esolangs.org/wiki/Brainfuck) (prints "mille", Italian)
* [boolfuck](https://esolangs.org/wiki/Boolfuck) (prints "afe", Samoan)
* [Brainlove](https://esolangs.org/wiki/Brainlove) (prints "mil", Spanish)
* [2DFuck](https://gitlab.com/TheWastl/2DFuck) (prints "sewu", Javanese)
* Python 1 (prints "one thousand", English)
* Python 2 (prints "eintausend", German)
* Python 3 (prints "hal kun", Somali)
* [Asar](https://github.com/RPGHacker/asar) (prints "tuhat", Estonian)
* [><>](https://esolangs.org/wiki/Fish) (prints "jedna hiljada", Bosnian)
* [Gol><>](https://github.com/Sp3000/Golfish) (prints "eenduisend", Afrikaans)
* [Befunge-98](https://esolangs.org/wiki/Funge-98) (prints "o mie", Romanian)
* [Befunge-96](https://web.archive.org/web/20040221081031/http://www.mines.edu/students/b/bolmstea/mtfi/96.html) (prints "otu puku", Igbo)
* [Labyrinth](https://esolangs.org/wiki/Labyrinth) (prints "elf", Maltese)
* [Hexagony](https://esolangs.org/wiki/Hexagony) (prints "ett tusen", Swedish)
* GNU Make (prints "isang libo", Filipino)
* [A Pear Tree](https://esolangs.org/wiki/A_Pear_Tree) (prints "hezar", Kurdish)
* Octave (prints "t≈´kstantis", Lithuanian)
* [Whispers](https://github.com/cairdcoinheringaahing/Whispers) (prints "seribu", Malay)
```
#ifdef    warnings //[[^
#_ if 0
#{
#(________ )
'''''echo' -n<<"'''+r'''":
    @echo   "isang libo"
define N #
1_801_201_
0
1...@
endif
print "tuhat"
macro _()
#}
disp("t\xc5\xabkstantis")
quit
#{
> "seribu"
>> Output 1
'''+r''':
[ -n "$ZSH_VERSION" ]&&echo een Dausend||([ -n "$BASH_VERSION" ]&&echo duizend||echo nje mije)
:<<"endmacro;\"^*///]\"\"\"#/t#"
#endif
#include<stdio.h>
int main(){puts(sizeof('1')-1?"et tusind":"ib txhiab");}
/*
print"hezar";exit;<<'/*';#NJ@G@GMCI
1234567890123456789012345678901234567890123|u;ts;6ie$;;tn;e@$<
]+[+++[[<+>->+++++>+<<]+>]<<<.<.+++.(.<.)>>+;+;;;;+;;+;;+;;+;;+;;+;+;+;+;+;;+;;+;[-]]![!.!...!..!..!.!..!..!.!.!.!.!...!.!...!.!...!.!.!.!.!][
'''
print(["hal kun","eintausend","one thousand"][(type(1==1)==type(1))+(3/2==1)])
r""""
01234567891234567890123456789012                               1
                       >"ukup uto">:#,_@
                H"eenduisend"\
        >o<"jedna hiljada"~\ u
#}
endef #   >"eim o"4k,@ /"`"/"/"\
endmacro;"^*///]"""#/t#
```
There should be a hard tab at the start of line 6.
[Try it online!](https://tio.run/##hVNpc5swEP3c/RXykokhxGCco6nB1L0mSWeazDQz/VAgFBu5yIdwQZq4OfrXXQFOMtOk7VuhY7Uj3q6erjJWLmlR9tZrjU1SOiEKV0nBGf9eEtsOgkvQYsImpAvaDWh6vAExoF2BjrO8TTrc81CtzEJ12IcXw8qvjkJWJvw7mbNRjqCOZ5ySM6KBEx91nbinPuiCY1nWEChP2QSWBeOCoJBZIhAWybjISawboN1BqqjqKMLV@CBcJaNZKRIuWIkG/JBMVPR8giUt2Egi@D45l2IpBXHgnlgfAsWU4NbXi5P4y4fPF6fnZ0ii7e2aLKWcvE9kqXjc3uqbyLdvngtNJbuuw@oVn1KyYFNqQF9VQflr1m6Ilzu2bUchVqbZQkPQmiQ1xsdzmVKvFCnLrcyHKulFwrhu3CjOpV6qH@QTve20jY7zGqkgQpaMp9hHNiJilbFkhIZ7B/ZOUzLM6HVSoEtXTLie17Z32q529nF4PDz@9O4UnN7e/sHhy6NX3f/ObqUrSveQ0S3XFdylwy0PIjMwTTMIPNPv@GYF3/S8yPQjz/Msz1IOS1ej4fuma7oK5p/t3poWdKKoFbSslrr61qY9jo1ZT/raoqC60CZrPcAsmZOZ5LiLVDma@1OLXAlNZLlU8ksxCnTxc0l1ZzBwjMGgmRuGqe/ZvcoVGVCgAjxW4vnikH/Dgb9s@ChnckmkyNHva7vx8EngCSr9KV3V9MOHbT/3cEpTnpCMzadJmuCvkMjqNag49Vq1@nDKFiTH/dnukNj4DW1lITwIcaNDlV8lQlivfwM) (use the switch languages button to try them all)
Length is exactly 1000 ASCII characters, and also 1000 bytes.
Asar is a SNES assembler that has quite sloppy input parsing and thus accepts a lot of inputs that one may consider invalid. I used version 1.71 for this, downloadable [here](https://github.com/RPGHacker/asar/releases/tag/v1.71), and depended on quite a few bugs, so there is a chance this will break in later versions.
All of the other languages are well-known enough to be on TIO.
I used Google Translate for the translations, so they may not be perfectly grammatically accurate. If anyone knows some of the languages better, please suggest improvements, I've got some wiggle room here :)
Credits: @JoKing for some minor optimizations regarding brainfuck, befunge, (gol)><>, hexagony, and python. @flawr for suggesting and helping with octave. @caird coinheringaahing for suggesting whispers.
Fun fact: I made most of this polyglot months ago. It included the first 10 languages mentioned here. (edit: I've since shuffled the language list around a bit so it makes more sense, but check the 2nd oldest version of this polyglot in the edit history and add hexagony to get that list).
# Explanation (slightly outdated)
This explanation was made for an older revision. It's hard enough keeping track of all the natural language shuffling (to make more difficult programming languages use shorter natural language words) and Hexagony's constant grid shifting, let alone update the explanation every single revision. I'm leaving this here since it still gives a good overview of how what path most of these languages take.
## Asar
Asar is a SNES assembler written by Alcaro in 2011, intended to be backwards-compatible with xkas (written by byuu in around 2006). It doesn't have the nicest code. The first line begins with a special kind of label definition, the label is called `ifdef`. Then follows a `warnings` command, which is supposed to control when warnings are thrown. Usually it's followed by either `push` or `pull`, but it doesn't reject other words following it. So that's the first line: a label-definition followed by a no-op. The 2nd line is a similar label definition (this time the label is called simply `_`) followed by an `if` statement. The condition is 0, so the contents of the if are ignored. This means we can pretty much go wild inside it, the only rule we have to follow is that all double-quotes must be paired. The end of that if statement is at the `endif` on line 10. After that comes a simple print statement which prints the output. Then comes a macro declaration. Declaring a macro that isn't used is pretty much equivalent to an `if 0`. The end of the macro declaration is on the very last line. In Asar, comments are started with `;`, so the rest of the last line is ignored.
## Bash, Zsh, Dash
The first 3 lines are just regular comments. The 4th line is equivalent to `echo -n <<"'''+r''':"`. This is an echo without a linebreak following it. Then we have a heredoc that ends at any occurrence of `'''+r''':`. The contents of the heredoc are piped to the stdin of that echo command, but that doesn't matter since echo ignores its stdin. After the end of the heredoc on line 14, we have regular shell code that checks whether the variables for either zsh or bash are defined and chooses what to print based on that. After that, we have the null command `:`, which does nothing, into which we pipe the rest of the script using another heredoc. The heredoc ends with `endmacro;"^*///]"""#/t#`, which just happens to be the very last line of the script.
## C, C++
The first line is a preprocessor directive which checks whether the define "warnings" is defined. There's also a comment after the directive. `warnings` isn't defined, so the contents of the block are skipped. There are a bunch more garbage preprocessor directives inside the skipped if branch, but they are ignored too. The `#endif` is on line 18. After that we have a standard C program. It checks whether the size of a character literal is greater than 1 or not. If it's greater, we are in C, because in C character literals are actually of `int` type, which has a size of at least 2 bytes on literally every platform in use today. In C++, however, the type of a character literal is `char`, which is defined to have a size of 1, so a different branch is taken.
The rest of the code is a single comment, started with /\* at line 21. It's terminated in the middle of the last line, but followed immediately by a single line comment.
## Brainfuck
On the first line, we have 2 open brackets. This is because one of them is eaten by the heredoc that ends the shell part, which is before the brainfuck part. There are some balanced brackets within the skipped part too, but they don't matter because they are balanced. The next closing bracket is on line 21, which is also the start of the brainfuck code. I used [this text-to-brainfuck converter](https://copy.sh/brainfuck/text.html), because somehow it generated even better output than BF-Crunch. Then follows the boolfuck code, which is mostly ignored due to `;` not being defined. The increments don't matter either, we just switch to the next cell which has never been written to so the next open bracket is a guaranteed jump. The next closing bracket after that is on the very last line, and there are no brainfuck instructions after it.
## Boolfuck
The boolfuck control flow is quite similar. However, once the brainfuck code is reached, most of it is ignored as `-` isn't defined in boolfuck. The area with `+` and `;` is where the output is actually printed. It just prints the string "mil" bit by bit, with `+` negating the current bit and `;` outputting it. The rest of the control flow is identical to brainfuck.
## Python 1, 2, 3
The first 3 lines are regular comments. The 4th line starts with a triple-quoted string literal, delimited by single quotes. This string literal is often closed and reopened because I needed to get a backslash in somewhere (I've forgotten where), so I needed the string literal to be raw, but I couldn't put the r before the first quotes. Anyways, the first place where the string literal is closed and not immediately followed by another string literal is on line 23, which is the start of the Python code. This code uses a few simple tests to determine which version of Python it's running on: in Python 1.6, there was no separate boolean type, so the results of comparisons were just `int`s. The first condition checks that. The second condition checks whether division rounds down or not. In Python 2, division on integers rounded the result down, whereas in Python 3, it results in a floating point answer. After the Python code, we have another raw string literal that lasts until the last line, where it is immediately followed by a comment.
## ><>, Gol><>
Now we get to the 2D languages. Gol><> is almost perfectly backwards compatible with fish, so they start execution the same way. In fish, execution starts from the north east ("top left") corner of the program, with the instruction pointer pointing west. In fish, `#` is a mirror which reflects the instruction pointer back in the direction it came from. The `#` causes the IP to point west instead. In fish, program space is topologically a torus, so going off the western edge results in reappearing at the eastern edge of the program. There it encounters `^`, which changes the instruction pointer's direction to north. Execution then continues from the very bottom of the script. The IP goes right past the very last character of the program and hits the `/` on line 31. The `/` reflects the IP like a mirror, so it'll go east again. Here is where we determine if we are running fish or golfish. In golfish, quotes inside string literals can be escaped with ```. So in golfish, the string literal is only terminated on the 3rd quote on that line. In regular fish, however, the backtick escape doesn't exist, so the string literal ends after the 2nd quote. (The 4th quote is needed to keep Asar happy about paired quotes). Then, both IPs are reflected upwards. The fish one goes west on line 30 and follows a pretty simple text printing program. The golfish one goes west on line 29, after switching to a different stack with the `u` in its path on line 30. There, it follows a very simple string printing code too (just push the string on the stack and call `H`, which exits and dumps the whole stack as ASCII text).
## Befunge-98
In Befunge-98, execution starts out in the north west ("top left") corner of program space, pointing east. `#` is a trampoline command, it skips the next instruction. The letters a-f just push their hex value on the stack. Spaces are no-ops. `w` pops 2 items from the stack, compares them, and turns left or right depending on which one is larger. here, `f` is larger than `e` (15 is larger than 14), so we turn left, with the IP pointing north. Now we jump to the bottom of the program, like in fish, and follow the path of arrows to line 31. This uses a simple string printing code with the `k` operator, which repeats the next instruction (print character) some number of times, 5 in this case.
## Hexagony
This was the one language that probably costed me the most time while writing this thing. This explanation is a bit oversimplified, go look at Hexagony's README or wiki page if you want to learn more. Hexagony reformats your program into a hexagon. Then execution starts at the north-west corner. The first command, `#`, switches to the IP with the index of the current memory cell (there are 6 IPs, each one starting at a different corner of the hexagon). Memory is initialized to all 0's though, so this switches to the first IP, which is the one that is already executing. All alphabetic characters simply set the current memory cell to their value, so most of the rest of the 1st line is just no-ops. Then there's a mirror, `/`, which makes the IP point north-west (as if it got reflected off the mirror). This means the IP will wrap around to the very bottom of the hexagon. There, it happens to hit the `/` at the very end of the script. This is also a mirror and makes the IP go east again. Then we set the current memory cell to `t` and use the "switch IP" command again. Since there are only 6 IPs, the current memory cell is taken modulo 6 when switching, so it goes to the 3rd IP, which starts at the eastern corner of the hexagon. This IP starts out moving southwest and it executes some useless operations before reaching the end of line 23 in the original code. There it uses the `$` operator to skip over some characters the first time around, then encounters `|` which turns it around and prints some more characters.
## Labyrinth
In labyrinth, control flow is determined by the program's layout. All spaces and alphabetic characters are considered walls. The `#` command pushes the number of items on the stack, which is 0, to the stack. Then execution continues in the only possible direction, south. Here, the number of items on the stack is pushed again, this time pushing a 1. Now there's 2 directions to go: south again or east. Since the topmost value on the stack is positive, execution would try to go west, but that path is blocked, so it goes east instead. `_` pushes a 0. Now there's again 2 directions to go, but we came from one direction and unless nothing else is possible, the IP will never flip around and go back the direction it came from, so we continue south. Here we have a `(`, which decrements the top of the stack. This means the topmost item is now `-1`. Excluding the direction we came from, there's 3 directions to go, but since the top of the stack is negative, we go east. Here we push 0 a bunch of times, which means we continue east for as long as possible. In the end, we go south because that's the only other place to go. There we find a `'`, which is a no-op if debugging output isn't enabled. Now, labyrinth treats tabs as a single space, so the character south of the `'` is actually `"` from the start of the echo's parameters. Execution continues there. Below that, there is only one path to follow, which leads to the 4th character of line 9. There, we simply construct the ascii values corresponding to "elf" and print them.
## Make
The first 3 lines are comments. The 4th line is somehow a valid target name. (To be honest, I have no idea either about why this works.) Since this is the first target in the makefile, it's what gets executed when no argument is given to make. The rule just prints the character count. Then we define a variable called N which contains the rest of the script. It ends on the 2nd-to-last line with the `endef` command. Following it is a comment that ends with a backslash. This causes make to interpret the next line as part of the comment too.
## A Pear Tree
A Pear Tree starts execution by finding the longest substring of the program whose CRC32 is 0. Then it shifts the whole program so that said substring is at the start of the program. This long substring with a CRC32 of 0 is `print"hezar";exit;<<'/*';#NJ@G@GMCI`, which *just happens to be* valid Perl code. No, actually I used a tool called [crchack](https://github.com/resilar/crchack) to generate some letters to add to a comment so that the string's CRC is 0. So this Perl program is shifted to the very beginning of the program. It contains a print statement, an exit statement and a heredoc. The heredoc is terminated by the line that was right before the perl script originally, and thus is at the very end of the program now. So the heredoc skips the entire rest of the script and all of the syntax errors that would arise from not doing so.
[Answer]
# 6 languages, prints 80
```
//'≈∏¬Ø"y"¬´q
   √°ttat√≠u/*
";"
√•o ÂÖ´
t?  ÂçÅ
t@   "
io    o
oo     @
"o
0o
1 K`ochenta
```
(There's also 5/90 solution with a different approach in the edit history if you're interested)
## [05AB1E](https://github.com/Adriandmen/05AB1E)/[English](https://www.ethnologue.com/language/eng) - `eighty`
```
//'≈∏¬Ø"y"¬´q
//          # no-ops
  '≈∏¬Ø       # push dictionary string "eight"
     "y"    # push literal string "y"
        ¬´   # concatenate
         q  # end program
```
[Try It Online!](https://tio.run/##yy9OTMpM/f9fX1/96I5D65UqlQ6tLuRSUFA4vLCkJLHk8NpSfS0uJWslrsNL8xWetq7mKrFXUHja28hV4gBUpMSVmQ@kFPK58sG0ggOXUj6XQT6XoYJ3Qn5yRmpeSeL//wA "05AB1E ‚Äì Try It Online")
Once execution ends, the stack top (`eighty`) is implicitly printed, and nothing later on in the file will be considered at all.
## [ink](https://github.com/inkle/ink)/[√çslenska](https://www.ethnologue.com/language/isl) - `√°ttat√≠u`
```
   √°ttat√≠u/*
```
[Try It Online!](https://tio.run/##y8zL/v9fX1/96I5D65UqlQ6tLuRSUFA4vLCkJLHk8NpSfS0uJWslrsNL8xWetq7mKrFXUHja28hV4gBUpMSVmQ@kFPK58sG0ggOXUj6XQT6XoYJ3Qn5yRmpeSeL//wA "ink ‚Äì Try It Online")
The very first line in the file is a comment, due to the `//`. The `/*` at the end of this line begins a multi-line comment (which we never have to close), so ink doesn't care about anything later on in the file either.
That just leaves the text `√°ttat√≠u`, which ink happily prints, because that is what ink does.
## [Alice](https://github.com/m-ender/alice)/[Êó•Êú¨Ë™û](https://www.ethnologue.com/language/jpn) - `ÂÖ´ÂçÅ`
```
/
  "
   ÂÖ´
    ÂçÅ
     "
      o
       @
```
[Try It Online!](https://tio.run/##S8zJTE79/19fX/3ojkPrlSqVDq0u5FJQUDi8sKQkseTw2lJ9LS4layWuw0vzFZ62ruYqsVdQeNrbyFXiAFSkxJWZD6QU8rnywbSCA5dSPpdBPpehgndCfnJGal5J4v//AA "Alice ‚Äì Try It Online")
In Alice, `/` is a mirror, but unlike in other 2D languages you might be familiar with, they reflect you 135 degrees rather than 90. So after encountering the `/`, we move diagonally, encountering `"ÂÖ´ÂçÅ"` (which pushes the string `ÂÖ´ÂçÅ` onto the stack), `o` (which outputs it), and `@` (which terminates the program).
## [><>](https://esolangs.org/wiki/Fish)/[Norsk](https://www.ethnologue.com/language/nor) - `√•tti`
```
//
";
√•o
t?
t@
io
oo
"o
0o
1
```
[Try It Online!](https://tio.run/##S8sszvj/X19f/eiOQ@uVKpUOrS7kUlBQOLywpCSx5PDaUn0tLiVrJa7DS/MVnrau5iqxV1B42tvIVeIAVKTElZkPpBTyufLBtIIDl1I@l0E@l6GCd0J@ckZqXkni//8A "><> ‚Äì Try It Online")
The `/` at the start deflects the instruction pointer upwards, after which it wraps around to the bottom, travelling up the first column.
It then pushes the numbers `1` and `0` and the characters `oittin` onto the stack, bounces around on the mirrors at the top, and travels up along the second column.
In the second column, we print the first four items on the stack (`√•tti`). Then we shuffle the last three values around a bit using `@`, leaving the `0` at the top, which thanks to the `?` makes us skip the final print instruction, before we arrive at the `;` which ends the program.
## [Gol><>](https://github.com/Sp3000/Golfish)/[Svenska](https://www.ethnologue.com/language/swe) - `√•ttio`
```
//
";
√•o
t?
t@
io
oo
"o
0o
1
```
[Try It Online!](https://tio.run/##S8/PScsszvj/X19f/eiOQ@uVKpUOrS7kUlBQOLywpCSx5PDaUn0tLiVrJa7DS/MVnrau5iqxV1B42tvIVeIAVKTElZkPpBTyufLBtIIDl1I@l0E@l6GCd0J@ckZqXkni//8A "Gol><> ‚Äì Try It Online")
Works just like ><> except the `@` shuffles the stack values in a different way, so we end up not skipping the last print, thus printing `√•ttio` instead of `√•tti`.
## [Retina](https://github.com/m-ender/retina/wiki/The-Language)/[Espa√±ol](https://www.ethnologue.com/language/spa) - `ochenta`
```
1 K`ochenta
```
[Try It Online!](https://tio.run/##K0otycxLNPz/X19f/eiOQ@uVKpUOrS7kUlBQOLywpCSx5PDaUn0tLiVrJa7DS/MVnrau5iqxV1B42tvIVeIAVKTElZkPpBTyufLBtIIDl1I@l0E@l6GCd0J@ckZqXkni//8A "Retina ‚Äì Try It Online")
The first ten lines are presumably interpreted as replacement stages, but since we don't have any input to manage, we don't really care what they do. the last stage, however, is a constant stage - we can tell because the config string before the backtick has a `K` in it. That means we just discard any input that stage would get from the stages before it, and output `ochenta`.
[Answer]
# 3 Languages, 800 chars
* [PHP](https://php.net/), Norwegian, Outputs `√ÖTTE HUNDRE`
* [Emoji](https://esolangs.org/wiki/Emoji), Persian, Outputs `Ÿáÿ¥ÿ™ÿµÿØ`
* [COW](https://bigzaphod.github.io/COW/), English, Outputs `EIGHT HUNDRED`
```
<?=['√ÖTTE HUNDRE','‚õΩŸáÿ¥ÿ™ÿµÿØüöò‚û°','
MoO
MoO MoO
MoO MoO MoO
MoO MoO MoO MoO
MoO MoO MoO MoO MoO
MoO MoO MoO MoO MoO MoO
MoO MoO MoO MoO MoO MoO MoO
MoO MoO MoO MoO MMM MoO MoO MoO
MoO MoO MoO MoO MoO MoO MoO MoO MoO
MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO
MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO
MoO MoO MoO MoO Moo MoO MoO MoO MoO Moo MOo MOo
Moo MoO Moo MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO
MoO MoO Moo MMM Moo MoO MoO MoO MoO MoO MoO MoO MoO MoO
MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO
MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO
Moo MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO Moo MOo MOo
MOo MOo MOo MOo MOo Moo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo Moo MMM
MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO Moo MMM MoO Moo MOo Moo'][0];
```
[PHP - Try it online!](https://tio.run/##K8go@P/fxt42Wv1wa0iIq4JHqJ9LkKu6jvqj2Xtvtt/YcmPVja031n@YP2vGo3kLgcJcvvn@IKyARKOzsfFxieETxy7n60usXlLUkKIOh9p8Baxi/mDMhZDPJ8OOfKi/86ntD2rqherPJ1MvUlj5w9kInI9FDBeGhBcFfslHSmdwM9Vjow1irf//BwA "PHP ‚Äì Try It Online")
[COW - Try it online!](https://tio.run/##S84v///fxt42Wv1wa0iIq4JHqJ9LkKu6jvqj2Xtvtt/YcmPVja031n@YP2vGo3kLgcJcvvn@IKyARKOzsfFxieETxy7n60usXlLUkKIOh9p8Baxi/mDMhZDPJ8OOfKi/86ntD2rqherPJ1MvUlj5w9kInI9FDBeGhBcFfslHSmdwM9Vjow1irf//BwA "COW ‚Äì Try It Online")
[Emoji - Try it online!](https://tio.run/##S83Nz8r8/9/G3jZa/XBrSIirgkeon0uQq7qO@qPZe2@239hyY9WNrTfWf5g/a8ajeQuBwly@@f4grIBEo7Ox8XGJ4RPHLufrS6xeUtSQog6H2nwFrGL@YMyFkM8nw458qL/zqe0PauqF6s8nUy9SWPnD2Qicj0UMF4aEFwV@yUdKZ3Az1WOjDWKt//8HAA "Emoji ‚Äì Try It Online")
[Answer]
# ~~3~~ ~~8~~ 9 languages, 300 characters
```
                            //¬Ædi.‚Ä¢pa√º¬æp‚Ä¢√´"ÂÖ©Áôæ"‚Äû‚Äû√≠¬∞¬°r\}qüí¨trescientosüí¨‚û°\u000A\u002F\u002A
    //\
{{Write("trois cent"/*\u002A\u002Finterface M{static void main(String[]a){System.out.print("driehonderd"                                             /*
    #include<stdio.h>
 int main(){{puts(sizeof'a'<sizeof(int)?"trezentos":"dreihundert"/**/);}}//
```
[Try it online in 05AB1E / Chinese](https://tio.run/##LU@7TsNAEKztrzgdRWwXPosSIlAaOqoUFITi8G3ISsRn7tZIxIqUhh@gowkKHeIhPgClcP7EEqLlD8zZRlqNZlezszvaykuEpmGMea48B/9UiOpDYVyvnnO5@6q2uWO7V/59//LzuOX1au1q9159VhszWd78Pj28kQGbImSkbdvW682kSJJk1OL@SYcj3/lO/LI8M0gQcDIaLUvdDhdRr@jVmBGYqUyBnZaWJGHKbjUqNpeYBWMymF2dX8iwHN9ZgnmsC4pzN6SAK4Mw05kCo3gXyOuDtVREvreHWXpdKBhaUqjj2ZHP3F5vHJZlXpANLC5ATwdyMOxZ4BThsfsWFl08fuDOAM6K9kz7eiTCw@VSiKb5Aw) - outputs `ÂÖ©Áôæ`.  
[Try it online in 05AB1E (legacy) / Italian](https://tio.run/##LU@7TsNAEKztrzgdRewUPoNEAxEoDR1VCgpMcfg2ZCXiM3drJGJZSsMP0NEEhQ7xEB@AUjh/EgnR8gfmHCOtRrOr2dmdeF9e7kLTMMY8V56DfypE/aEw2syfc7n@qle5Y@tX/n3/8vO44pv5wtX6vf6slyapbn6fHt7IgE0RMtK2bTeLZVLEcTxsce9ki0Pf@SZ@WZ4ZJAg4GY2WpW6Hi36n6NSYEZixTIGdlpYkYcpuNSo2lZgFIzKYXZ1fyLAc3VmCaaQLinI3pIArgzDRmQKj@DaQ1wVrqej73g5m6XWhYGBJoY4mRz5ze51xWJZ5QTawOAM97sneoGOBU4TH7luYbePxA3cGcFK0Z9rX@yI8rCohmuYP) - outputs `trecento`.  
[Try it online in 2sable / English](https://tio.run/##LU@7TsNAEKztrzgdRWwXviglRKA0dFQpKAjF4dvglRKfuVsjEStSGn6AjiYodIiH@ACUwv6TSIiWPzDnGGk1ml3Nzu4MrLyaQdMwxjxXnoN/KkT1oTDerZ5zWX9V29yx@pV/37/8PG75brV2Vb9Xn9XGTJY3v08Pb2TAJggZadu2u/VmUvT7/VGLg9M9jnznO/HL8twgQcDJaLQscTtcRJ2iU2NGYKYyAXZWWpKECbvVqNhcYhaMyWB2fXEpw3J8ZwnmsS4ozt2QAq4MQqozBUbxfSCvC9ZSEfneAWbJrFAwtKRQx@mxz9xeZxyWZV6QDSwuQE97sjfsWOAU4Yn7Fhb7ePzQnQFMi/ZM@3okwqPlUoim@QM) - outputs `three hundred`.  
[Try it online in Java 8 / Dutch](https://tio.run/##LU@7TsNAEKztrzgdRexI@CJKiEBp6KhSUGCKk@@CNxCfuVtHIidLafgBOpqg0CEe4gNQCudPLCFa/sCcY6TVaHY1O7sz5XO@PxXXTUMI8Vx5Dv4pY9WHgKhePud8@1Vtcse2r/T7/uXncUPr5crV9r36rNY6Lm9/nx7eUEuTgMxQmbatV@u4GAwGoxYPTnc48p1v7Ft7rgFlQFErMCRxO5T1O0WnhgylnvBEkjNrkCMkZK5AkBmHLBijhuzq4pKHdnxnUM4iVWCUuyEGVGiQqcqE1ILuAnldsJayvu/tQZbcFEIODQpQUXrsE7fXGYfW5gWawMBCqkmP94YdC5wiPHHfysUuHj10ZySkRXumfb3PwqOyZKxp/gA) - outputs `driehonderd`.  
[Try it online in C# (Visual Interactive Compiler) / French](https://tio.run/##LU89S8RAEK2TX7GsxSUBs8FSD@UaO6srLIxF2N0zA1427k4ELwSu8Q/Y2ZycnfiBP0CuSP5JQGz9B3GTCMPjzfDmzTxu9rmBriOEOLYcC/@UsfpDQNiun/Ok@ap3uWXNK/2@f/l53NF2vbHVvNef9VbH1c3v08Mbamk4yAyV6dt2s42LKIpmPR6cDjhzrW/sluW5BpQeRa3AEG53KAtGxaiGDKVeJFySs9JggsDJrQJBlglk3hw1ZFcXl4lfzu8MymWoCgxzO0SPCg0yVZmQWtAhkDMG6ykLXGcPMn5dCDk1KECF6bFL7N5o7JdlXqDxDKykWkySyXRknlX4J/ZbuRri0UN7RkJa9Gf61wPmH1UVY133Bw) - outputs `trois cent`.  
[Try it online in C / German](https://tio.run/##LU89T8MwEJ2TX2GZoUkk4ooRKlAXNqYODJTBst3mpNYO9gWJRpW68AfYWIrKhvgQPwB1SP9JJcTKPwhOgnR6end69@6eOBQzrqd1TQgJfAUe/ilj1YeEdL96zvnuq9rmnu1e6ff9y8/jlu5Xa1@79@qz2tjx8ub36eENrXIClEbjmna/3oyLfr8/bPDovMVh6H3HYVleWkAVUbQGHBF@h7KkU3Rq0KjshAtFLkqHHEGQWwOSzDnoaIQW9PTqmsfl6M6hmqemwDT3Q4yotKAyo6WykraBgi5YQ1kSBgegxayQauBQgkmz05D4vc44Lsu8QBc5WCgz6fHeoGORV8Rn/lu1aOPRY39GQVY0Z5rXExafLJeM1fUf) - outputs `dreihundert`.  
[Try it online in C++ / Portuguese](https://tio.run/##LU89T8MwEJ2TX2GZoUkk4ooRKlAXNqYODJTBst3mpNYO9gWJRpW68AfYWIrKhvgQPwB1SP9JJcTKPwhOgnR6end69@6eyPNDMeN6WteEkMBX4OGfMlZ9SEj3q@ec776qbe7Z7pV@37/8PG7pfrX2tXuvPquNHS9vfp8e3tAqJ0BpNK5p9@vNuOj3@8MGj85bHIbedxyW5aUFVBFFa8AR4XcoSzpFpwaNyk64UOSidMgRBLk1IMmcg45GaEFPr655XI7uHKp5agpMcz/EiEoLKjNaKitpGyjogjWUJWFwAFrMCqkGDiWYNDsNid/rjOOyzAt0kYOFMpMe7w06FnlFfOa/VYs2Hj32ZxRkRXOmeT1h8clyyVhd/wE) - outputs `trezentos`.  
[Try it online in Whitespace / Japanese](https://tio.run/##LU@7TsNAEKztrzgdRewUvogSIlAaOqoUFJjC8l3wSsRn7tYgcrKUhh@gowkKHeIhPgClcP7EEqLlD8w6RlqN5k6zOzO3GaCyRZKqtmWMeTQewT8Vov6QEDXL5yLZftWbgtj2lX/fv/w8bnizXNFs3@vPem3i6vr36eENjbIpqBy17Z7Nah2Xo9Fo0uH@yQ4nPt2NfefODHkHHI0Gy1La4WLYK3o15KjMjKKxU2cxQUjZjQbJ5gnkwRQN5JfnF0nopncW1TzSJUYFfWLApQGV6VwqI/mukNcX66gY@t4e5OlVKdXYogQdZUc@o73@cOhcUaINLCyUng2SwbhnASnCY0qrFrt6/IBsFGRlZ9NFH4rwsKqEaNs/) - outputs `‰∏âÁôæ`.  
[Try it online in Emoji / Spanish](https://tio.run/##LU@7TsNAEKztrzgdRWwXvogSIlAaOqoUFITC8m3wIuIzd2skcoqUhh@gowkKHeIhPgClcP7EEqLlD8zZRlqNZlezszswV1fYNIwxz5Xn4J8KUX1IjOvVc5Hsvqpt4djulX/fv/w8bnm9WrvavVef1UZPlze/Tw9vpMGkCDkp07b1ejMth8PhuMX9kw7HvvOd@taeaSQIOGmFhqVuh4uoV/RqzAn0LEmBnVpDCWHKbhVKNk8wDyakMb88v0hCO7kzBPNYlRQXbkgBlxohU7kELXkXyOuDtVREvreHeXpdShgZkqji7Mhnbq83Dq0tSjKBwQWo2SAZjHoWOEV47L6FRRePH7gzgFnZnmlfj0R4uFwK0TR/) - outputs `trescientos`. 
## Explanation:
**[05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands) / Chinese and 05AB1E (legacy) / Italian and [2sable](https://github.com/Adriandmen/2sable) / English:**
```
                    # Spaces/tabs are no-ops
  //                # Divide twice (without input)
                    # Legacy 05AB1E / new 05AB1E: this pushes an empty string
                    # 2sable: the stack remains empty
    ¬Æ               # Push -1
     d              # Legacy 05AB1E: check if this -1 is an integer (truthy)
                    # New 05AB1E: check if this -1 is non-negative (‚â•0) (falsey)
                    # 2sable: check if this consists only of digits (falsey)
      i             # If it is truthy:
       .‚Ä¢pa√º¬æp‚Ä¢     #  Push compressed string "trecento"
      √´             # Else:
       "ÂÖ©Áôæ"       #  Push string "ÂÖ©Áôæ"
       ‚Äû‚Äû√≠¬∞¬°        #  Push dictionary string "one hundred"
             r      #  Reverse the stack
                    #   New 05AB1E: "","ÂÖ©Áôæ","one hundred" ‚Üí "one hundred","ÂÖ©Áôæ",""
                    #   2sable: "ÂÖ©Áôæ","one hundred" ‚Üí "one hundred","ÂÖ©Áôæ"
              \     #  Discard the top item
                    #   New 05AB1E: "one hundred","ÂÖ©Áôæ","" ‚Üí "one hundred","ÂÖ©Áôæ"
                    #   2sable: "one hundred","ÂÖ©Áôæ" ‚Üí "one hundred"
      }             # Close the if-else
       q            # Terminate the program
                    # (after which the top of the stack is output implicitly as result)
                    # And any character after it are no-ops
```
[See this 05AB1E tip of mine (sections *How to use the dictionary?* and *How to compress strings not part of the dictionary?*)](https://codegolf.stackexchange.com/a/166851/52210) to understand why `‚Äû‚Äû√≠¬∞¬°` is `"one hundred"` and `.‚Ä¢pa√º¬æp‚Ä¢` is `"trecento"`.
**[Emoji](https://esolangs.org/wiki/Emoji) / Spanish:**
```
                    # Some no-ops
üí¨trescientosüí¨    # Push string "trescientos"
                ‚û°  # Print the top to STDOUT
                    # Some more no-ops
```
**[Whitespace](https://web.archive.org/web/20150618184706/http://compsoc.dur.ac.uk/whitespace/tutorial.php) / Japanese:**
Only spaces, tabs, and newlines are relevant for Whitespace programs and every other character is ignored. So the program is actually (`S` = space; `T` = tab; `N` = newline):
```
SSSTSSTTTSSSSSTSSTN
TN
SSSSSTTTSTTSSTTTTTTSN
TN
SS
```
1. `SSSTSSTTTSSSSSTSSTN` push the integer 19977 to the stack (first `S` is to enable stack manipulation; second `S` is to push a number; third `S` is positive (`T` would have been negative); the `S` and `T` that follow are the integer in binary where `S=0` and `T=1`; and the trailing `N` finishes this command.
2. `TNSS` print this integer as character (with this unicode value) to STDOUT (first `TN` enables I/O; the following `S` is to output to STDOUT; and the second `S` to output as character (`T` would have been as integer)).
3. `SSSSSTTTSTTSSTTTTTTSN` push 30334
4. `TNSS` print as character again
**C# (Visual Interactive Compiler) / French:**
The first line contains some no-op spaces/tab, and a comment (`//` starts the comment, making everything after it on that same line no-ops).  
The second line is similar, again a no-op tab and a comment.  
The third line starts with `{{Write("trois cent"`, and `/*` starts a (potentially multi-line) comment-block. This stops at the `*/` on the last line, making everything in between no-ops. After which `);}}` is part of the C# program again (and the very last `//` is a comment again, only there to make the program-size 300).
So the non-comment parts of the C# (Visual Interactive Compiler) program are:
```
{{Write("trois cent");}}
```
The `{{` and `}}` are code-blocks, and basically no-ops in this case.  
The `Write("trois cent");` prints this text to STDOUT.
**C / German and C++ / Portuguese:**
First line is a comment again.  
The `//\` on the second line is relevant in C and C++, as it will comment out the entire next line.
The `#include<stdio.h>` and `int` in front of the `main`-function are mandatory in C++ (and optional in C; it would run fine without these two parts, but would generate some warnings).  
The `/**/` and `//` are again comments.
So the non-comment parts of the C and C++ programs are:
```
#include<stdio.h>         // Required include for `puts` in C++
int main(){               // Mandatory main-function:
  {                       //  No-op code-block (similar as the C# part above)
    puts(                 //   Print to STDOUT with trailinb newline:
      sizeof'a'           //    If the byte-size of character 'a' 
      <                   //    is smaller than
      sizeof(int)?        //    the byte-size of an integer:
       "trezentos"        //     Print "trezentos"
      :                   //    Else:
       "dreihundert");}}  //     Print "dreihundert"
```
In C (and Java), values of type `char` are saved as an integer. `sizeof(int)` and `sizeof'a'` will therefore both result in `4` in C, and `4<4` is falsey, so `"dreihundert"` is printed. In C++ (and C#), values of type `char` are actually a separated type saved as characters. `sizeof'a'` will therefore result in `1` in C++, and `1<4` is truthy, so `"trezentos"` is printed.
**Java 8 / Dutch:**
In Java, we can use `\uHEX` as unicode values, which are read as characters after compilation. The very first line therefore compiles to (I'll ignore the leading spaces/tabs for now to make it a bit more compact):
```
//¬Ædi.‚Ä¢pa√º¬æp‚Ä¢√´"ÂÖ©Áôæ"‚Äû‚Äû√≠¬∞¬°r\}qüí¨trescientosüí¨‚û°
/*
```
The `\u000A\u002F\u002A` are a newline, `/` and `*` respectively. Just like in the C# program, this will stop at the first `*/`, which is the `\u002A\u002` on the third line in this case. There the Java program starts:
```
interface M{static void main(String[]a){System.out.print("driehonderd"
```
After that come a bunch of no-op spaces/tabs again, followed by another `/*` which stops at the same place as the C# program. So the full Java program is:
```
interface M{static void main(String[]a){System.out.print("driehonderd");}}
interface M{                    // Class:
  static void main(String[]a){  //  Mandatory main method
    System.out.print(           //   Print to STDOUT
      "driehonderd");}}         //    The string "driehonderd"
```
# Why these languages?
**Natural languages:**
* I'm fluent in English and Dutch
* I've learned French and German at high school
* I watch quite a lot of Japanese anime
* I know a few loose words in Spanish, Italian, and Portuguese
* Chinese was short enough to fit after adding 2sable ;)
**Programming languages:**
* I'm pretty skilled at Java, 05AB1E, C#, and Whitespace
* I've used the polyglot tricks for combining Java & C as well as Java & C# before [here](https://codegolf.stackexchange.com/a/138416/52210) and [here](https://codegolf.stackexchange.com/a/187428/52210)
* [I've seen the C / C++ difference before](https://stackoverflow.com/a/2172948/1682559), and it was therefore easy to add here
* Emoji is a perfect language to add, since it ignores everything except for the relevant emoji commands (unlike Emojicode I tried to add as well..)
* 2sable is based on an old version of 05AB1E (legacy), and therefore rather similar as 05AB1E and 05AB1E (legacy), except it's a bit older than both.
*I might try to learn and add [Aheui](https://aheui.readthedocs.io/ko/latest/) for a suiting Korean output later on, since it will ignore everything except for the Korean characters in the code.*
[Answer]
# ~~3~~ 4 languages, outputs 20
* [Actually](https://github.com/mego/seriously):[Japanese](https://www.ethnologue.com/language/jpn)
* 05AB1E:[Vietnamese](https://www.ethnologue.com/language/vie)
* Emoji:[Danish](https://www.ethnologue.com/language/hun)
* Underload:[Cantonese](https://www.ethnologue.com/language/yue)
This answer is inspired by [this](https://codegolf.stackexchange.com/a/194682/85052) answer. Let's see whether I can fit in the ~~4th~~ 5th language in 20 characters.
```
(Âªø)"‰∫åÂçÅ""hai"üí¨tyveüí¨‚û°S
```
[Try it online in Actually!](https://tio.run/##S0wuKU3Myan8/1/j6e79mkpPdvU87W1UUspIzFT6MH/SmpLKslQQ/WjewuD//wE)
[Try it online in 05AB1E!](https://tio.run/##yy9OTMpM/f9f4@nu/ZpKT3b1PO1tVFLKSMxU@jB/0pqSyrJUEP1o3sLg//8B)
[Try it online in Emoji!](https://tio.run/##S83Nz8r8/1/j6e79mkpPdvU87W1UUspIzFT6MH/SmpLKslQQ/WjewuD//wE)
[Try it online in Underload!](https://tio.run/##K81LSS3KyU9M@f9f4@nu/ZpKT3b1PO1tVFLKSMxU@jB/0pqSyrJUEP1o3sLg//8B)
## Explanation
Actually:
```
(                           Roll empty stack left
 Âªø                         Unidentified instruction
   )                        Roll empty stack right
    "‰∫åÂçÅ""hai"             Push 2 strings
               üí¨t         Pop a, b, push a[b:]. Nothing special since b is a string.
                   y        Push prime factors of the string on the top of the stack
                    v      Discard TOS for the seed of the RNG
                     e     Push exp(Top Stack String)
                      üí¨‚û°S Sort the Top Of Stack; no effect to the text
Outputs the whole stack implicitly.
```
05AB1E:
```
(                           Negate the empty stack
 Âªø                         Unidentified instruction
   )                        AFAICT this is a NOP
    "‰∫åÂçÅ""hai"             Push 2 strings onto the stack
              üí¨t           Square root top of the stack string
                  y         Push string variable
                   v        Enumerated loop
                    e       Number of permutations
                     üí¨‚û°S Cast to list of characters / digits.
This outputs the TOS implicitly.
```
Emoji:
```
(Âªø)"‰∫åÂçÅ""hai"             No operations
              üí¨tyveüí¨‚û°  Output tyve
                          S NOPs
```
Underload:
```
(Âªø)                         Push Âªø onto the stack
    "‰∫åÂçÅ""h                 NOPs
            a                Enclose TOS with braces
             i"üí¨tyveüí¨‚û°  NOPs
                           S Output TOS
```
```
]