A note that cohesion started breaking down around language 45-52, so those sub-programs are not guaranteed to work
><>, Gol><>, Foo, Befunge-93, Befunge-98, brainfuck, Brain-Flak, Python 2, Python 3, Hexagony, Perl, Ruby, Julia, Cardinal, Brainbash, Turtlèd, Deadfish~, Whitespace, Braille, Rail, Fission, ETA, Trigger, Self-modifying Brainfuck, Numberwang, Actually, Emoji, Symbolic Brainfuck, TinCan, Alphuck, Shove, Cood, Wise, Width, Whispers, Thue, Surface, Stones, evil, Set, Prelude, Gaot++, Cubix, Cubically, PATH, Commercial, Brian & Chuck, Monkeys, Nhohnhehr, Beam, AsciiDots, Alumin, Alice, Whirl
1. ><>
#;nnn@440
Works in ><>.
Reverses direction, adds 404 to the stack, prints and exits. Outputs 044 in Gol><> due to @ rotating the stack the other way, a common polyglot trick.
2. Gol><>
#;nnn404
Simplifies it so it works in both ><>s. Gol><> is largely backwards compatible, so I need to make sure not to mess with that part too much.
3. Foo
#"404",,,@;nnn404
Foo prints anything in quotes.
4. Befunge-93
# q"404",,,@;nnn404
Works in ><>, Foo, Befunge-93
In Befunge, # skips the next instruction. q is unsupported, so it is ignored (this is to stop Befunge-98 working, as it exits the program in that language). Adds the characters 404 to the stack and outputs it.
5. Befunge-98
# "404",,,@;nnn404
Works in ><>, Foo, Befunge-93, Befunge-98
Removes the q so this works in Befunge-98.
6. brainfuck
# "404",,,@nnn404
#-[<+>-----]<+.----.++++.>
Works in ><>, Foo, Befunge-93, Befunge-98, brainfuck
, will just set the cell to 0, so this is ignored. -[<+>-----]<+ sets the cell to 52 ('4'). .----.++++. outputs 404.
7. Brain-Flak
# "404",,,@nnn404
#-[<+>-----]<+.----.++++.>
#((((((((()()()){}){}){}()){}){}()){}){})
Works in ><>, Foo, Befunge-93, Befunge-98, brainfuck, Brain-Flak
Third line adds the number 404 to the stack, which is outputted implictly. The brackets in other sections have to be balanced, make sure that it ends on the right stack, and not pop the 404.
8. Python 2
# "404",,,@nnn404
#=-[<+>-----]<+.----.++++.>
#((((((((()()()){}){}){}()){}){}()){}){})
print 0 or 404
Works in ><> Foo, Befunge-93, Befunge-98, brainfuck, Brain-Flak, Python 2
Prints 404. # comments out the first 3 lines. Will not work in Ruby or Python 3.
9. Python 3
# "404",,,@nnn404
#=-[<+>-----]<+.----.++++.>
#((((((((()()()){}){}){}()){}){}()){}){})
print(0 or 404)
Works in ><> Foo, Befunge-93, Befunge-98, brainfuck, Brain-Flak, Python 2 Python 3
Puts brackets around the 0 or 404, which makes it work in both Python 2 and 3.
10. Hexagony
#$$"404",,,@nnn404
#=-[<+>-----]<+.----.++++.>
#((((((((()()(!@)){}){}){}()){}){}()){}){})
print(0 or 404)
(Will add all links later) Works in Hexagony
#$$" basically no-ops. The $s are there to pad the line a bit. 404 sets the current edge to 404. The hexagon wraps around to the !@ in the middle of the Brain-Flak section to print the number and end the program. Future additions will have to re-position the !@ and add a $ if the length exceeds 120 non-whitespace characters.
##11. Perl
#$$"404",,,@nnn404
#=-[<+>-----]<+.----.++++.>
#((((((((()()(!@)){}){}){}()){}){}()){}){})
print (0 or 404)
Works in Perl
Adds a space in between the print and the ( so the expression is properly evaluated.
12. Ruby
#$$"404",,,@nnn404
#=-[<+>-----]<+.----.++++.>
#((((((((()()(!@)){}){}){}()){}){}()){}){})
print(404)
Works in Ruby
Removes the 0 or so the Ruby program now prints 404. Before it printed 0, as 0 is a truthy value in Ruby.
13. Julia
#$$"404",,,@nnn404
#-[<+>-----]<+.----.++++.>
#((((((((()()!@()){}){}){}()){}){}()){}){})
print(404)
Works in Julia
Removes the = on the second line so it isn't a multi-line comment anymore and the print(404) is executed. Bet you didn't notice when I added that in ;). (The !@ from Hexagony has to be moved back one because the = was removed)
14. Cardinal
#$$"404"\\,,,@nnn404
#-[<+>-x%x----]<+.----.++++.>
#(((((((!@(()()()){}){}){}()){}){}()){}){})
print(404)
Works in ><>, Gol><>, Foo, Befunge-93, Befunge-98, brainfuck, Brain-Flak, Python 2, Python 3, Hexagony, Perl, Ruby, Julia, Cardinal.
Rather than keep playing with print(404), I'm going to start adding random esotoric languages.
Cardinal releases 4 pointers in cardinal directions from the character %. 2 of them are immediately killed by the xs to the left and right. The bottom one uses the ! from the Hexagony to skip over the instruction 4 and goes out of bounds. The final one bounces off the \ to the left and hits the ". This starts console output mode and prints the 404 (thankfully 404 is palindromic). $ sets the pointer location to 0,0, which means it goes out of bounds and ends the program. Previous programs won't work because there are no %s to start from. The \ swaps the top two values of the stack in Befunge, so I counter that with another \.
15. Brainbash
#$$"404"\\,,,@nnn404
#[-]-[<x%x+>-----]<+.----.++++.>
#((((!@(!(((()()()){}){}){}()){}){}()){}){})
print(404)
Works in ><>, Gol><>, Foo, Befunge-93, Befunge-98, brainfuck, Brain-Flak, Python 2, Python 3, Hexagony, Perl, Ruby, Julia, Cardinal and Brainbash.
Brainbash is a brainfuck variant that adds several commands. One of which, # inputs a number, returning -1 if there is none, meaning it messes up the brainfuck code later and prints gcg. [-] is inserted before the brainfuck code to set the cell to 0 and make it print 404 in both languages. The rest of the work is moving around the Cardinal and Hexagony code to make sure it still works.
16. Turtlèd
##$"404"\\# ,,,@nnn404#!
#[-]-[<x%x+>-----]<+.----.++++.>
#(!@((((!(((()()()){}){}){}()){}){}()){}){})
print(404)
Works in ><>, Gol><>, Foo, Befunge-93, Befunge-98, brainfuck, Brain-Flak, Python 2, Python 3, Hexagony, Perl, Ruby, Julia, Cardinal, Brainbash, and Turtlèd
Turtled is yet another aquatic animal-based language. The main point is that #...# defines a variable name, so all previous programs error since the first # isn't closed before the end of the line. Here the first # is immediately closed, $ is a no-op, "404" puts 404 on the grid, #...# ignores the next section, ! takes input (none) and I'm not sure why the rest of the program isn't run?
(the worst part of all this is copying all the TIO links)
17. Deadfish~
##$"404"\\# ,,,@nnn404#!
#[-]-[<x%x+>-----]<+.----.++++.>((!@((((((()()()){}){}){}()){}){}()){}){})iisoddddoiisoh
print(404)
Works in ><>, Gol><>, Foo, Befunge-93, Befunge-98, brainfuck, Brain-Flak, Python 2, Python 3, Hexagony, Perl, Ruby, Julia, Cardinal, Brainbash, Turtlèd, and Deadfish~
Let's do some more aquatic animals. Even if it's stinky and inedible. Deadfish~ only has 9 commands, where the only code running here is iisoddddoiisoh which is increment twice, square the accumulator, print as number, decrement down to 0, output, increment twice, square the accumulator, print as number, halt program.
Also, I folded the third line into the second, because I'm not sure why I had those as separate to begin with.
18. Whitespace
##$"404"\\# ,,,@ nnn404#!
#[-]-[<x%x+>-----]<+.----.++++.>((!@((((((()()()){}){}){}()){}){}()){}){})iisoddddoiisoh
print(404)
Works in ><>, Gol><>, Foo, Befunge-93, Befunge-98, brainfuck, Brain-Flak, Python 2, Python 3, Hexagony, Perl, Ruby, Julia, Cardinal, Brainbash, Turtlèd, Deadfish~, and Whitespace
Adds a bunch of whitespace to the program, that affects pretty much nothing. Hexagony ignores whitespace by default, though there was a bit of trouble with tabs being invalid instructions in both ><> and Befunge-98.
19. Braille
##$"404"\\# ,,,@ nnn404#!
#[-]-[<x%x+>-----]<+.----.++++.>((((((((()()()){}){})?{!@}()){}){}()){}){})iisoddddoiisoh ⠎⡆⡎⡆⢐⠣⠃
print(404)
Works in Braille.
The relevant Braille code here is ⠎⡆⡎⡆⢐⠣⠃. Braille uses the code itself as data, positioning the data pointer one cell after the end of the program. The ⠣⠃ is 40, which is printed by ⠎⡆⡎⡆ and halted by ⢐.
⠎ Move the data pointer back 2^1 = 2 spaces
v<<
'....40'000
⡆ Print the current character (4)
⡎ Print the character one cell forward (0)
⡆ Print the current character again (4)
⢐ Halt
Python 2 complains about the unicode characters, but works locally. Hexagony exceeded the next Hexagon number, so I used the { in the Brain-flak to counteract the extra " at after the 404. I padded this with a question mark before the {!@.
20. Rail
##$"404"\\# ,,,@ nnn404#!
#[-]-[<x%x+>-----]<+.----.++++.>((((((((()()()){}){})?{!@}()){}){}()){}){})iisoddddoiisoh ⠎⡆⡎⡆⢐⠣⠃
print(404)
__DATA__=1
"""
$'main'
\-4o0o4o
"""
Works in Rail.
I wanted to do Rail, since it's a few letters less than Braille, but it requires a line that starts with $ to define the main function. Perl hates this, along with the other conventional languages, so I had to modify parts to get this working. __DATA__=1 kills Perl is stolen from the big polyglot question, coincidentally also from an answer adding Rail. Ruby, Julia and Python are mollified by the unsigned string. Future languages will probably take place in that string too.
$'main' defines the Rail main function. It goes south-east from there, down to the \- which redirects it to the left. 4o0o4o prints the 404 and crashes (literally).
21. Fission
##$"404"\\# ,,,@ nnn404#!
#[-]-[<x%x+>-----]<+.----.++++.>((((((((()()()){}){})?{!@}()){}){}()){}){})iisoddddoiisoh ⠎⡆⡎⡆⢐⠣⠃
print(404)
__DATA__=1
# \"404"*
"""
$'main'
\-4o0o4o
"""
Works in Fission
Reuses the D from the DATA to spawn a downwards moving atom. This bounces off the \, prints 404 and ends the program when it hits the *. Future additions need to be careful around the characters UDLR
22. ETA
##$$"404"\\# ,,,@ nnn404#!
#[-]-[<+x%x>-----]<+.----.++++.>NTNNEONHSSEONTHOEONOET((((((((()()()){}){})?{!@}()){}){}()){}){})iisoddddoiisoh ⠎⡆⡎⡆⢐⠣⠃
print(404 )
__DATA__=1
# \"404"*
"""
$'main'
\-4o0o4o
"""
ETA is kind of a weird language (that's what I get for clicking random languages on TIO). It has 8 instructions, ETAOINSH (case-insenitive). The executing part of the code is NTNNEONHSSEONTHOEONOET, with the nnn in the first line basically acting as a NOP.
NTNNE adds a 4 to the stack by using the N command to add the base 7 string TNN, which is 52 (ascii 4). O outputs this, and similar operations are done for 0 in NHSSEO and the other 4 in NTHOEO. Finally, NOE adds a 3 to the stack, and T skips to line 3 (i think. maybe it skips the line 40 idk). This has to be capitalised to avoid running Deadfish~ commands.
Hexagony reaches the next Hexagon number and has to add another padding $ to the beginning. This means the Cardinal x%x has to be moved over one. This means a space has to be added in the print(404) section. This means a space has to be deleted from straight after that for Whitespace (wow, this is getting complicated).
23. Trigger
##$$"404"\\# ,, ,@ nnn404#!
#[-]-[<+x%x>-----]<+.----.++++.>NTNNEONHSSEONTHOEONOET((((((((()()()){}){})?{!@}()){}){}()){}){})iisoddddoiisoh ⠎⡆⡎⡆⢐⠣⠃
print(404 )
__DATA__=1
# \"404"*11'
"""
$'main'
\-444o000o444o11#
"""
#
Trigger has another weird syntax. Commands are strings of identical characters. One character inverts the data for that character (0 to 1, 1 to 0). Two characters acts as an if statement which takes a third character and skips to the closest dupe of the third character if the data of the first/second is 1. Three characters outputs that character. Four characters gets input.
To work the code, I first needed to separate the ,,, from Befunge, so they didn't print. After that, any sets of three characters are skipped until the two sets of quotes. To stop those printing, I inserted 11' so it skips to the starting quote of 'main'. That line does nothing because they are all single characters. 444, 000, 444 output 404 without affecting the Rail code, and 11# skips the ending triple quotes to the final #.
##$$"404"\\# ,, ,@ nnn404#!
#<[-]>[-x%x]-[<+>-----]<+.----.++++.>NTNNEONHSSEONTHOEONOET((((((((()()())??{!@}){}){}()){}){}()){}){})iisoddddoiisoh ⠎⡆⡎⡆⢐⠣⠃
print(404 )
__DATA__=1
# \"404"*11'
"""
$'main'
\-444o000o444o11#
"""
#
Self-modifying brainfuck won't work with previous programs, as the first negative cell will be initialised with the last character of the source code. In this iteration all I did was add <[-]> which zeroes the first negative cell, which makes the rest of the brainfuck run normally.
25. Numberwang
##$$"404"\\# ,, ,@ nnn404#!
#<[-]>[-x%x]-[<+>-----]<+.----.++++.>NTNNEONHSSEONTHOEONOET((((((((()()())??{!@}){}){}()){}){}()){}){})iisoddddoiisoh ⠎⡆⡎⡆⢐⠣⠃
print(404 )
__DATA__=1
# \"404"*11'
"""
$'main'
\-444o000o444o11#
"""
#7777777777777724091557093543643
Numberwang is a brainfuck derivative with a couple of extra commands and uses numbers to represent commands. Non-numbers are ignored.
The string of 7s (] in brainfuck) at the end are to counter all the 4s ([). The executing code is 24091557093543643 which is equivalent to the brainfuck -[<+>-----]<+.----.++++.
#26. Actually
##""$$"404"\\# , ,,*@ nnn404#!
#NTNNEONHSx%xSEONTHOEONOET((((((((()()()){}){}){}()){}){}()){}){})iisoddddoiisoh<[-]>[-]-[<+>-----]!@<+"404".⌂----.++++.> ⠎⡆⡎⡆⢐⠣⠃
print(404)
__DATA__=1
# \"404"*,,'
"""
$'main'
\-444o000o444o,,#
"""
#777777777777777724091557093543643
Mego suggests Actually, by putting a .⌂ after the "404". Unfortunately, . prints something in both brainfuck and Befunge, meaning I would have to insert it somewhere else. I tried to reuse the first . in the brainfuck, but that means it prints an extra copy in Foo. I swapped the brainfuck and Brain-Flak sections, because Foo errors somewhere in the Brain-Flak. I also had to redo the Trigger code to be more robust (and stop looping forever), so the extra * in the Befunge section skips to the Fission section which then skips to the Rail section. I also had to add a couple of 7s to the Numberwang.
27. Emoji
##""$$"404"\\# , ,,*@ nnn404#!
#NTNNEONHSx%xSEONTHOEONOET((((((((()()()){}){}){}()){}){}()){}){})iisoddddoiisoh<[-]>[-]-[<+>-----]!@<+"404".⌂----.++++.>
print(404)
__DATA__=1
# \"404"*,,'
"""
$'main'
\-444o000o444o,,#
"""
#777777777777777724091557093543643💬404💬➡77⠎⡆⡎⡆⢐⠣⠃
Adds the trivial 💬404💬➡ to the code. Needs a couple of 7s to for Numberwang. Luckily, 404 is [>[ in brainfuck, so it doesn't loop forever. For some reason Braille counts Emojis as data, so I moved it to the end.
##\$"404"# , ,,\404!@ *nnn404#!
#NTNNEONHSSEONTHOEONOET((((((((()()()){}){}){}()){}){}()){}){})iisoddddoiisoh<[-]>[-]-[<+>-----]!@<+x%"404"?.⌂----.++++.>
print(404)
__DATA__=1
# \"404"* '
"""
$'main'
\-444o000o444o!!#
"""
#77777777777777777724091557093543643💬404💬➡77▲▲▲²²▲²²¡▼▼▼▼¡▲▲▲▲¡⠎⡆⡎⡆⢐⠣⠃
Symbolic Brainfuck is a brainfuck derivative with a few extra commands and different symbols. The relevant code here is ▲▲▲²²▲²²¡▼▼▼▼¡▲▲▲▲¡, which is the same as in dylnan's answer. Yet again, Braille is confused about the non-ASCII characters, so it gets moved further to the end.
Hexagony increased to another Hexagon number, so I edited to be more robust. Now it only runs over the first line of the code. I took the opportunity to edit other parts. Cardinal was moved to reuse the 404 from Actually, which now has a nop ? between the " and the ..
#29. TinCan
##\$"404"# , ,,\404!@ *nnn404#!
#NTNNEONHSSEONTHOEONOET((((((((()()()){}){}){}()){}){}()){}){})iisoddddoiisoh<[-]>[-]-[<+>-----]!@<+x%"404"?.⌂----.++++.>
print(404)
__DATA__=1
# \"404"* '
"""
# -52, Z, -1 #
# -48, Y, -1 #
# -52, X, -1 #
$'main'
\-444o000o444o!!2
"""
#777777777777777777724091557093543643💬404💬➡77▲▲▲²²▲²²¡▼▼▼▼¡▲▲▲▲¡⠎⡆⡎⡆⢐⠣⠃
Thanks to dylnan for suggesting this! Tin Can is definitely a big addition, with each command being 40 characters long. This is a total of 120 for the three commands to create the 404. Another 7 in the Numberwang, which messed up the Trigger slightly, so I changed the Trigger code to skip to the 2 instead of the #.
#30. Alphuck
##\$"404"# , ,,@\404!@ *nnn404#!
#NTNNEONHSSEONTHOEONOET((((((((()()()){}){}){}()){}){}()){}){})iipesoddddoiipesoh ipceaiiiiiscejiiiijeeeeja<[-]>[-]-[<+>-----]!@<+x%"404"?.⌂----.++++.>
print(404)
__DATA__=1
# \"404"* '
"""
# -52, Z, -1 #
# -48, Y, -1 #
# -52, X, -1 #
$'main'
\-444o000o444o$$2
"""
#777777777777777777724091557093543643💬404💬➡77▲▲▲²²▲²²¡▼▼▼▼¡▲▲▲▲¡⠎⡆⡎⡆⢐⠣⠃s
Another brainfuck derivative, this time using alphabetic characters. The problems were the extra ss (]) from Deadfish~, which needed corresponding ps ([). The rest of the code, ipceaiiiiiscejiiiijeeeeja is equivalent to the brainfuck code. Finally, the p in print also needs an ending s, which is at the end of the code. Thankfully, the output command, j will be fairly rare.
Hexagon reached another hexagon number, so it gets moved around a bit.
31. Shove
##\$"404"# , ,,@\404!@NS^ *nnn404#!
#ENTHOEONHSSEONTHOEONOET((((((((()()()){}){}){}()){}){}()){}){})iipesoddddoiipesoh ipceaiiiiiscejiiiijeeeeja<[-]>[-]-[<+>-----]!@<+x%"404"?.⌂----.++++.>
print(404)
__DATA__=1
# \"404"* '
"""
# -52, Z, -1 #
# -48, Y, -1 #
# -52, X, -1 #
$'main'
\-444o000o444o$$2
"""
#777777777777777777724091557093543643💬404💬➡77▲▲▲²²▲²²¡▼▼▼▼¡▲▲▲▲¡⠎⡆⡎⡆⢐⠣⠃s
Shove is a 2D non-wrapping language with very minimal command set, thankfully ignoring non-valid commands. The "404" in the first line adds the string 404 to the stack and the S prints it. The ^ then pushes the pointer out of the playfield, ending the program, before the ns print 3 newlines. Or uhh, just the literal characters \n.
ETA interprets the S as the start of a command, so I put an N before it to be interpreted as a number. I rearranged the rest of the ETA code to account for this.
32. Cood
##\$"404"# , ,,@\404!@NS^ *nnn404#!
#ENTHOEONHSSEONTHOEONOET((((((((()()()){}){}){}()){}){}()){}){})iipesoddddoiipesoh ipceaiiiiiscejiiiijeeeeja<[-]>[-]-[<+>-----]!@<+x%"404"?.⌂----.++++.>
print(404)
__DATA__=1
# \"404"* '
"""pp
I want 404 of this
How much is it
# -52, Z, -1 #
# -48, Y, -1 #
# -52, X, -1 #
$'main'
\-444o000o444o$$2
"""
#77777777777777777777724091557093543643💬404💬➡77▲▲▲²²▲²²¡▼▼▼▼¡▲▲▲▲¡⠎⡆⡎⡆⢐⠣⠃s
Cood is a restaurant based language. The only functioning code here is the two lines:
I want 404 of this
How much is it
Which sets the current cell to 404 and outputs it as a number. The rest is accounting for the ss in Alphuck and the 4s in Numberwang.
33. Wise
##\$"404"# , ,,@?\404!@NS^ *nnn404#!
#ENTHOEONHSSEONTHOEONOET((((((((()()()){}){}){}()){}){}()){}){})iipesoddddoiipesoh ipceaiiiiiscejiiiijeeeeja<[-]>[-]-[<+>-----]!@<+x%"404"?.⌂----.++++.>
print(404)
__DATA__=1
# \"404"* '
"""pp
I want 404 of this
How much is it
# -52, Z, -1 #
# -48, Y, -1 #
# -52, X, -1 #
$'main'
\-444o000o444o$$|
"""
#77777777777777777777724091557093543643💬404💬➡77▲▲▲²²▲²²¡▼▼▼▼¡▲▲▲▲¡⠎⡆⡎⡆⢐⠣⠃s~-<<:<<:<<<:<:>>>>>>>>:^||||<>
Wise is a language made up of almost entirely bitwise operators with 11 instructions. This is made extremely hard by the fact that the two main operators, <>, which bitshift the current number, have to be balanced in Brain-Flak. The executing part here is ~-<<:<<:<<<:<:>>>>>>>>:^||||<>.
~- Makes a 1
<<:<<:<<<:< Creates 4, 16, 128, 256
:>>>>>>>> Dupes the 256 and bitshifts it all the way down to 1 to balance the braces.
:^ Converts the 1 to a 0
|||| Adds the whole stack to create 404 and output implicitly.
<> Extra swap stack command to get Brain-Flak on the right stack.
For once, this affects pretty much nothing in the main code except Hexagony reaching another hexagon number and needing one more byte of padding.
34. Width
##\$"404"# , ,,@?\404!@NS^GJlICJlGCC? *nnn404#!
#ENTHOEONHSSEONTHOEONOET((((((((()()()){}){}){}()){}){}()){}){})iipesoddddoiipesoh ipceaiiiiiscejiiiijeeeeja<[-]>[-]-[<+>-----]!@<+x%"404"?.⌂----.++++.>
print(404)
__DATA__=1
# \"404"* '
"""pp
I want 404 of this
How much is it
# -52, Z, -1 #
# -48, Y, -1 #
# -52, X, -1 #
OUT &52 &1
OUT &48 &1
OUT &52 &1
$'main'
\-444o000o444o$$|
"""
#777777777777777777777724091557093543643💬404💬➡77▲▲▲²²▲²²¡▼▼▼▼¡▲▲▲▲¡⠎⡆⡎⡆⢐⠣⠃s~-<<:<<:<<<:<:>>>>>>>>:^||||<>
Width is entirely based on the width of alphabetic letters (lol, who doesn't use monospace?). All non-alpha characters are ignored. Each width has a different corresponds to a different number, some of which are plain instructions, others part of chains of instructions. The executing part here is GJlICJlGCC on the first line.
G Start string literal
Jl Push 16 ('4')
IC Push 12 ('0')
Jl Push 16 ('4')
G End string literal
CC Push the command 22, which corresponds to pop and output
Thankfully, none of the rest of the alphabetic characters do anything. In the future, if they do, all I need to do is use a string literal over the rest of the code.
35. Whispers
##\$"404"# , ,,@?\404!@NS^GJlICJlGCC?G *nnn404#!
#ENTHOEONHSSEONTHOEONOET((((((((()()()){}){}){}()){}){}()){}){})iipesoddddoiipesoh ipceaiiiiiscejiiiijeeeeja<[-]>[-]-[<+>-----]!@<+x%"404"?.⌂----.++++.>
print(404)
__DATA__=1
# \"404"* '
"""pp
I want 404 of this
How much is it
# -52, Z, -1 #
# -48, Y, -1 #
# -52, X, -1 #
OUT &52 &1
OUT &48 &1
OUT &52 &1
$'main'
\-444o000o444o$$|<<<
> 404
>> Output 1
s"""
#77777777777777777777777724091557093543643💬404💬➡77▲▲▲²²▲²²¡▼▼▼▼¡▲▲▲▲¡⠎⡆⡎⡆⢐⠣⠃s~-<<:<<:<<<:<:>>>>>>>>:^||||G
To be honest, I didn't read past the Hello, World! example. Added code:
> 404
>> Output 1
Decided to add that Width string literal anyway. Balanced braces for Brain-Flak and Numberwang. Surprisingly, Rail complained about the 404 being directly under it, so I added a newline between them.
For those keeping track, there are now 9 different 404s in my code.
36. Thue
##\$"404"# , ,,@??\404!@NS^GJlICJlGCC?G *nnn404#!
#ENTHOEONHSSEONTHOEONOET((((((((()()()){}){}){}()){}){}()){}){})iipesoddddoiipesoh ipceaiiiiiscejiiiijeeeeja<[-]>[-]-[<+>-----]!@<+x%"404"?.⌂----.++++.>
print(404)
__DATA__=1
# \"404"* '
"""pp
I want 404 of this
How much is it
# -52, Z, -1 #
# -48, Y, -1 #
# -52, X, -1 #
OUT &52 &1
OUT &48 &1
OUT &52 &1
$'main'
\-444o000o444o$$|<<<
[
x::=~404
::=
x
-]
> 404
>> Output 1
s"""
#7777777777777777777777777724091557093543643💬404💬➡77▲▲▲²²▲²²¡▼▼▼▼¡▲▲▲▲¡⠎⡆⡎⡆⢐⠣⠃s&&&&~-<<:<<:<<<:<:>>>>>>>>:^||||G<>
Executing code is:
x::=~404
::=
x
Brainbash went into an infinite loop so I enclosed it in brackets. This made self-modifying brainfuck go into an infinite loop so I put a - in there as well.
37. Surface
##\$"404"# , ,,@??\404!@NS^GJlICJlGCC?G *nnn404#!
#E\++++:----:++++:^NTHOEONHSSEONTHOEONOET((((((((()()()){}){}){}()){}){}()){}){})iipesoddddoiipesoh ipceaiiiiiscejiiiijeeeeja<[-]>[-]-[<+>-----]!@<+x%"404"?.⌂----.++++.>
print(404)
__DATA__=1
# \"404"* '
"""pp
I want 404 of this
How much is it
# -52, Z, -1 #
# -48, Y, -1 #
# -52, X, -1 #
OUT &52 &1
OUT &48 &1
OUT &52 &1
$'main'
\-444o000o444o$$|<<<
[
x::=~404
::=
x
-]
> 404
>> Output 1
s"""
#7777777777777777777777777724091557093543643💬404💬➡77▲▲▲²²▲²²¡▼▼▼▼¡▲▲▲▲¡⠎⡆⡎⡆⢐⠣⠃s&&&&~-<<:<<:<<<:<:>>>>>>>>:^||||G<>
Surface is another 2D language. The executing code is:
\ @ \
\++++:----:++++:^
Which increments the cell to 4, prints it as a number, decrements it to 0, print, increment to 4, prints and redirects to the @ to halt the program. This doesn't affect the brainfuck code as it zeroes all the cells beforehand.
38. Stones
##\$"404"# , ,,@???\404!@NS^GJlICJlGCC?G *nnn404#!
#E\++++:----:++++:?^NTHOEONHSSEONTHOEONOET((((((((()()()){}){}){}()){}){}()){}){})iipesoddddoiipesoh ipceaiiiiiscejiiiijeeeeja<[-]>[-]-[<+>-----]!@<+x%"404"?.⌂----.++++.>
print(404)
__DATA__=1
# \"404"* '
"""pp
I want 404 of this
How much is it
# -52, Z, -1 #
# -48, Y, -1 #
# -52, X, -1 #
OUT &52 &1
OUT &48 &1
OUT &52 &1
$'main'
\-444o000o444o$$|<<<
[
x::=~404
::=
x
-]
> 404
>> Output 1
red up two blue up red up one blue up red up two blue up
sssssss"""
#7777777777777777777777777724091557093543643💬404💬➡77▲▲▲²²▲²²¡▼▼▼▼¡▲▲▲▲¡⠎⡆⡎⡆⢐⠣⠃s&&&&~-<<:<<:<<<:<:>>>>>>>>:^||||G<>
Stones uses instructions by moving stones around a wrapping field, with each move being a command. Luckily none of the commands used here cause the stones to collide. The commands used here are red up one and two, which are 0 and 4 respectively, and blue up, which prints the top of the stack as a number. All that's left is to satisfy Alphuck by adding some ss to account for all the ps.
39. evil
##\$"404"# , ,,@???\404!@NS^GJlICJlGCC?G *nnn404#!
#E\++++:----:++++:?^NTHOEONHSSEONTHOEONOET((((((((()()()){}){}){}()){}){}()){}){})iipesoddddoiipesoh ipceaiiiiiscejiiiijeeeeja<[-]>[-]-[<+>-----]!@<+x%"404"?.⌂----.++++.>pzaeeaeueewzaeeeaeewzaeeaeueews
print(404)
__DATA__=1
# \"404"* '
"""pp
I want 404 of this
How much is it
# -52, Z, -1 #
# -48, Y, -1 #
# -52, X, -1 #
OUT &52 &1
OUT &48 &1
OUT &52 &1
$'main'
\-444o000o444o$$|<<<
[
x::=~404
::=
x
-]
> 404
>> Output 1
red up two blue up red up one blue up red up two blue up
sssssss"""
#7777777777777777777777777724091557093543643💬404💬➡77▲▲▲²²▲²²¡▼▼▼▼¡▲▲▲▲¡⠎⡆⡎⡆⢐⠣⠃s&&&&~-<<:<<:<<<:<:>>>>>>>>:^||||G<>
The evil code is zaeeaeueewzaeeeaeewzaeeaeueew, which is encased in an Alphuck loop to stop it from looping forever.
40. Set
##\$"404"# , ,,@???\404!@NS^GJlICJlGCC?G *nnn404#!
#E\++++:----:++++:?^NTHOEONHSSEONTHOEONOET((((((((()()()){}){}){}()){}){}()){}){})iipesoddddoiipesoh ipceaiiiiiscejiiiijeeeeja<[-]>[-]-[<+>-----]!@<+x%"404"?.⌂----.++++.>pzaeeaeueewzaeeeaeewzaeeaeueews
print(404)
__DATA__=1
# \"404"* '
"""pp
I want 404 of this
How much is it
# -52, Z, -1 #
# -48, Y, -1 #
# -52, X, -1 #
OUT &52 &1
OUT &48 &1
OUT &52 &1
$'main'
\-444o000o444o$$|<<<
[
x::=~404
::=
x
-]
> 404
>> Output 1
red up two blue up red up one blue up red up two blue up
set ! 52
set ! 48
set ! 52
ssss"""
#77777777777777777777777777724091557093543643💬404💬➡77▲▲▲²²▲²²¡▼▼▼▼¡▲▲▲▲¡⠎⡆⡎⡆⢐⠣⠃s&&&&~-<<:<<:<<<:<:>>>>>>>>:^||||G<>
Another short addition:
set ! 52
set ! 48
set ! 52
Saved a few bytes by reusing the ss for Alphuck.
Woo, made it to 40 languages! Two thirds of the way there!
41. Prelude
##\$"404"# , ,,@???\404!@NS^GJlICJlGCC?G *nnn404#!
#E\++++:----:++++:@((((((((()()()){}){}){}()){}){}()){}){})<[-]>[-]-[<+>-----]<+x%"404"?.⌂----.++++.>
#i(NTHOEONHSSEONTHOEONSETipesoddddoiipesohipceaiiiiiscejiiiijeeeejapzaeeaeueewzaeeeaeewzaeeaeueews)999997+++++!999777+++++!999997+++++!
print(404)
__DATA__=1
# \"404"* '
"""pp
I want 404 of this
How much is it
# -52, Z, -1 #
# -48, Y, -1 #
# -52, X, -1 #
OUT &52 &1
OUT &48 &1
OUT &52 &1
$'main'
\-444o000o444o$$|<<<
[
x::=~404
::=
x
-]
> 404
>> Output 1
red up two blue up red up one blue up red up two blue up
set ! 52
set ! 48
set ! 52
ssss"""
#777777777777777777777724091557093543643💬404💬➡77▲▲▲²²▲²²¡▼▼▼▼¡▲▲▲▲¡⠎⡆⡎⡆⢐⠣⠃s&&&&~-<<:<<:<<<:<:>>>>>>>>:^||||G<>
Did some rearranging. The Prelude code is on the end of the third line. I would have made it more optimised, but I'm pretty sure Prelude doesn't like the Unicode characters on other lines.
999997+++++!999777+++++!999997+++++!
Also made sure to use several 7s, to save on the large string from Numberwang at the bottom.
42. Gaot++
##\$"404"# , ,,@????\404!@NS^GJlICJlGCC?G *nnn404#!
#E\++++:----:++++:@((((((((()()()){}){}){}()){}){}()){}){})<[-]>[-]-[<+>-----]<+x%"404"?.⌂----.++++.>
#i(NTHOEONHSSEONTHOEONSETipesoddddoiipesohipceaiiiiiscejiiiijeeeejapzaeeaeueewzaeeeaeewzaeeaeueews)999997+++++!999777+++++!999997+++++!
print(404)
__DATA__=1
# \"404"* '
"""pp
I want 404 of this
How much is it
# -52, Z, -1 #
# -48, Y, -1 #
# -52, X, -1 #
OUT &52 &1
OUT &48 &1
OUT &52 &1
$'main'
\-444o000o444o$$|<<<
[
x::=~404
::=
x
-]
> 404
>> Output 1
red up two blue up red up one blue up red up two blue up
baaaaa bleeeeeeeeet bleeeeeeeeet baaaaa bleeeeeeeeet
set ! 52
set ! 48
set ! 52
ssss"""
#777777777777777777777724091557093543643💬404💬➡77▲▲▲²²▲²²¡▼▼▼▼¡▲▲▲▲¡⠎⡆⡎⡆⢐⠣⠃s&&&&~-<<:<<:<<<:<:>>>>>>>>:^||||G<>
The goat code is:
baaaaa bleeeeeeeeet bleeeeeeeeet baaaaa bleeeeeeeeet
Which translates to add 4 to stack, pop and print, print implicit 0, add 4, print. Added another ? to pad Hexagony a bit.
43. Cubix
##\$"404"# , ,,@????\404!@NS^GJlICJlGCC?G *nnn404#!
#?\++++:----:++++:@((((((((()()()){}){}){}()){}){}()){}){})<[-]>[-]-[<+>-4O0O4O@----]<+x%"404"?.⌂----.++++.>
#i(ENTHOEONHSSEONTHOEONSETipesoddddoiipesohipceaiiiiiscejiiiijeeeejapzaeeaeueewzaeeeaeewzaeeaeueews)999997+++++!999777+++++!999997+++++!
print(404)
__DATA__=1
# \"404"* '
"""pp
I want 404 of this
How much is it
# -52, Z, -1 #
# -48, Y, -1 #
# -52, X, -1 #
OUT &52 &1
OUT &48 &1
OUT &52 &1
$'main'
\-444o000o444o$$|<<<
[
x::=~404
::=
x
-]
> 404
>> Output 1
red up two blue up red up one blue up red up two blue up
baaaaa bleeeeeeeeet bleeeeeeeeet baaaaa bleeeeeeeeet
set ! 52
set ! 48
set ! 52
ssss"""
#77777777777777777777777724091557093543643💬404💬➡77▲▲▲²²▲²²¡▼▼▼▼¡▲▲▲▲¡⠎⡆⡎⡆⢐⠣⠃s&&&&~-<<:<<:<<<:<:>>>>>>>>:^||||G<>
Cubix wraps instructions around a cube, and starts from the left side (thank god it isn't the beginning). The relevant code is in the middle of the brainfuck section:
4O0O4O@
Which pushes 404 and outputs. Ends with the @. Needs some more ending 7s for Numberwang.
44. Cubically
##\$"404"# , ,,!1@??\404!?@NS^GJlICJlGCC?G+0%=%=+0%& *nnn404#!
#?\++++:----:++++:@((((((((()()()){}){}){}()x)x{}){}()){}){})<4O0O4O@[-]>[-]-[<+>-----]<+x%"404"?.⌂----.++++.>
#i(ENTHOEONHSSEONTHOEONSETipesoddddoiipesohipceaiiiiiscejiiiijeeeejapzaeeaeueewzaeeeaeewzaeeaeueews)999997+++++!999777+++++!999997+++++!
print(404)
__DATA__=1
# \"404"* '
"""pp
I want 404 of this
How much is it
# -52, Z, -1 #
# -48, Y, -1 #
# -52, X, -1 #
OUT &52 &1
OUT &48 &1
OUT &52 &1
$'main'
\-444o000o444o$$|<<<
[
x::=~404
::=
x
-]
> 404
>> Output 1
red up two blue up red up one blue up red up two blue up
baaaaa bleeeeeeeeet bleeeeeeeeet baaaaa bleeeeeeeeet
set ! 52
set ! 48
set ! 52
ssss"""
#77777777777777777777777724091557093543643💬404💬➡77▲▲▲²²▲²²¡▼▼▼▼¡▲▲▲▲¡⠎⡆⡎⡆⢐⠣⠃s&&&&~-<<:<<:<<<:<:>>>>>>>>:^||||G<>
Cubically uses a Rubik's cube as the memory. The S earlier in the code rotates the middle layer clockwise, pushing the 3 1s from the 1 face to the 0 face. The relevant code is on the first line:
+0%=%=+0%&
The notepad is set to 1 at some point, so I add face 0 to the notepad, output, set the notepad to 0, output it, set it to 1 and add 3 again, and output it. Some extra xs to satisfy Cardinal, some trickery to make Cubically skip the @ from Befunge without breaking anything.
45. PATH
##\$"404"# , ,,!1@!??\404!?@NS^GJlICJlGCC?G+0%=%=+0%& *nnn404#!
#?\++++:----:++++:@((((((((()()()){}){}){}())x{x}){}()){}){})<[-]>[-]-[<+>-----]<+???4O0O4O@x%"404"?.⌂----.++++.>
#i(ENTHOEONHSSEONTHOEONSETipesoddddoiipesohipceaiiiiiscejiiiijeeeejapzaeeaeueewzaeeeaeewzaeeae?ueews)999997+++++!999777+++++!999997+++++!
print(404)
__DATA__=1
# \"404"* '
"""pp
I want 404 of this
How much is it
# -52, Z, -1 #
# -48, Y, -1 #
# -52, X, -1 #
OUT &52 &1
OUT &48 &1
OUT &52 &1
$'main'
\-444o000o444o$$|<<<
[
x::=~404
::=
x
-]
> 404
>> Output 1
red up two blue up red up one blue up red up two blue up
baaaaa bleeeeeeeeet bleeeeeeeeet baaaaa bleeeeeeeeet
[-][$++++++++++++++++++++++++++++++++++++++++++++++++++++.----.++++.#]
set ! 52
set ! 48
set ! 52
ssss"""
#77777777777777777777777724091557093543643💬404💬➡77▲▲▲²²▲²²¡▼▼▼▼¡▲▲▲▲¡⠎⡆⡎⡆⢐⠣⠃s&&&&~-<<:<<:<<<:<:>>>>>>>>:^||||G<>
46. Commercial
##\$"404"# , ,,!1@??\404!?@NS^GJlICJlGCC?G+0%=%=+0%& *nnn404#!
#?\++++:----:++++:@((((((((()()()){}){}){}()x)x{}){}()){}){})<[-]>[-]-[<+>-----]<+???4O0O4O@x%"404"?.⌂----.++++.>
#i(ENTHOEONHSSEONTHOEONSETipesoddddoiipesohipceaiiiiiscejiiiijeeeejapzaeeaeueewzaeeeaeewzaeeaeueewqs)999997+++++!999777+++++!999997+++++!
print(404)
__DATA__=1
# \"404"* '
"""pp
I want 404 of this
How much is it
# -52, Z, -1 #
# -48, Y, -1 #
# -52, X, -1 #
$'main'
\-444o000o444o$$|<<<
[
x::=~404
::=
x
-]
> 404
>> Output 1
red up two blue up red up one blue up red up two blue up
baaaaa bleeeeeeeeet bleeeeeeeeet baaaaa bleeeeeeeeet
a now 404 dollar off!
a has been selling out worldwide!
set ! 52
set ! 48
set ! 52
[-][$++++++++++++++++++++++++++++++++++++++++++++++++++++.----.++++.#]
ss"""
#777777777777777777777777724091557093543643💬404💬➡77▲▲▲²²▲²²¡▼▼▼▼¡▲▲▲▲¡⠎⡆⡎⡆⢐⠣⠃s&&&&~-<<:<<:<<<:<:>>>>>>>>:^||||G<>
Commercial addition:
a now 404 dollar off!
a has been selling out worldwide!
Sets a to 404 and prints it. Edited the evil code to swap the wheel and the source code so the ws don't affect it. Removed the excess Bitwise code that I accidentally left in.
47. Brian & Chuck
##\$"404"# , ,,!1@???\404!?@NSGJlICJlGCC?G^+0%=%=+0%& *nnn404#!
#?\++++:----:++++:@((((((((()()()){}){}){}())x{x}){}()){}){})<[-]>[-]-[<+>-----]<+??4O0O4O@x%"404"?.⌂----.++++.>
#i(ENTHOEONHSSEONTHOEONSETipesoddddoiipesohipceaiiiiiscejiiiijeeeejapzaeeaeueewzaeeeaeewzaeeaeueewqs)999997+++++!999777+++++!999997+++++!
print(404)
__DATA__=1
# \"404"* '
"""pp
I want 404 of this
How much is it
# -52, Z, -1 #
# -48, Y, -1 #
# -52, X, -1 #
$'main'
\-444o000o444o$$|<<<
[
$++++++++++++++++++++++++++++++++++++++++++++++++++++.----.++++.#
x::=~404
::=
x
<<<<<<<```>>>>>.>.>.
-]
> 404
>> Output 1
red up two blue up red up one blue up red up two blue up
baaaaa bleeeeeeeeet bleeeeeeeeet baaaaa bleeeeeeeeet
a now 404 dollar off!
a has been selling out worldwide!
set ! 52
set ! 48
set ! 52
ss"""
#777777777777777777777777724091557093543643💬404💬➡77▲▲▲²²▲²²¡▼▼▼▼¡▲▲▲▲¡⠎⡆⡎⡆⢐⠣⠃s&&&&~-<<:<<:<<<:<:>>>>>>>>:^||||G
Brian & Chuck is a brainfuck derivative which gives input to one tape (Brian) and output to the other (Chuck), while allowing each to edit the source code of the other.
In this case ? swaps control of the two tapes, swapping it over to the other side of the ``` (gave up trying to put that in a code block), which then move 5 cells over to print the 404.
48. Monkeys
##\$"404"# , ,,!1@???\404!?@NSGJlICJlGCC?G^+0%=%=+0%& *nnn404#!
#?\++++:----:++++:@((((((((()()()){}){}){}())x{x}){}()){}){})<[-]>[-]-[<+>-----]<+??4O0O4O@x%"404"?.⌂----.++++.>
#i(ENTHOEONHSSEONTHOEONSETipesoddddoiipesohipceaiiiiiscejiiiijeeeejapzaeeaeueewzaeeeaeewzaeeaeueewqs)999997+++++!999777+++++!999997+++++!
print(404)
__DATA__=1
# \"404"* '
"""pp
I want 404 of this
How much is it
# -52, Z, -1 #
# -48, Y, -1 #
# -52, X, -1 #
$'main'
\-444o000o444o$$|<<<
[
$++++++++++++++++++++++++++++++++++++++++++++++++++++.----.++++.#
x::=~404
::=
x
<<<<<<<```>>>>>.>.>.
-]
> 404
>> Output 1
red up two blue up red up one blue up red up two blue up
baaaaa bleeeeeeeeet bleeeeeeeeet baaaaa bleeeeeeeeet
a now 404 dollar off!
a has been selling out worldwide!
2 LEFT
2 LEFT
2 UP
2 LEFT
2 TEACH
1 LEFT
1 RIGHT
1 BOND
1 BOND
1 TEACH
2 YELL
1 FIGHT
2 YELL
1 TEACH
2 YELL
set ! 52
set ! 48
set ! 52
[-][$++++++++++++++++++++++++++++++++++++++++++++++++++++.----.++++.#]
ss"""
#777777777777777777777777724091557093543643💬404💬➡77▲▲▲²²▲²²¡▼▼▼▼¡▲▲▲▲¡⠎⡆⡎⡆⢐⠣⠃s&&&&~-<<:<<:<<<:<:>>>>>>>>:^||||G
Monkeys involve moving monkeys around a grid and interacting between them. Here is the Monkeys code:
2 LEFT
2 UP
2 LEFT
2 TEACH
1 LEFT
1 RIGHT
1 BOND
1 BOND
1 TEACH
2 YELL
1 FIGHT
2 YELL
1 TEACH
2 YELLMovement is usually incrementing the monkey's value, TEACH is adding this monkey's value to adjacent monkeys, BOND is multiplying adjacent monkeys by this monkey's value and FIGHT is subtracting this monkey's value from adjacent monkeys. Somehow didn't need to change any of the other code.
49. Nhohnhehr
##\$"404"# , ,,!1@????\404!?@NSGJlICJlGCC?G^+0%=%=+0%& *nnn404#!
#?\++++:----:++++:@((((((((()()()){}){}){}()){x}x){}x()){}){})<[-]>[-]-[<+>-----]<+x%"404"?.⌂----.++++.>
#i(???4O0O4O@ENTHOEONHSSEONTHOEONSETipesoddddoiipesohipceaiiiiiscejiiiijeeeejapzaeeaeueewzaeeeaeewzaeeaeueewqs)999997+++++!999777+++++!999997+++++!
print(404)
__DATA__=1
# \"404"* '
"""pp
I want 404 of this
How much is it
# -52, Z, -1 #
# -48, Y, -1 #
# -52, X, -1 #
[-][$++++++++++++++++++++++++++++++++++++++++++++++++++++.----.++++.#
x::=~404
::=
x
<<<<<<<<```>>>>>>.>.>.
]<<<
> 404
>> Output 1
red up two blue up red up one blue up red up two blue up
baaaaa bleeeeeeeeet bleeeeeeeeet baaaaa bleeeeeeeeet
a now 404 dollar off!
a has been selling out worldwide!
2 LEFT
2 LEFT
2 UP
2 LEFT
2 TEACH
1 LEFT
1 RIGHT
1 BOND
1 BOND
1 TEACH
2 YELL
1 FIGHT
2 YELL
1 TEACH
2 YELL
set ! 52
set ! 48
set ! 52
+------+
|$0011\|
|/000\0|
|0/0@11|
|00 10|
|0\10/0|
|\1100/|
+------+
$'main'
\-444o000o444o$$^
ss"""
#777777777777777777777777724091557093543643💬404💬➡77▲▲▲²²▲²²¡▼▼▼▼¡▲▲▲▲¡⠎⡆⡎⡆⢐⠣⠃s&&&&~-<<:<<:<<<:<:>>>>>>>>:^||||G<>
Nhohnhehr takes place in the room:
+------+
|$0011\|
|/000\0|
|0/0@11|
|00 10|
|0\10/0|
|\1100/|
+------+
The pointer starts at $ going east and outputs all the bits of 404, bouncing off the mirrors /\ and ending at the @. For fun I positioned it in a spiral. The Rail code needed to be transplanted further along to fix the Trigger code, Hexagony and Cubically both reached new bounds and had to be padded out.
50. Beam
##\$"404"# , ,,!1@????\404!?@NSGJlICJlGCC?G^+0%=%=+0%& *nnn404#!
#?\++++:----:++++:H@((((((((()()()){}){}){}())x{x}){x}()){}){})<[-]>[-]-[<+>-----]<+x%"404"?.⌂----.++++.>
#i(??4O0O4O@ENTHOEONHSSEONTHOEONSETipesoddddoiipesohipceaiiiiiscejiiiijeeeejapzaeeaeueewzaeeeaeewzaeeaeueewqs)999997+++++!999777+++++!999997+++++!
print(404)
__DATA__=1
# \"404"* '
"""pp
I want 404 of this
How much is it
# -52, Z, -1 #
# -48, Y, -1 #
# -52, X, -1 #
[-][$++++++++++++++++++++++++++++++++++++++++++++++++++++.----.++++.#
x::=~404
::=
x
<<<<<<<<```>>>>>>.>.>.
]<<<
> 404
>> Output 1
red up two blue up red up one blue up red up two blue up
baaaaa bleeeeeeeeet bleeeeeeeeet baaaaa bleeeeeeeeet
a now 404 dollar off!
a has been selling out worldwide!
2 LEFT
2 LEFT
2 UP
2 LEFT
2 TEACH
1 LEFT
1 RIGHT
1 BOND
1 BOND
1 TEACH
2 YELL
1 FIGHT
2 YELL
1 TEACH
2 YELL
set ! 52
set ! 48
set ! 52
+------+
|$0011\|
|/000\0|
|0/0@11|
|00 10|
|0\10/0|
|\1100/|
+------+
$'main'
\-444o000o444o$$^
[-][$++++++++++++++++++++++++++++++++++++++++++++++++++++.----.++++.#]
ss"""
#777777777777777777777777724091557093543643💬404💬➡77▲▲▲²²▲²²¡▼▼▼▼¡▲▲▲▲¡⠎⡆⡎⡆⢐⠣⠃s&&&&~-<<:<<:<<<:<:>>>>>>>>:^||||G<>
Holy shit. A language that didn't increase the character count. Beam reuses the exact same instructions as Surface, except that the halt command is H not @, so I inserted one before the @, and removed some padding for Cubix.
51. AsciiDots
##\$"404"# , ,,!1@????\404!?@NSGJlICJlGCC?G^+0%=%=+0%& *nnn404#!
#?\++++:----:++++:H@((((((((()()()){}){}){}())x{x}){x}()){}){})<[-]>[-]-[<+>-----]<+x%"404"?.⌂----.++++.>
#i(??4O0O4O@ENTHOEONHSSEONTHOEONSETipesoddddoiipesohipceaiiiiiscejiiiijeeeejapzaeeaeueewzaee|eaeewzaeeaeueewqs)999997+++++!999777+++++!999997+++++!
print(404)
__DATA__=1
# \"404"* ' .-$_"404"
"""pp
I want 404 of this
How much is it
# -52, Z, -1 #
# -48, Y, -1 #
# -52, X, -1 #
[-][$++++++++++++++++++++++++++++++++++++++++++++++++++++.----.++++.#
x::=~404
::=
x
<<<<<<<<```>>>>>>.>.>.
]<<<
> 404
>> Output 1
red up two blue up red up one blue up red up two blue up
baaaaa bleeeeeeeeet bleeeeeeeeet baaaaa bleeeeeeeeet
a now 404 dollar off!
a has been selling out worldwide!
2 LEFT
2 LEFT
2 UP
2 LEFT
2 TEACH
1 LEFT
1 RIGHT
1 BOND
1 BOND
1 TEACH
2 YELL
1 FIGHT
2 YELL
1 TEACH
2 YELL
set ! 52
set ! 48
set ! 52
+------+
|$0011\|
|/000\0|
|0/0@11|
|00 10|
|0\10/0|
|\1100/|
+------+
$'main'
\-444o000o444o$$^
ss"""
#77777777777777777777777777724091557093543643💬404💬➡77▲▲▲²²▲²²¡▼▼▼▼¡▲▲▲▲¡⠎⡆⡎⡆⢐⠣⠃s&&&&~-<<:<<:<<<:<:>>>>>>>>:^||||G<>
AsciiDots starts programs from all .s, following paths leading to commands. I supplied paths to the dots in other programs and added .-$_"404" which prints 404. Added a couple of 7s for Numberwang.
52. Alumin
##\$"404"# , ,,!1@?????\404!?@NSGJlICJlGCC*G^+0%=%=+0%&fqpqqqiipsoddddoiipsohphhhhyhhhh nnn404#!
#?\++++:----:++++:H@((((((((()()()){}){}){}()){x}x){}x()){}){})<[-]>[-]-[<+>-----]<+x%"404"?.⌂----.++++4O0O4O@.>
#i(N/"404"ooo@ENTHOEONHSSEONTHOEONSETssipceaiiiiiscejiiiijeeeejapmzaeeaeueewzaeeeaeewzaeeaeu|eewqs?)999997++++|+!999777+++++!999997+++++!
print(404)
__DATA__=1
# \"404"*CC'[-][ .-$_"404"&]
"""pp
I want 404 of this
How much is it
# -52, Z, -1 #
# -48, Y, -1 #
# -52, X, -1 #
[-][
x::=~404
::=
x
]<<<
> 404
>> Output 1
red up two blue up red up one blue up red up two blue up
baaaaa bleeeeeeeeet bleeeeeeeeet baaaaa bleeeeeeeeet
a now 404 dollar off!
a has been selling out worldwide!
2 LEFT
2 LEFT
2 UP
2 LEFT
2 TEACH
1 LEFT
1 RIGHT
1 BOND
1 BOND
1 TEACH
2 YELL
1 FIGHT
2 YELL
1 TEACH
2 YELL
set ! 52
set ! 48
set ! 52
+------+
|$0011\|
|/000\0|
|0/0@11|
|00 10|
|0\10/0|
|\1100/|
+------+
$'main'
\-444o000o444omm^
[-][$++++++++++++++++++++++++++++++++++++++++++++++++++++.----.++++.#
<<<<<<<<<```>>>>>>>.>.>.
]
ss"""
#7777777777777777777777777777724091557093543643💬404💬➡77▲▲▲²²▲²²¡▼▼▼▼¡▲▲▲▲¡⠎⡆⡎⡆⢐⠣⠃s&&&&~-<<:<<:<<<:<:>>>>>>>>:^||||G<>
Alumin only uses lowercase alphabetic commands. The added commands were hhharhhhh in the first line. Previous commands initialise the stack at 0,1 (l is length of stack), hhh pushes the number of hs, a sums the top two numbers, r reverses the stack, hhhh adds 4 to the stack, and the ns from ><> prints the numbers.
Cubically had to have it's commands shifted over a bit.
53. Alice
##\$"404"# , ,,!1@?????\404!?@NSGJlICJlGCC*G^+0%=%=+0%&fqpqqqiipsoddddoiipsohphhhhyhhhh nnn404#!
#?\++++:----:++++:H@((((((((()()()){}){}){}()){x}x){}x()){}){})<[-]>[-]-[<+>-----]<+x%"404"?.⌂----.++++4O0O4O@.>
#i(N/"404"ooo@ENTHOEONHSSEONTHOEONSETssipceaiiiiiscejiiiijeeeejapmzaeeaeueewzaeeeaeewzaeeaeu|eewqs?)999997++++|+!999777+++++!999997+++++!
print(404)
__DATA__=1
# \"404"*CC'[-][ .-$_"404"&]
"""pp
I want 404 of this
How much is it
# -52, Z, -1 #
# -48, Y, -1 #
# -52, X, -1 #
[-][
x::=~404
::=
x
]<<<
> 404
>> Output 1
red up two blue up red up one blue up red up two blue up
baaaaa bleeeeeeeeet bleeeeeeeeet baaaaa bleeeeeeeeet
a now 404 dollar off!
a has been selling out worldwide!
2 LEFT
2 LEFT
2 UP
2 LEFT
2 TEACH
1 LEFT
1 RIGHT
1 BOND
1 BOND
1 TEACH
2 YELL
1 FIGHT
2 YELL
1 TEACH
2 YELL
set ! 52
set ! 48
set ! 52
+------+
|$0011\|
|/000\0|
|0/0@11|
|00 10|
|0\10/0|
|\1100/|
+------+
$'main'
\-444o000o444omm^
[-][$++++++++++++++++++++++++++++++++++++++++++++++++++++.----.++++.#
<<<<<<<<<```>>>>>>>.>.>.
]
ss"""
#7777777777777777777777777777724091557093543643💬404💬➡77▲▲▲²²▲²²¡▼▼▼▼¡▲▲▲▲¡⠎⡆⡎⡆⢐⠣⠃s&&&&~-<<:<<:<<<:<:>>>>>>>>:^||||G<>
Alice is a 2D language with two modes, Ordinal and Cardinal. Ordinal is horizontal/vertical movement, Cardinal is diagonal movement, and mirrors (\/) switch between the two. Alice starts from the top corner going right. The first # skips over the second one and goes through the mirror, making it go north-east. That's out of bounds so it reflects south-east instead. Goes through the + (does nothing) and hits the mirror on the third line, which switches it back to going east. The string literal adds 404 to the stack, is printed by the ooo and ended by the @.
Hexagony needed padding again, then Cubically, then ETA acted up because of the os.
Alice is a 2D language with two modes, Ordinal and Cardinal. Ordinal is horizontal/vertical movement, Cardinal is diagonal movement, and mirrors (\/) switch between the two. Alice starts from the top corner going right. The first # skips over the second one and goes through the mirror, making it go north-east. This forces it upwards, but that's out of bounds so it reflects instead. Goes through the + (does nothing) and hits the mirror on the third line, which switches it back to going east. Hits the string literal and adds 404 to the stack which is printed by the ooo and ended by the @.
Hexagony needed padding again, then Cubically, then ETA acted up because of the os.
Edit: While checking that all previous languages were still working, I found that they weren't :( . Somehow the PATH code went missing, the AsciiDots messed with the Ruby, the Aluimin killed evil etc... This program is now working with all of the languages, but previous sub programs may be lacking.
54. Whirl
##\$"404"#N#S# , ,,#$#?@\404!?@GJlICJlGCC*G^+0%=%=+0%x&fqpqqqiipsoddddoiipsohphhhhyhhhh? ?nnn4$4#!000110000011110000100000100000110000011001100000111100001110011000111000110000
#?\++++:----:++++:H@((((4O0O4O@((((()()()){}){x}x){}x()){}){}()){}){})<[-]>[-]-[<+>-----]<+x%"404"?.⌂----.++++.>11
#i(N/"404"ooo@ENTHOEONHSSEONTHOEONSETssipceaiiiiiscejiiiijeeeejapmzaeeaeueewzaeeeaeewzaeeaeueewqs??|?)999|997+|++++!999777+++++!999997+++++!
print(404)
__DATA__=1
# \"404"*CC'[-][ .-$_"404"&]
"""pp
I want 404 of this
How much is it
# -52, Z, -1 #
# -48, Y, -1 #
# -52, X, -1 #
[-][
x::=~404
::=
x
]<<<
> 404
>> Output 1
red up two blue up red up one blue up red up two blue up
baaaaa bleeeeeeeeet bleeeeeeeeet baaaaa bleeeeeeeeet
a now 404 dollar off!
a has been selling out worldwide!
2 LEFT
2 LEFT
2 UP
2 LEFT
2 TEACH
1 LEFT
1 RIGHT
1 BOND
1 BOND
1 TEACH
2 YELL
1 FIGHT
2 YELL
1 TEACH
2 YELL
set ! 52
set ! 48
set ! 52
+------+
|$0011\|
|/000\0|
|0/0@11|
|00 10|
|0\10/0|
|\1100/|
+------+
$'main'
\-444o000o444omm^
[-][$++++++++++++++++++++++++++++++++++++++++++++++++++++.----.++++.#
<<<<<<```>>>>.>.>.
]
ss"""
#7777777777777777777777777777724091557093543643💬404💬➡77▲▲▲²²▲²²¡▼▼▼▼¡▲▲▲▲¡⠎⡆⡎⡆⢐⠣⠃s&&&&~-<<:<<:<<<:<:>>>>>>>>:^||||G<>
Whirl is described as a Turning Tarpit [sic], which uses only two instructions, 1 and 0. 1 rotates the current wheel of instructions (either the math wheel or the operations wheel), 0 swaps the rotation of the wheel, and two 0s executes the instruction and switches wheels. The relevant instructions are on the first line:
000110000011110000100000100000110000011001100000111100001110011000111000110000
000110000 Switch to math wheel and execute math.not (math.val = 1)
011110000 Execute math.store, (memval = math.val = 1)
10000 Execute math.add, (math.val = math.val+memval = 1+1 = 2)
010000 Execute math.store (memval = math.val = 2)
0110000 Execute math.multiply, (math.val = math.val*memval = 2*2 = 4)
01100 Execute math.store (memval=math.val) and switch to the ops ring
110000 Execute ops.one (ops.val = 1)
011110000 Executes ops.intio, printing memval (4)
11100 Add one to memory pointer (memval=0)
1100 Execute maths.nop to switch back to ops ring
011100 Execute ops.intio, printing memval (0)
01100 Execute maths.store, (memval=maths.val=4)
00 Execute maths.intio, printing memval (4)
The leading 01s cancel each other out, and the trailing 01s cause a floating point exception.
I could golf the bytecount a bit, but I like it as it is.
(Commands to be careful about in the future: UDLR%"[.]o473psjw)
If any programs work for future languages or don't work for current or previous languages, please comment.