1. Python 3 (8 bytes)

print(1) 

This program prints 1 in Python 3.

Starting this off with Python 3 because I know it's good for polyglots and can be taken in a number of different directions (also, I wanted to ensure that the first answer was in a relatively normal language, rather than an absurd esolang that's hard to polyglot with).

2. V (11 bytes)

print(1)#i2 

This program prints 1 in Python 3, and 2 in V.

Just to get the ball rolling and to throw my favorite language into the mix early on. :)

It's a very straightforward answer.

print(1)# 

just so happens to be a NOP in V. (lucky for me) Then i2 enters insert mode and inserts a '2'. You can try V online here

Of course, in python

print(1) 

prints '1', and

#i2 

is a comment.

3. Minkolang v0.15 (26 bytes)

#>>>>>>>>v print(1)#>3N.i2 

This program prints 1 in Python 3, 2 in Vim, and 3 in Minkolang v0.15

I hope I don't mess things up by introducing a 2d language

Try it online!

Explanation

# stops program from moving through time (really does nothing) >>>>>>>> I can't use a space because then the program will move through time v go down > go right 3N. Outputs 3 and end program Anything afterward is ignored since program has ended 

Vim somehow ignores Minkolang, so that's good

And there really wasn't a problem with Python since it ignores the comments #

Next...

For the next language, I suggest something like ><> since # acts as a reflector (so that the direction will change to left and it will wrap to all the way in the right) so you can add code that can be ignored by other languages

4. ><> (29 bytes)

#>>>>>>>>v;n4 print(1)#>3N.i2 

This program prints 1 in Python 3, 2 in Vim, 3 in Minkolang v0.15 and 4 in ><>

Try it Online!

Code ran

# - change direction to left 4 - add 4 to stack n - print as a number ; - end the program 

Yet another 2D language.

Has no effect on Minkolang as it adds characters after the direction changes, gets ignored by Vim for some reason. # is a comment in Python so no change their either.

5. Python 2 (35 bytes)

#3N.;n4 print('1'if 1/2else'5') #i2 

This program prints 1 in Python 3, 2 in Vim, 3 in Minkolang v0.15, 4 in ><> and 5 in Python 2.

Try It Online beta!

In Python 2, 1/2 is 0, which is a falsy value, which makes Python print 5. In Python 3, 1/2 is 0.5, which is a truthy value, which makes Python print 1.

6. SMBF, 45 bytes

#v<++++<;n4 #>3N. print('1'if 1/2else'5') #i2 

Try it online

This program prints 1 in Python 3, 2 in V, 3 in Minkolang v0.15, 4 in ><>, 5 in Python 2, and 6 in SMBF.

SMBF (aka Self-modifying Brainfuck) uses <++++<>.. The pointer is moved left (to the last character of the source code), and the cell is incremented four times then printed.

7. Japt (50 bytes)

#v;7||"<++++<;n4 #>3N. print('1'if 1/2else'5') #i2 

Man, it was fun to fit Japt in there. Hopefully it didn't kill anyone's plans...

Test it online!

This program prints 1 in Python 3, 2 in V, 3N.print('1'if 1/2else'5')#i2" rel="nofollow noreferrer">3 in Minkolang v0.15, 4 in ><>, 5 in Python 2, 6 in SMBF and 7 in Japt

How this works: #v; takes the char code of v, or 118. Then 7|| returns the logical OR of 7 and the rest of the code, which is wrapped in a string with " to avoid any syntax errors. The result, 7, is automatically sent to STDOUT.

For future polyglotters, " can be changed to ` at no penalty to the Japt program (though I'm not sure about the others).

8. Retina, 70 bytes

#v;7||"<+0+0+0+<;n4 #>3N. #|\w* #8 #| #M` print('1'if 1/2else'5') #i2 

Try it online

This program prints 1 in Python 3, 2 in V, 3 in Minkolang v0.15, 4 in ><>, 5 in Python 2, 6 in SMBF, and 7 in Japt.

Explanation:

#v;7||"<+0+0+0+<;n4 # replace every empty string with "#>3N." #>3N. #|\w* # replace words chars with "#8" #8 #| # remove all "#". The "|" is something I could've golfed off. #M` # match all places between characters (finds 8) print('1'if 1/2else'5') # replace something that won't be found. noop #i2 

9. Perl, 84 bytes

#v;7||"<+0+0+0+<;n4 #>3N. #|\w* #8 #| #M` print(None and 9or 1/2and 1or 5) #j␛d5ki2 

There's a literal ESC character in the actual code between the j and d; it has been replaced with a ␛ here for visibility.

This prints 1 in Python 3, 2 in Vim (tested locally, but here's a link for the very similar language V), 3 in Minkolang, 4 in <><, 5 in Python 2, 6 in SMBF, 7 in Japt, 8 in Retina, and 9 in Perl.

Let's get some more exoteric languages in, via abusing arithmetic that works differently in different languages. (None is falsey in Python but truthy in Perl, and and/or chains work the same way in both languages.)

Apart from Python, I also had to change the vim code. Instead of making it into a series of no-ops, I just let it insert junk, then deleted the junk again at the end.

10. Befunge, 95 bytes

#v02^0;7||"<+0+0+0+<;n4 #v0#@00 #>3N. #|\w* #8 #| #M` print(None and 9or 1/2and 1or 5) #jd5ki2 

There is a literal ESC character between j and d on the last line (grr, @ais523). It is not included in this code. To get the actual code, please go to the Try it online link.

This prints 1 in Python 3, 2 in Vim, 3 in Minkolang, 4 in <><, 5 in Python 2, 6 in SMBF, 7 in Japt, 8 in Retina, 9 in Perl, and 10 in Befunge.

This code shares * with Retina and . with Minkolang and SMBF.

Try it online

Explanation

Actual program

#v02^ @ . * t 5 #v02^ 

The last line was written for clarity (Befunge playground is cyclic.)

# 

Trampoline, skips v

02^ 

Push 0 and then 2 in stack and go up.

5t*.@ 

Push 5, no-op, multiply two elements in stack (2 and 5), print, end program.

11. Befunge 98, 102 bytes

#v;2^0;7||"<+0+0+0+<;n4 #v0#_q@ #>3N. #|\w* #8 ^1b0< #| #M` print(None and 9or 1/2and 1or 5) #jd5ki2 

Prints:

• 1 in Python 3
• 2 in Vim - This takes quite a while to output for some reason...
• 3 in 3N.#|\w*#8 ^1b0<#|#M`print(None and 9or 1/2and 1or 5)#jd5ki2" rel="noreferrer">Minkolang v0.15
• 4 in ><>
• 5 in Python 2
• 6 in SMBF
• 7 in Japt
• 8 in Retina
• 9 in Perl
• 10 in Befunge 93
• 11 in Befunge 98

To be perfectly honest, I have no clue why the Vim code takes 1 min to output. Also, no clue how Retina works.

Explanation:

#v Skips the v, which would send the IP down ; Unlike '93, where ; is a no-op, '98 skips to the next ; and doesn't execute anything in between 2^0; Not executed, unlike Befunge 93 7| Pushes 7 onto the stack, and then sends the IP up, because 7 is not 0 n0b1 n clears the stack, and #s are pushed until the stack is [0, 11, 1 *. multiplies the top 2 values of the stack to give 11, and prints it (yay!) _ Sends the IP right, because the top value of the stack is 0 q Ends the program (no-op for '93, which continues to @) 

Things to note:

• The 0 next to the b isn't strictly necessary in the code's current state, and the stack has been cleared. It can be removed if necessary, but allows for other stack manipulation beforehand as part of a possible future program.
• The _q@ is there as part of Retina (It doesn't work without it, don't ask me why). The addition of q also lets the '98 code run a t operation, which splits the IP (along with making the Retina program print 8 instead of 7)
• The _ is not a simple > because that would mess the SMBF part up.

Edit: Just realized that the _q@ should probably be @00 (Where 0s can be ~any char) to make the program more flexible in the future. I'm too lazy (and tired) to change all the links right now though. Will get around to it eventually...

Edit 2: I Didn't expect 6 more answers this quickly. I guess it's staying as is. Great job everyone!

12. Fission (110 bytes)

Just adding yet another 2d lang... Streak of 3 2d-langs in a row, let's keep it moving folks!

#v;2^0;7||"<+0+0+0+<*!2'!1'L;n4 #v0#_q@ #>3N. #|\w* #8 ^1b0< #| #M` print(None and 9or 1/2and 1or 5) #jd5ki2 

This prints 1 in Python 3, 2 in Vim, 3 in Minkolang, 4 in <><, 5 in Python 2, 6 in SMBF, 7 in Japt, 8 in Retina, 9 in Perl, 10 in Befunge, 11 in Befunge-98, and 12 in Fission.

Try it online!

Explanation

The only important piece of code is the first line

 These are the important bits >------< #v;2^0;7||"<+0+0+0+<*!2'!1'L;n4 ^ we start here by creating an atom moving Left (I could not use R for Right since that means Replace in Vim) 1' sets the atom's mass to the ASCII value of '1' ! outputs the atom's mass (as a character) 2' sets the atom's mass to the ASCII value of '2' ! outputs it * program terminates 

Next...

If Fission is causing trouble, remember, you can move the Fission code anywhere you want, since the start of the program is only identified by the commands that create atoms, and the program ends whenever the atoms are destroyed.

You can also change the atom's start direction to suit your needs, R for Right (but Vim will interpret that as Replace), U for Up, D for Down (or Deletes entire line in Vim, can be useful).

13. Ruby (129 bytes)

#v;2^0;7||"<+0+0+0+<*!2'!1'L;n4 #v0#_q@ #>3N. #|\w* #8 ^1b0< #| #M` print ((0 and'13')or(None and 9 or 1/2 and 1 or 5)) #jd5ki2 

Please note the literal Esc character on the last line between the j and d, as per ais523's Perl answer.

Try it online!

This prints 1 in Python 3, 2 in Vim, 3 in Minkolang, 4 in <><, 5 in Python 2, 6 in SMBF, 7 in Japt, 8 in Retina, 9 in Perl, 10 in Befunge, 11 in Befunge-98, 12 in Fission and 13 in Ruby.

Just a minor modification to the existing print statement to abuse the fact that 0 is truthy in Ruby. I had to add some spaces to the other statements to make it parse correctly.

14. Turtlèd (135 bytes)

#v;2^0;7||"<+0+0+0+<*!2'!1'L#'1r'4;n4 #v0#_q@ #>3N. #|\w* #8 ^1b0< #| #M` print ((0 and'13')or(None and 9 or 1/2 and 1 or 5)) #jd5ki2 

This prints 1 in Python 3, 2 in Vim, 3 in Minkolang, 4 in <><, 5 in Python 2, 6 in SMBF, 7 in Japt, 8 in Retina, 9 in Perl, 10 in Befunge, 11 in Befunge-98, 12 in Fission, 13 in Ruby and 14 in Turtlèd.

First line added #'1r'4 near the end of line, Turtled takes #[string]# as string input then 'X places the value of x on the grid, r moves right 1 space on the grid. The value on the grid is printed at the end of the program implicitly.

Try it Online

Link to Turtled docs

15. Haystack (141 bytes)

#v;2^0;7||"<+0+0+0+<*!2'!1'L#'1r'4;n4 #v0#_q@ #>3N.15o|1 #|\w* #8 ^1b0< #| #M` print ((0 and'13')or(None and 9 or 1/2 and 1 or 5)) #jd5ki2 

Note: there is an ESC after o in the third line and after j in the last line

This prints 1 in Python 3, 2 in Vim, 3 in Minkolang, 4 in <><, 5 in Python 2, 6 in SMBF, 7 in Japt, 8 in Retina, 9 in Perl, 10 in Befunge, 11 in Befunge-98, 12 in Fission, 13 in Ruby, 14 in turtlèd, and 15 in Haystack.

Try it online!

Explanation

#v go down v > go right 3N. does nothing important 15o| outputs 15 and ends program there is an <ESC> after 'o' since 'o' in Vim enters insert mode 1 I added this to satisfy Retina 

16. Pyth (159 bytes)

#v\;2^0\;7||"<+0+0+0+<*!2'!1'L#'1r'4;n4 #v0#_q@ #>3N.15o|1 #|\w* #8 ^<1b0 < #| #M` print ((0 and'13')or(None and 9 or 1/2 and 1 or 5)) #"07|5//00;16 "jd5ki2 

Note: there is an ESC byte (0x1B) after the o in the third line and after the j in the last line.

This was quite a fun experience. Japt and Pyth are both golfy languages, but Japt is infix and Pyth is prefix, and Pyth auto-requests input and fails if arguments are missing.

Before the Haystack answer I had an almost-working solution using #, which gets a char code in Japt and loop-until-error in Pyth. Pyth happens to be very useful in polyglots, since the common comment char # essentially works as an error silencer.

When I got home I managed to find a this piece of code that worked in both using //, which works as a comment in Japt and two divisions in Pyth. Then it was just a matter of getting the Befunges to route correctly.

This is very unlikely to be optimal, but it's good enough for now. I tried to test them all, but I'd highly appreciate someone double checking that the outputs match.

Prints 1 in Python 3, 2 in V, 3 in Minkolang, 4 in ><>, 5 in Python 2, 6 in Self-Modifying Brainfuck, 7 in Japt, 8 in Retina, 9 in Perl, 10 in Befunge(-93), 11 in Befunge-98, 12 in Fission, 13 in Ruby, 14 in Turtléd, 15 in Haystack, and

16 in Pyth.

Explanation

What Pyth sees here is:

#v\;2^0\;7||"string multiline string"07|5//00;16 "string 

This translates to the following pseudocode:

while no errors occur: evaluate ";" print 2 print 0 to the power ";" print 7 print "string\nmultiline\nstring" or 0 or 7 print 5 or 0 divided by 0 divided by (missing) print 16 do nothing with "string" 

The first loop exits on trying to evaluate ; which isn't a valid expression. Then Pyth just prints 16.

Note: If you see this first, you might want to sort by oldest

17. Julia (128 bytes)

#v`16 "<" 6/b0\ .q@#;n4"14"" #>3N9@15o|R"12"*^ #=| print((1/2and 9 or 13)-(0and+4)^1<<65>>62);# =#;print(17) #gg99ddi2` |1|1+6 

There are two ESCs on the last line, one before the first g and one after the 2. This could be golfed more, but things got messy no thanks to V and Pyth.

Prints 1 in Python 3, 2 in V, 3 in Minkolang, 4 in ><>, 5 in Python 2, 6 in SMBF, 7 in Japt, 8 in Retina, 9 in Perl, 10 in Befunge-93, 11 in Befunge-98, 12 in Fission, 13 in Ruby, 14 in Turtléd, 15 in Haystack, 16 in Pyth and 17 in Julia.

Hints:

• The start of the fourth line is Python 2/3, Perl, Ruby. The end is Julia, thanks to #= multiline comments (note that Julia doesn't have and/or).
• V is <ESC>gg99ddi2<ESC>, which is definitely golfable but V is annoying to test on Try it online! since the interpreter is fairly slow.
• Minkolang and Haystack go down at the first v. Befunge-93 and -98 don't, and depend on a b.
• Retina counts the number of spaces and 1s in the fourth line, and V hides in the config for Retina (i.e. before the backtick).
• Per @ETHproduction's hint, Japt uses backticks to hide the majority of the code in a string.
• Fission is R"12"*.
• SMBF has been golfed to <. in the first line, plus the final 6.

18. Cardinal, 137 bytes

#v`16 "<" 6/b0\ .q@#;n4"14"" #>3N9@15o|R"12"*^*ttt*~++% #=| print((1/2and 9 or 13)-(0and+4)^1<<65>>62);# =#;print(17) #gg99ddi2` |1|1+6 

Literal escape chars between # and g, and 2 and `.

Prints:

• 1 in Python 3
• 2 in V
• 3 in Minkolang
• 4 in ><>
• 5 in Python 2
• 6 in SMBF
• 7 in Japt
• 8 in Retina
• 9 in Perl
• 10 in Befunge 93
• 11 in Befunge 98
• 12 in Fission
• 13 in Ruby
• 14 in Turtléd
• 15 in Haystack
• 16 in Pyth
• 17 in Julia
• 18 in Cardinal (No online interpreter, but the specs are here)

Edit: Fixed esc character between o and | - don't know why it was there in the first place.

19. Reng, 152 bytes

#v`16 "<" 6/b0\ .q@#;n4"14"" #>3N9@15o|R"12"*^*ttt*~++% #=| print((1/2and 9 or 13)-(0and+4)^1<<65>>62);# =#;print(17) # ~nJ< # #gg99ddi2` |1|1+6 

I added another #\n so that retina would cooperate. Here's how it works:

# redefines v to push 0, the default TOS. Then, it negates the TOS (`), pushes 1 and 6, the character of <, pushes 6 again, and mirrors upwards with /, colliding with the other `, which negates the 6. Then, it hits the <, pushes J (base 36 for 19), then outputs it as a number, finally terminating (~).

Escapes in between 2 and `; and # and g.

1. Try it online!—Python 3
2. Try it online!—V
3. Try it online!—Minkolang
4. Try it online!—><>
5. Try it online!—Python 2
6. Try it online!—SMBF
7. Ethproductions—Japt
8. Try it online!—Retina
9. Try it online!—Perl
10. Try it online!—Befunge 93
11. Try it online!—Befunge 98
12. Try it online!—Fission
13. Try it online!—Ruby
14. Try it online!—Turtléd
15. Try it online!—Haystack
16. Try it online!—Pyth
17. Try it online!—Julia
18. Try it online!—Cardinal
19. JSFiddle—Reng

20. Prelude, 167 bytes

#v`16 "<" 6/b0\ .q@#;n4"14"" #>3N9@15o|R"12"*^*ttt*~++% #=| print((1/2and 9 or 13)-(0and+4)^1<<65>>62);#35(99999+++++!) =#;print(17) # ~nJ< # #gg99ddi2` |1|1+6 

Literal ESC characters in the same place as in the previous submissions (between the # and g, and between the 2 and `, on the last line), because you can't take Vim out of insert mode with printable characters.

This program prints 20 in Prelude, 19 in Reng (testable here), 18 in Cardinal, 17 in Julia, 16 in Pyth, 15 in Haystack, 14 in Turtlèd, 13 in Ruby, 12 in Fission, 11 in Befunge-98, 10 in Befunge-93, 9 in Perl, 8 in Retina, 7 in Japt, 6 in SMBF, 5 in Python 2, 4 in ><>, 3 in Minkolang, 2 in Vim/V, 1 in Python 3, and a partridge in A Pear Tree.

The existing code pretty much cancels itself out in Prelude, consisting only of while loops with falsey arguments and some stack manipulation on stacks we don't care about. Even better, there's a spot in the code that's a comment in all the languages that have them (between the # and =# of the previous submission). The hard part of fitting Prelude into this was generating numbers with only one stack and without blowing up the byte count. This program uses a loop that adds 45 to every stack element and outputs it as ASCII, thus by placing a 5 above a 3 on the stack, we get 20 as output. (Neatly, 20 is an easier number to output than 19 is in Prelude, so answer 19 being posted actually helped me a bit.)

21. Nim (161 bytes)

#v`16/"<"6/b.q@#;n4"14"" #>3N6@15o|> ^*ttt*~++ % #=~nJ<R"12"; #[ print((1/2and 9 or 13)-(0and+4)^1<<65>>62)#46(89999+++++!)=#print(17)#]#echo 21 #8dggi2` |1|6 

Two <ESC>s, between 8d and between 2` on the last line. You can tell that my previous one was golfed in a hurry, because I woke up this morning and realised I could take a bunch more off. I had 152 bytes but that seems to only work in Perl 5.24.0, so in the interest of compatibility with TIO I've kept the original expression for now.

Prints 1 in Python 3, 2 in V, 3 in Minkolang, 4 in ><>, 5 in Python 2, 6 in SMBF, 7 in Japt, 8 in Retina, 9 in Perl, 10 in Befunge-93, 11 in Befunge-98, 12 in Fission, 13 in Ruby, 14 in Turtléd, 15 in Haystack, 16 in Pyth, 17 in Julia, 18 in Cardinal, 19 in Reng, 20 in Prelude and 21 in Nim.

Note that Nim on ideone.com uses version 0.11.2, which is a tad too old, since this program relies on #[ ... ]# multiline comments added in early 2016.

Thanks to Cardinal's Windows interpreter, my workflow now consists of two laptops and a Python http.server in between.

Edit — some more hints:

• The 8 at the start of the last line is to set Retina's limit to the first 8 matches, otherwise without it Retina would output 2. Note that this means the final line regex only needs to match at least 8 times in the second last line now, as opposed to exactly 8 — during my meddling I modified Prelude to get Retina right, but it turned out that was unnecessary in the end.
• The mismatched quote at the end of the first line is so that Pyth doesn't complain about invalid syntax for the rest of the code.
• If you modify the second line you might have to change the 6@ for Minkolang, which makes the pointer jump 6 spaces to land on the ^.
• There's a pair of [] now, so SMBF needs to be on a 0 cell before it hits the [, or alternative the interior needs to clear the cell.

There's probably more to golf (even now I see a stray space before the % for Cardinal), but I should really stop golfing in the wee hours of the morning.

22. Underload (stringie), 174 bytes

#v`16/"<"6/b.q@"(::):: :(22)S#;n4"14" #>3N6@15o|> ^*ttt*~++ % #=~nJ<R"12"; #[ print((1/2and 9 or 13)-(0and+4)^1<<65>>62)#46(89999+++++!)=#print(17)#]#echo 21 #8dggi2` |1|6 

As before, there's a literal ESC character immediately after each of the 8 and 2 on the last line.

This program prints 22 in Underload, 21 in Nim, 20 in Prelude, 19 in Reng (testable here), 18 in Cardinal, 17 in Julia, 16 in Pyth, 15 in Haystack, 14 in Turtlèd, 13 in Ruby, 12 in Fission, 11 in Befunge-98, 10 in Befunge-93, 9 in Perl, 8 in Retina, 7 in Japt, 6 in SMBF, 5 in Python 2, 4 in ><>, 3 in Minkolang, 2 in Vim/V, and 1 in Python 3.

stringie is the Underload interpreter used by Try It Online! Fortunately for polyglotting, it ignores non-command characters rather than crashing on them, so the main thing to ensure is that there are enough stack elements that we don't get an empty stack crash (done here with (::):::; the code probably doesn't actually need that many colons, but I added them anyway as padding to remove awkward vertical alignments). Because it had to appear fairly early (it needs to be before any instances of aS^:*~!), I placed the Underload code on the first line; thanks for Sp3000 for suggesting a place where it would fit safely.

I needed to leave an additional space on the first line because Cardinal doesn't like : lined up with %; I also needed to structure the Underload code to avoid parentheses lining up with each other vertically (which Prelude dislikes). Pyth was the hardest language to get working, and I needed to resort to advice from Sp3000 there (who suggested moving the double quotes around; this combination works). In an earlier version of the code, the Underload was further to the right, but that got in the way of Turtlèd.

The space immediately after the Underload (i.e. after the S of (22)S should still be safe; the Underload doesn't change that. In order to avoid causing problems for Underload, ensure that your code has matched parentheses, avoids S, and isn't intelligible enough as Underload code to cause problems in its own right. (::) has a tendency to breed once it's placed on the stack (I intentionally wanted to write the Underload in a fairly robust way to make continuing the chain easier), so most random sequences of non-S characters will be safe from here, but it's possible to defeat the "ignore the rest of the program" if you try hard enough. If you need an S for some reason, try ensuring that some pair of parentheses captures it; that'll cause Underload to treat it as data rather than code and avoid producing stray output.

23. Hexagony, 186 bytes

Sorry if this messes up plans...

#v`16/"<"6/b.q@"(::)::: (22)S#;n4"14" #>3N6@15o|> ^*ttt*~++~~~% #=~nJ<R"12"; #[ print((1/2and 9 or 13)-(0and+4)^1<<65>>62)#46(89999+++++!)=#print(17)#0\32=""<0]#echo 21 #8␛dggi2␛` |1|6 

␛ is used to represent a literal ESC character.

Prints:

23 in Hexagony, 22 in Underload, 21 in Nim, 20 in Prelude, 19 in Reng (testable here), 18 in Cardinal, 17 in Julia, 16 in Pyth, 15 in Haystack, 14 in Turtlèd, 13 in Ruby, 12 in Fission, 11 in Befunge-98, 10 in Befunge-93, 9 in Perl, 8 in Retina, 7 in Japt, 6 in SMBF, 5 in Python 2, 4 in ><>, 3 in Minkolang, 2 in Vim/V, and 1 in Python 3.

To get to the unlinked languages, click the change language button in the upper right of the Hexagony link.

Hexagony isn't readable (at ALL) in this format. We need to look at it in hexagonal form.
Note that the 2 ESC characters have been replaced with ␛s so you can see them - they are ignored, so there are no others in the program:

 # v 1 6 / " < " 6 / b . q @ " ( : : ) A lot more readable, right?? No? : : : ( 2 2 ) S # ; n 4 " 1 4 " # > 3 N 6 @ 1 5 o | > ^ * t t t * ~ + + ~ ~ ~ % # = ~ n J < R " 1 2 " ; # [ p r i n t ( ( 1 / 2 a n d 9 o r 1 3 ) - ( 0 a n d + 4 ) ^ 1 < < 6 5 > > 6 2 ) # 4 6 ( 8 | Note that the 0s below can be replaced 9 9 9 9 + + + + + ! ) = # p r i | With anything (except "`" or " "), n t ( 1 7 ) # 0 \ 3 2 = " " < V as far as Hexagony is concerned 0 ] # e c h o 2 1 # 8 ␛ d g g i 2 ␛ | 1 | 6 . . . . . <-- the ␛ represents an esc . . . . . . . . . . . . character . . . . . . . . . . . . . . . . . . . . . A "." is a no-op . . . . . . . . . ^ | Mirror wraps to here, going NW 

For those unfamiliar with Hexagony, There are 6 IPs, which start at the 6 corners. Only 1 is active at a time, and are switched by using #][. The memory model isn't that important to this program, but might be necessary to understand in the future. All that you need to know is that 1 int is stored in a "memory edge" (ME for short), and '"}{ change the ME that is active.

\/|_>< are mirrors that control program flow.

This is how it works:

First line executed:

# A no-op (sets active IP to 0, the currently active one) v letter chars set the ME to their ASCII value - so ME is now 118 16 Like Labyrinth, 0-9 multiplies ME by 10 and is added - ME now 11816 / A mirror that sends IP going NW by wrapping to the bottom 

The bottom (snippet flipped vertically so you can read up to down):

 . . A series of no-ops. The IP is going NW now, . because of the mirror on the top. . | Another mirror. This one sends the IP NE, into the h h sets the ME to 104, the ASCII value for h # 104 % 6 == 2, so IP 2 is now active instead of 0 

The right edge:

 8 IP #2 is moving SW, starting in the right corner i Sets the ME to 105 < Mirror. Sends the IP going due West "" These change the Active ME - just know that the new edge is 0 = Changes the MP (more in specs) - effectively a no-op used to fill space \32 pushes 23, and mirrors up NE to the ! 

The last bit of relevant code:

! Prints the current value of the ME as an int. Success! 20(R~ Does things to the ME - irrelevant now @ Ends the program! 

Things to note:

• Hexagony drops all s and `s before executing, so any changes to those will not affect Hexagony
• I needed to pad the code so that it would be interpreted as a 9 length hexagon, instead of an 8th - be careful golfing below 169 or above 217 relevant characters
• Because of this, the ~~~ and the 2 0s at the end can be changed at no harm to the code
• The ="" just moves the ME away from the previous one so that a new ME can be modified. They can be replaced with other characters that do the same thing at no harm to the hexagony program ('s, for example)
• This is technically not comlient with the Befunge 93 specs, because it limits the bounding box of the code to 80 by 25 chracters. However, Most interptreters ignore this spec (like TIO), So I don't personally think it's that big of a deal. If you do, feel free to leave a comment. (If enough really want me to change it, then I will try)
• Hope it's not too hard now.

24. Thutu, 211 bytes

Fourth try. Hopefully the implementation is uncontroversially valid this time.

#v`16/"<"6/b.q@"(::)::: (22)S#;n4"14" #>3N6@15o|> ^*ttt*~++~~~% #=~nJ<R"12"; #[ #| print((eval("1\x2f2")and 9 or 13)-(0and+4)^1<<65>>62)#@46(8+9+9+9+9+=!)=#print(17)#3]#echo 21#===2|/=1/24=x=9+/ #8␛dggi2␛` |1|6 

␛ represents a literal ESC character, as usual.

As far as I know, there isn't a Thutu implementation that works in a browser yet. I used the implementation in the Esoteric Files Archive, which is a compiler from Thutu to Perl (basically, compile the Thutu into Perl, then run the Perl). Update: Since I wrote that, the language has been added to TIO. So now you can:

Try it online!

This program prints 24 in Thutu, 23 in Hexagony, 22 in Underload, 21 in Nim, 20 in Prelude, 19 in Reng (test here), 18 in Cardinal, 17 in Julia, 16 in Pyth, 15 in Haystack, 14 in Turtlèd, 13 in Ruby, 12 in Fission, 11 in Befunge-98, 10 in Befunge-93, 9 in Perl, 8 in Retina, 7 in Japt, 6 in SMBF, 5 in Python 2, 4 in ><>, 3 in Minkolang, 2 in Vim/V, and 1 in Python 3.

I had to pretty much redo the Hexagony part of the solution. It turns out to be easiest to run the Hexagony code on a diagonal, rather than horizontally:

 # v 1 6 / " < " 6 / b . q @ " ( : : ) : : : ( 2 2 ) S # ; n 4 " 1 4 " # > 3 N 6 @ 1 5 o | > ^ * t t t * ~ + + ~ ~ ~ % # = ~ n J < R " 1 2 " ; # [ # | p r i n t ( ( e v a l ( " 1 \ x 2 f 2 " ) a n d 9 o r 1 3 ) - ( 0 a n d + 4 ) ^ 1 < < 6 5 > > 6 2 ) # @ 4 6 ( 8 + 9 + 9 + 9 + 9 + = ! ) = # p r i n t ( 1 7 ) # 3 ] # e c h o 2 1 # = = = 2 | / = 1 / 2 4 = x = 9 + / # 8 ␛ d g g i 2 ␛ | 1 | 6 . . . . . . . . . . . . . . . . . . . . . . 

The bold font doesn't show up that well for me, but nonetheless, I've boldened the route that the IP takes. There's only one IP used, this time, and it hardly runs any commands. The program starts by pushing some junk to the memory edge, then replacing its value with the sum of the memory edges to either side (which still have their initial value of 0), thus resetting memory to all-zeroes. Then we can just do 23!@ to print 23 and exit.

Thutu doesn't like blank lines. As such, I had to replace Retina's blank line (which matches anything) with #| (which also matches anything).

Thutu also cares a lot about slashes; they're the main syntactical element of the language. Luckily, # at the start of a line is a comment in Thutu, so we only have one line to worry about. However, # inside a line is not a comment, so the big long line is something of a concern. As such, I had to hide the slash from Thutu by placing it inside an eval. Luckily, both versions of Python, Perl, and Ruby all have an eval, and will all unescape \x2F into / inside a string delimited by ". Unfortunately, the use of " makes the code live in Pyth, and can easily cause syntax errors (e.g. eval("1\x2F2") is a syntax error), but we can use a lowercase \x2f and Pyth will be OK with that, at least syntax-wise (it's in a part of the code that never runs, so we don't have to worry about what it actually does).

Thutu interprets most of the big long line (up to the first slash) as a regular expression. As such, the Prelude code was causing problems, as +++ is too much quantification. However, it was fairly easy to fix that by re-associating the uses of +.

So how does the Thutu work? Most of the code is a comment, with only one line of code. Thutu's kind-of like Retina; it works by repeatedly regexing a working space. Initially, the input is =1. We first check to see if it matches the regex print(( … ===2| (it does, because most (all)? regexes ending with | will match anything). Then we replace one occurrence of =1 with 24=x=9+. At the end of each cycle, the Thutu implementation will output everything before =x (i.e. 24), exit (due to the presence of =9), and keep the + (which we don't care about) for the next cycle (which doesn't exist).

In terms of places where code can be added, the main offender is Hexagony, which is incredibly fragile in the current case. As such, I suspect that the last line is currently the easiest place to add code if you don't want to redo a large amount of work. The 6 at the end is used for SMBF, but the |1| is used only by Retina, which can cope with any other regex there that's matched a lot of times, and Vim; a few 2D languages will pass over the line but will consider most characters fairly harmless. Before the first ESC is touched even less, with only Retina caring (although if you go too far right, you'll affect some 2D languages, like before). Note that there's a limit to how long the code there can be, because if the Hexagony side length gets thrown off, everything will break.

If you're willing to redo the Hexagony, the long line is still a good place to add code, although slightly worse than before. The ===2 is purely Hexagony, and will hardly be seen by other languages (although Thutu wants it to be a valid regexp, Prelude doesn't want parentheses or exclamation marks, SMBF doesn't want periods or mismatched brackets). Earlier in the line (the #@) is also a safe place to add code so long as you're careful with Thutu and SMBF, and redo the Hexagony; you may need to add a 0 or two at the end of your code to prevent it confusing the Prelude code later.

Finally, if you're prepared to dodge the 2D languages, the #| line is pretty much entirely free, with only Retina and the occasional wild two-dimensional instruction pointer causing problems.

25. Pip, 220 bytes

#v`16/"<"6/b.q@"(::)::: (22)S#;n4"14" #>3N6@15o|> ^*ttt*~++~~~% #=~nJ<R"12"; #[ #| print((eval("1\x2f2")and 9 or 13)-(0and+4)^1<<65>>62)#@46(8+9+9+9+9+=!)=#print(17)#3]#echo 21#===2|/=1/24=x=9+/ #8␛dggi2␛` |1|6//1''19+6 

␛ represents a literal ESC character, as per previous submissions.

This program prints 25 in Pip, 24 in Thutu, 23 in Hexagony, 22 in Underload, 21 in Nim, 20 in Prelude, 19 in Reng (test here), 18 in Cardinal, 17 in Julia, 16 in Pyth, 15 in Haystack, 14 in Turtlèd, 13 in Ruby, 12 in Fission, 11 in Befunge-98, 10 in Befunge-93, 9 in Perl, 8 in Retina, 7 in Japt, 6 in SMBF, 5 in Python 2, 4 in ><>, 3 in Minkolang, 2 in Vim/V, and 1 in Python 3.

The 1|6 is used by both Retina and Japt and the // serves to comment out the end of the code so that Japt doesn't output anything else. I feel like 26 should be fairly 'easy' to sneak into the end since SMBF needs a trailing 6, so anything that will output the last item in the code (being 26) should be at an advantage... Perhaps 05ab1e? Good luck!

26. 05AB1E, 224 bytes

#v`16/"<"6/b.q@"(::)::: (22)S#;n4"14" #>3N6@15o|> ^*ttt*~++~~~% #=~nJ<R"12"; #[ #| print((eval("1\x2f2")and 9 or 13)-(0and+4)^1<<65>>62)#@46(8+9+9+9+9+=!)=#print(17)#3]#echo 21#===2|/=1/24=x=9+/ #8␛dggi2␛` |1|6//1"'"'--1+26 

␛ represents a literal ESC character, which you likely know by now if you're here, but I'm reminding you just in case.

This program prints 26 in 05AB1E, 25 in Pip, 24 in Thutu, 23 in Hexagony, 22 in Underload, 21 in Nim, 20 in Prelude, 19 in Reng (test here), 18 in Cardinal, 17 in Julia, 16 in Pyth, 15 in Haystack, 14 in Turtlèd, 13 in Ruby, 12 in Fission, 11 in Befunge-98, 10 in Befunge-93, 9 in Perl, 8 in Retina, 7 in Japt, 6 in SMBF, 5 in Python 2, 4 in ><>, 3 in Minkolang, 2 in Vim/V, and 1 in Python 3.

I wish I could explain this a bit, but I mostly just stumbled through this blindly. Never heard of/used 05AB1E or Pip, and never used Pyth (which gave me the most trouble).

05AB1E saw most of the program as an unclosed string (from ")and 9 onwards), so that needed to be closed. Pip and Pyth didn't cooperate with the extra double quote initially, which turned into trial and error of single/double quote placement until they complied.

The exact math used for Pip was mostly arbitrary, as long as it resulted in 25, so toying with that got me a plain 26 at the end for 05AB1E while still calculating the 25 needed for Pip.

27. Perl 6, 235 bytes

#v`16/"<"6/b.q@"(::)::: (22)S#;n4"14" #>3N6@15o|> ^*ttt*~++~~~% #=~nJ<R"12"; #[ #`<`| print((eval("1\x2f2")and 9 or 13)-(0and 4)^1<<65>>62)#@46(8+9+9+9+9+=!)=#print(17)#3]#echo 21#===2|/=1/24=x=90/ #8␛dggi2␛` |1|6$//''25 #>say 27#"26 

␛ represents a literal ESC character, as usual.

This program prints 27 in Perl 6, 26 in 05AB1E, 25 in Pip, 24 in Thutu, 23 in Hexagony, 22 in Underload, 21 in Nim, 20 in Prelude, 19 in Reng (tested here), 18 in Cardinal, 17 in Julia, 16 in Pyth, 15 in Haystack, 14 in Turtlèd, 13 in Ruby, 12 in Fission, 11 in Befunge-98, 10 in Befunge-93, 9 in Perl 5, 8 in Retina, 7 in Japt, 6 in SMBF, 5 in Python 2, 4 in ><>, 3 in Minkolang, 2 in Vim/V, 1 in Python 3, and (as it's Christmas) a partridge in A Pear Tree.

The syntax highlighting that Stack Exchange produces for this answer is completely wrong. #`< is one of Perl 6's many multiline comment markers, and ends at #>, thus the only code that actually runs in Perl 6 is the very simple say 27. I chose this particular comment marker because <> aren't a matching pair in most languages, and thus the unmatched < won't break languages, such as Retina, that attempt to parse it.

I'm not entirely sure how the Hexagony works any more. When it broke, I changed one of the characters it was using from a + to a 0 to see if it was being hit; turns out it was, and turns out this fixed the program, but I'm not sure why (I know it broke due to a # in the line of execution, but it's unclear why removing the + fixes things). (The character in question is also parsed by Thutu, but luckily this doesn't make a difference to the functioning of the Thutu program, as at that point in the program, anything that isn't preceded by an = is copied literally into the working string.) Note that the 0and+4 from a previous line became 0and 4, to make it one character shorter from Hexagony's point of view (Hexagony doesn't see spaces); this is to compensate for the #| on a previous line becoming #`<`|, which is one character longer from Hexagony's point of view (because it doesn't see backquotes either). Note that the code's now only five bytes away from expanding the Hexagony side length and breaking everything about the current Hexagony code. I'd recommend doing this anyway and just redoing the Hexagony section of the code; it'll probably be easier, rather than harder, to fit everything in after an expansion.

Some other languages changed too, mostly to add enough robustness that I could fit arbitrary code in on the last line. $// is a comment marker in Japt that allows spaces later on the line, making the added program less fragile in Japt (meanwhile, // breaks if there are any closing parentheses later on the line, and space is a sort of closing parenthesis in Japt). A pair of spaces is a comment marker in Pip, meaning that the Pip code can be substantially simplified here. This also means that we can simplify the 05AB1E down to a trivial "26. Retina needs the fifth line to be a legal regex that's good at matching things (the trailing | is thus for Retina); it parses differently from the corresponding line in the previous entry, but in a way that's just as suitable. The Cardinal is also very slightly simpler than in previous entries, but this is just pure coincidence with how everything lines up vertically, and the change is to code that didn't do anything anyway.

Assuming you redo the Hexagony (you'll probably have to), there are safe places to add code on all of the last three lines: the 3 in #3]# is only for Hexagony (and easily changed); the space between the # and " on the final line is ignored by the vast majority of languages; and nothing's really parsing the end of the fifth line other than Retina. (There are plenty of other places where code can be added, too, but these are probably the most convenient.)

28. Brain-Flak, 280 bytes

#v`16/"<"6/b.q@"(::)::: (22)S#;n4"14" #>3N6@15o|> ^*ttt*~++~~~% #=~nJ<R"12"; #[ #`<`| print((eval("1\x2f2")and (9) or (13))-(0and 4)^(1)<<(65)>>62)or'(\{(\{})(\{}\/^23!@[()])}\{})(\{}\{})'#@46(8+9+9+9+9+=!)=#print(17)#]#echo 21#|/=1/24=x=90/ #8␛dggi2␛` |1|6$//''25 #>say 27#"26 

␛ represents a literal ESC character, as usual.

This program prints 28 in Brain-Flak, 27 in Perl 6, 26 in 05AB1E, 25 in Pip, 24 in Thutu, 23 in Hexagony, 22 in Underload, 21 in Nim, 20 in Prelude, 19 in Reng (tested here), 18 in Cardinal, 17 in Julia, 16 in Pyth, 15 in Haystack, 14 in Turtlèd, 13 in Ruby, 12 in Fission, 11 in Befunge-98, 10 in Befunge-93, 9 in Perl 5, 8 in Retina, 7 in Japt, 6 in SMBF, 5 in Python 2, 4 in ><>, 3 in Minkolang, 2 in Vim/V, 1 in Python 3

First off, I want to say what a privilege it is to be able to contribute to this challenge. I only heard of code golf a few weeks ago and I have been absolutely hooked ever since. The first thing I did when I found this challenge was try to run the code as is in various languages just to see if I could find anything I could work with. This was back when we were on like #6. I honestly thought this challenge was bonkers impossible, but here we are (#28 Wow!). What I found at the time was that Brain-Flak output the value 2. So I set out to learn it.

Brain-Flak turned out to be pretty great for this kind of challenge because it's fairly easy to learn and it ignores pretty much any characters except (){}[]<>. # also happens to comment anything after it on the same line, so the only part of the last submission that was ever considered for Brain-Flak was print((eval("1\x2f2")and 9 or 13)-(0and 4)^1<<65>>62) which then paired down to ((())()<<>>). So then the plan became adding superfluous parenthesis to what I've come to think of as the python code.

I modified the python bits to parse in Brain-Flak to ((() () ())()()<<()>>) which equates to 2 stacks the first being 5 and the second being 3. After that I'm squaring the 5 with ({({})({}[()])}{}) and adding the result to 3 with ({}{}). This squaring and adding is going on in a string from a Python perspective. I can't claim to understand Python's reasoning here, but I am fairly confident that this string isn't otherwise being evaluated by other languages in a meaningful way, with only a couple exceptions.

Japt, it turns out, interprets curly braces within a string as containing code, but these were easy enough to escape out with \ before each { in this string. But this bloated up the byte count. Such is life.

Prelude was pretty forgiving with all of my parentheses. An earlier comment pointed out that Prelude would have fits with vertically aligned Parentheses and I happened to only create one. Sweet! The ( in the top line lined up with the and (9 in the big line. So I had to add an additional space before the ( in the top line. My assumption here is that the double space was a comment indicator for something, so adding an additional space seemed trivial, and it worked. I should point out that I tried adding a additional spaces in the (9) instead, but Cardinal didn't cooperate.

05AB1E didn't like my first attempt at the Python string being encapsulated in double quotes, but everyone seemed agreeable to using single quotes. Not a big deal there.

Hexagony was the only language left at this point, and I was obviously way past the next hex size threshold, so it was time to get dirty. The /^23!@ is the Hexagony code and I'm super excited about it, because I think it'll make future additions much easier. This little piece can basically be moved anywhere in the python string without busting any code. This is the full string just so we're all on the same page '(\{(\{})(\{}\/^23!@[()])}\{})(\{}\{})'. The / here sets the path of Hexagony from SE ->NW to W-> E down this string, which we have a lot of leeway with. (The preceding \ is to escape / for thutu BTW). My idea here is if you make changes, odds are that you'll end up going through this string at some point and you can slide the Hexagony piece around within the string to catch the code path and send it to the proper conclusion. Just take care not to come between Japt's \ and the {. If you have trouble with this, the @ to the right of the string is just left over from another Hexagony solution, and can be removed without consequence to the other languages. And of course if you happen to catch Hexagony's code path going the opposite direction, you can of course use @!32^\ instead of /^23!@. Also, you may notice that my solution removed the ===2 from the code to keep things under the byte limit. Someone mentioned in here that this was for Hexagony's alignment and I didn't need it anymore.

Finally, here is a little piece of code I found while exploring codegolf that converts a line of text into a Hexagony readable hexagon so you can debug. I'm sure plenty of people know about this, but I hadn't seen it posted here, so it might help someone else too. Fair warning, you have to alter the input to remove the back ticks and carriage returns as well as swap the literal escape for something that takes up normal amount of space to get the code to line things up in a pretty Hexagon.

P.S. While I was writing this out, I realized I had a mistake. I had believed I was clearing Hexagony's memory edge for with the ^, but apparently I can replace it with a no-op to no consequence. That ^ should probably be a + if you try to manipulate this section. I was apparently passing through a + prior to this, but future polyglotters may not be so lucky.

Good Luck!

29. Trigger, 292 bytes

#v`16/"<"6/b.q@"(: ::T): :(22)S#;n4"14" #>3N6@15o|> ^*ttt*~++~~~% #=~nJ<R"12"; #[ #`<`| print((eval("1\x2f2")and (9) or (13))-(0and 4)^(1)<<(65)>>62)or'(\{(\{})(\{\/+23!@=}[()])}\{})(\{}\{})'#@46(8+9+9+9+9+=!)=#print(17)#]#echo 5+5+11#|/=1/24=x=90/ #8␛dggi2␛` |1|6$//''25 #>say 27#T222999"26 

This program prints 29 in Trigger, 28 in Brain-Flak, 27 in Perl 6, 26 in 05AB1E, 25 in Pip, 24 in Thutu, 23 in Hexagony, 22 in Underload, 21 in Nim, 20 in Prelude, 19 in Reng (tested here), 18 in Cardinal, 17 in Julia, 16 in Pyth, 15 in Haystack, 14 in Turtlèd, 13 in Ruby, 12 in Fission, 11 in Befunge-98, 10 in Befunge-93, 9 in Perl 5, 8 in Retina, 7 in Japt, 6 in SMBF, 5 in Python 2, 4 in ><>, 3 in Minkolang, 2 in V/Vim, and 1 in Python 3.

Something must have been working in my subconcious in the time since the last submission to this challenge, because by the point I decided it was running low on time and I wanted to ensure it wouldn't die, I suddenly remembered a language from years back that could be added fairly easily as seen by the low increase in the byte count, and quite a bit of that was due to Hexagony rather than Trigger itself. Except for commands that assign to variables (which mostly don't matter), all Trigger's commands contain two consecutive equal characters. The first time this happens is in the Underload code in the first line, so I simply modified that a bit to jump to almost the end of the program, and placed the Trigger code to print 29 (which is 222999) there. The jump label I used is T (originally I tried U but Fission disliked it), but if you need to use a capital T in your own program for some reason, you can easily change both occurrences to something else that isn't used in your program.

Very little else needed changing, apart from (as always) the Hexagony. I decided it was time to stop messing around with formatting the code into a hexagon by hand, but luckily we've already had a challenge about Hexagony parsing, so I went and modified this answer to the challenge into an online-usable Hexagony formatter that handles backticks correctly (here). Here's how this version of the program looks as a hexagon:

 # v 1 6 / " < " 6 / b . q @ " ( : : : U ) : : ( 2 2 ) S # ; n 4 " 1 4 " # > 3 N 6 @ 1 5 o | > ^ * t t t * ~ + + ~ ~ ~ % # = ~ n J < R " 1 2 " ; # [ # < | p r i n t ( ( e v a l ( " 1 \ x 2 f 2 " ) a n d ( 9 ) o r ( 1 3 ) ) - ( 0 a n d 4 ) ^ ( 1 ) < < ( 6 5 ) > > 6 2 ) o r ' ( \ { ( \ { } ) ( \ { \ / + 2 3 ! @ # } [ ( ) ] ) } \ { } ) ( \ { } \ { } ) ' # @ 4 6 ( 8 + 9 + 9 + 9 + 9 + = ! ) = # p r i n t ( 1 7 ) # ] # e c h o 5 + 5 + 1 1 # | / = 1 / 2 4 = x = 9 0 / # 8 ␛ d g g i 2 ␛ | 1 | 6 $ / / ' ' 2 5 # > s a y 2 7 # U 2 2 2 9 9 9 " 2 6 . 

You might well have noticed that the Nim code is more verbose than it used to be. This is purely because padding it out as 5+5+11 rather than 21 happened to make the Hexagony line up perfectly; if you start at the / of /+23!@#, you can see an uninterrupted run of Hexagony-safe characters, and that's how I made that part of the program work.

30. Whitespace, 296 bytes

#v`16/"<"6/b.q@"(: ::T): ␉␉␉␉ :(22)S#;n4"14" #>3N6@15o|>␉^*ttt*~++~~~% #=~nJ<R"12"; ␉ #[␉ #`<`| print((eval("1\x2f2")and (9)or(13))-(0and 4)^(1)<<(65)>>62)or'(\{(\{})(\{\/+23!@}[()])}\{})(\{}\{})'#46(8+9+9+9+9+=!)=#print(17)#]#echo 21#|/=1/24=x=90/ #8␛dggi2␛␉` |1|6$//''25 #>say␉␉ 27#T222999"26 

␛ represents literal escapes.

␉ represents literal tabs.

This program prints 30 in Whitespace, 29 in Trigger, 28 in Brain-Flak, 27 in Perl 6, 26 in 05AB1E, 25 in Pip, 24 in Thutu, 23 in Hexagony, 22 in Underload, 21 in Nim, 20 in Prelude, 19 in Reng (tested here), 18 in Cardinal, 17 in Julia, 16 in Pyth, 15 in Haystack, 14 in Turtlèd, 13 in Ruby, 12 in Fission, 11 in Befunge-98, 10 in Befunge-93, 9 in Perl 5, 8 in Retina, 7 in Japt, 6 in SMBF, 5 in Python 2, 4 in ><>, 3 in Minkolang, 2 in V/Vim, and 1 in Python 3.

Whitespace is another esolang with a limited character set. This one only reads tabs, spaces, and line feeds.

So once we take out all the stuff that Whitespace doesn’t read we’re left with the following code:

[space][space][space][LF] [space][LF] [LF] [LF] [LF] [space][space][space][space][space][LF] [space][space][space][space] 

And the code to output 30 is this:

[space][space][space][tab][tab][tab][tab][space][LF] [tab][LF] [space][tab] 

So the top 3 lines of the existing code were given extra spaces at the end of lines to meet the requirements. Note that line 1’s tabs and trailing space are in the middle of the line to accommodate ><>’s needs.

Line 2’s space was changed to a tab here. This seems to function Identically to a space for the 2D languages, but visually it doesn’t line up anymore. ¯\_(ツ)_/¯

After the instructions to output 30, the game became getting the rest of the necessary spaces and line feeds to do pointless things and compile correctly.

White space happens to have instructions that mark/goto a code location with a label that allows for an arbitrary number of tabs and spaces, so that helped couch the long line’s spaces. It also starts and ends with a line feed, so that helped us up some of the line feeds in lines 3-6.

The final line couldn’t have a linefeed without breaking Retina, so its instructions are to do some arbitrary math and stack manipulation.

Here’s the full code with spaces, tabs, and linefeeds replaced with our notation:

#v`16/"<"6/b.q@"(:[Space]::T):[Space][Space][Tab][Tab][Tab][Tab][Space]:(22)S#;n4"14"[LF] #>3N6@15o|>[Tab]^*ttt*~++~~~%[LF] #=~nJ<R"12";[Space][Tab][LF] #[[Tab][LF] #`<`|[LF] print((eval("1\x2f2")and[Space](9)or(13))-(0and[Space]4)^(1)<<(65)>>62)or'(\{(\{})(\{\/+23!@}[()])}\{})(\{}\{})'#46(8+9+9+9+9+=!)=#print(17)#]#echo[Space]21#|/=1/24=x=90/[LF] #8␛dggi2␛[Tab]`[Space]|1|6$//''25[Space][Space]#>say[Tab][Tab][Space]27#T222999"26[LF] 

And here is a commented version of just the Whitespace:

Push 30 onto the stack [space][space][space][tab][tab][tab][tab][space][LF] Output the number at the top of the stack [tab][LF][space][tab] Jump to label null if the top of the stack is negative. (it's not) [LF][Tab][LF] Label this location as [Space] [LF][Space][Space][Space][LF] Add the top two items on the stack and replace them with the result. [Tab][Space][Space][Space] Store the stack. [Tab][Tab][Space] 

Edits: Hexagony turns out to skip over tabs just like spaces, contrary to my previous assertion. @ais523 was kind enough to update @Kenney's Hexagonizer to account for literal escapes and tabs. I had to modify it to correct my prior assertion about tabs being read as no-ops and to replace literal escapes with . because the ␛ character is wider than other characters, making the hex slightly misaligned. Here the link.

And this is our corrected current Hex:

 # v 1 6 / " < " 6 / b . q @ " ( : : : T ) : : ( 2 2 ) S # ; n 4 " 1 4 " # > 3 N 6 @ 1 5 o | > ^ * t t t * ~ + + ~ ~ ~ % # = ~ n J < R " 1 2 " ; # [ # < | p r i n t ( ( e v a l ( " 1 \ x 2 f 2 " ) a n d ( 9 ) o r ( 1 3 ) ) - ( 0 a n d 4 ) ^ ( 1 ) < < ( 6 5 ) > > 6 2 ) o r ' ( \ { ( \ { } ) ( \ { \ / + 2 3 ! @ } [ ( ) ] ) } \ { } ) ( \ { } \ { } ) ' # 4 6 ( 8 + 9 + 9 + 9 + 9 + = ! ) = # p r i n t ( 1 7 ) # ] # e c h o 2 1 # | / = 1 / 2 4 = x = 9 0 / # 8 . d g g i 2 . | 1 | 6 $ / / ' ' 2 5 # > s a y 2 7 # T 2 2 2 9 9 9 " 2 6 . . . . . . . 

Finally, I golfed out some needless characters, mostly added previously to line up Prelude parenthesis and Hexagony hexagons.

Nim’s code is back to echo 21 from echo 5+5+11

Hexagony’s #@46 is now #46

Hexagony’s code is back to /+23!@= from /+23!@

Prelude’s parenthetical alignment of (9) or (13) became (9)and(13)

Well, that’s all I got. Good Luck everyone!