nyuuzyou/wikis huggingface dataset:
The Language That Explodes

The Language That Explodes, created by User:ais523 in 2021, is intended to create interesting conceptual problems about computability classes, whilst being entirely useless in practice. It is Turing-complete in the sense that for every program with input and output in any Turing-complete language, there is some corresponding program in The Language That Explodes that maps the same inputs to the same outputs; however, it is usually uncomputable to determine what that program is (in fact, the language has decidable haltability).
One way to think about it is that the language itself is computable, but the language uses an uncomputable encoding.
== Definition ==
A program in The Language That Explodes consists of a string of 1s, followed by a string of 2s.
* The string of 1s is a Unary program.
* The length of the string of 2s must be a solution to the Busy Beaver problem for Unary; specifically, its length must be equal to the maximum number of brainfuck commands that run during the execution of any halting Unary program that's no longer than the string of 1s.
If the string of 2s has the correct length, then the The Language That Explodes program behaves the same way as the Unary program that is formed by the string of 1s.
If the string of 2s has an incorrect length, this is undefined behaviour.
== Computational class ==
Being able to compile arbitrary Unary programs into The Language That Explodes requires solving the halting problem for Unary, which is impossible. The compilation does conceptually exist, but there is no way to find it. Despite the uncomputable nature of writing a program in The Language That Explodes (with the exception of a few simple programs), executing a program is trivially easy, thanks to the undefined behaviour if the string of 2s is incorrect – you can just ignore it and write a Unary interpreter.
The halting problem for The Language That Explodes is trivially easy to solve – simply run the Unary program for a number of brainfuck commands equal to the given number of 2s. If it doesn't halt in that time, it can't halt at all.
A side effect of all this (and the fact that inspired the language) is that The Language That Explodes has a Busy Beaver function that grows (slightly) sub-linearly.
Category: Joke languagesCategory:2021Category:Unusable for programmingCategory:Unimplemented
Category: Languages
The Past

The Past is a time-traveling esolang by User:PythonshellDebugwindow.
==Memory model==
The Past uses an arbitrary-size signed integer accumulator.
==Output==
The final value of the accumulator is output (if the program goes into an infinite loop, then nothing will be output).
==Commands==
Command	Effect
+ 	Increment the accumulator
- 	Decrement the accumulator
. 	Wait a tenth of a second
< 	Go back one millisecond in the past
==Implementation==
Written in Python 3. A filename is read as a command line argument. Note that this implementation is somewhat slow and can take some time to start the program. If it is interrupted before the program starts, incorrect output may be produced.
 import sys
 import time
 
 with open(sys.argv[1]) as f: code = f.read()
 dt = 0.1*code.count('.') - 0.001*code.count('<')
 acc = code.count('+') - code.count('-')
 if dt >= 0:
 print('Starting program...')
 time.sleep(dt)
 print(f'Accumulator: {acc}')
 else:
 print(f'Accumulator: {acc}')
 time.sleep(-dt)
 print('Starting program...')
Category:Languages
Category:2020
Category:Unusable for programming
Category:Reversible computing
Category:Total
Category:Output only
Category:Implemented
The Sophomores From Tbilsi

The Sophomores From Tbilsi is an esolang created by User:yayimhere to do two things:
* complete the trilogy of “the _ from _”.
* look like The Genius from Kiev and have triggers like The Amnesiac From Minsk but be different in every other way
the The Sophomores From Tbilsi has only one level unlike the other esolangs mentioned. The nutjob from wellington takes inspiration from MEMORYLEEK and teleport
== semantics and syntax ==
a The Sophomores From Tbilsi program must be a triangle. the top layer can have any length. the amount each row increases in length must be a fixed amount. right next to the triangle is 3 rows. the amount of columns on each one is the height of the triangle. each row is 1 char long and can hold one of 5 things: a number(base 61), , a number in the index format(see below), , or . each of the rows must be seperated such that they dont touch each other at all. in each triangle collumn there is an expression. it is evaluated like in MEMORYLEEK. the symbols in an expression is:
+-*/()≠(return 1 if the left value is not equal to right else 0)=(same as ≠ but reversed)
n(a base 19 number)_(negate the following number)
an expression is always done left to right. there is an infinite amount of counters which are unbounded negative floats. each counter is represented by an index (1 indexed) which has this format:
j is 1 and z is 17 and the letters between become the values between. if there is a # then it will be the n'th counter where n is the j-z value plus whats in the following counter
two letters next to each other are added together. so jj is 2 and zj is 18. 20 would be zm
these registers start at -∞. when an expression has been evaluated on one collumn then the counters in the next row is set to that data. so if the data was [-1,-8] and the counters in the expression where j and k(in that order) then ji would be -1 and k would be -8. there is 3 different triggers which each runs the respective row (with the collumn matching the one of the just evaluated expression). if trigger 1 or 2 is ran the expression will be undone and the counters affected will be set to -1:
* if the expression results in the counters of the next collumn being set to something higher than 0
* if the expression results in the counters of the next collumn being set to 0 specifically
* -∞ was used in the expression
now to what different symbols in the rows:
* a number n in base 61: run the n'th row of the triangle
* : halt
* a number n in index format: run n'th collumn of current trigger
* : multiply every value of the data generated by -1 and run the collumn that would've been ran
* : go to next trigger row on current collumn(wraps around)
a is always a NOP and will in a row just return to the next collumn
== infinite loop ==
 1 1 @ @
 j@ @ @ @
or longer:
 _1 @ @ @
 j*_1 1 @ @
 j@@@@@ @ @ @
Category:Languages Category:2024 Category:Unknown computational class Category:Unimplemented
The Temporary Stack

The Temporary Stack is a stack-based esoteric programming language created by User:PythonshellDebugwindow.
==Instructions==
Instructions are separated by spaces.
Instruction	Meaning
@ 	Pushes to the stack the ASCII value of the each character of user input.
v 	Pushes to the stack the base-10 integer value of the number following this v (no space between this v and that number)
* 	Pushes to the stack the ASCII value of each character following this * (no space between this * and those character(s), and spaces can't be used - use v instead)
O 	Switches the output mode from ASCII value to base-10 integer value (the default)
o 	Inverse of O
+ 	Duplicates the top of the stack; the duplicate is added to the stack
: 	Repeats the next instruction until a value is either pushed to or removed from the stack (the next instruction still only counts as one command - see the bottom of the next section)
\ 	Repeats the next instruction until the stack is empty (the next instruction still only counts as one command - see the bottom of the next section)
€ 	Performs a random action (other than comment)
# 	Comment until space, which is command/comment separator (this comment counts as a command)
The v and * commands are just different ways of achieving the same result, but only v can be used to push spaces.
All other characters are treated as comments; however, if they are alone in a word, they still count toward the command count (e.g., the word unexecuted counts as a command). Note that such characters can appear within commands; for example, O, Others, and cOOde are equivalent, and v123 and hv1no2th3ing would both push the number 123.
==The stack==
The Temporary Stack has one way to store values (which must be integers): the stack. Each value has a "weight", which is just its value. Infinite values can be stored, but there is a catch: if the sum of all values' weights on the stack except for that of the bottom one, divided by two, is greater than the weight of the bottom value, then the bottom one gets "squished" and either the ASCII character of its value minus one, or just its value minus one, is output, depending on the output mode, which defaults to base-10 value and can be switched with "O" and "o". For example,
 v1 v3
would output 0, and so would
 v1 v1 v1 v1
because in both examples, the combined weights of all values in the stack except for the bottom one was 3, and that of the bottom value was 1, and since 3 divided by 2 is 1.5, which is greater than 1, the bottom value in the stack (1) was decremented by 1, removed from the stack, and output as a base-10 integer.
And as if that isn't hard enough, every fifteen commands, including comments, the stack is reset, hence the name "The Temporary Stack".
==Examples==
===Hello, world!===
 o *Ifmmp-!xpsme" v11 v2297
===Drunken cat===
 o @ \ @
==Implementations==
* A Python interpreter by User:Bangyen.
* An interpreter on Github written in C++
Category:Languages Category:Stack-based Category:2019 Category:Implemented
The best esolang ever

The best esolang ever is an esolang written by User:Heav in 2022.
==Implementation details==
A compliant The best esolang ever interpreter should only interpret programs in the best way. If an interpreter decides to interpret programs in a way that would not be the best, then it is not compliant.
==Examples==
q8z91¹
This code will output the best possible output for this code, taking everything into consideration.
Category:Joke languages
Category:Unimplemented
Category:2022
The bluetooth device is ready to pair

:
The bluetooth device is ready to pair or TBDIRP is an esolang based off of something User:Infinitehexagon saw on YouTube about a bluetooth speaker with an accent. 
Category:2024Category:LanguagesCategory:PseudonaturalCategory:UnimplementedCategory:Joke languages
== Variables / Syntax ==
All programs start off with this;
Power on.
and all programs end with this.
Power off.
If there is no power off, the program will still be ran, but an error will be returned.
Variables are created by starting off with a random capital letter {[A-Z]}followed by an e and the text bluetooth device is ready to pair. here is an example of an variable. In this case, the letter I used was "D".
De bluetooth device is ready to pair.
There is a special variable with the characters "Ch". This variable takes string input when called. The CH variable can also contain a value that is NOT input. To give a value to a variable, start with bluetooth device is followed by a string of text or a number.
Che bluetooth device is 72.
=== Operations ===
To use operations in a variable, you use the keyword "Che bluetooth device is" followed by the operation +, -, x, /, or %.
De bluetooth device is 3 * 7.
== Instructions ==
Instruction 	Description 	Equivalence
{variable} bluetooth device is connected successfully.	Output the string of the given variable. 	print(variable)
Play music. 	Initiate a loop. 	while x do[
Stop music. 	Close a loop and go to the last "Play music" if the current variable is a non-zero value.	]
{variable} ++ olume up. 	Increment the given variable by 1. 	x+1
{Variable} ++ olume down. 	Decrement the given variable by 1. 	x-1
== Example Programs / Programs ==
=== Cat program ===
 Power on.
 Che bluetooth device is ready to pair.
 Che bluetooth device is connected successfully.
 Power off.
=== Hello world program(string) ===
 Power on.
 He bluetooth device is ready to pair.
 He bluetooth device is "Hello, World!".
 He bluetooth device is connected successfully.
 Power off.
=== Truth machine ===
 Power on. 
 De bluetooth device is ready to pair.
 Play music.
 De bluetooth device is connected successfully.
 Stop music.
 Power off.
=== Count up to 100 ===
 Power on.
 Ae bluetooth device is ready to pair.
 Ae bluetooth device is 0.
 Be bluetooth device is ready to pair.
 Be bluetooth device is 100.
 Play music
 Aolume up.
 Bolume down.
 Ae bluetooth device is connected successfully.
 Stop music
 Power off.
The chan-esoteric stack

The #esoteric stack is a software solutions stack based on the Principals of Eso. It is a ridiculously large stack, with too many things that nobody should ever use.
== The Stack ==
Feel free to add whatever because WTFN. In no particular order, the #esoteric stack currently consists of:
* Any non-esoteric (or really useful but esoteric) language (used to implement the rest of the stack). (preferably Python, unless Forth is an option)
* EsoDB
* An IRC bot
* Pile.js
* User:zzo38's Z-Machine implementation
* A language consisting of nothing but an extended variant on call/cc
* Any suitable CHIP-8 interpreter (preferably esoteric)
* any instruction that can or will jump in code in any esolang from before 2024
Category:Implementations
The kids choice awards

The kids choice awards is a program that prints "slime" over and over without terminating. This tests:
* printing
* looping
* ability for lack of termination
* ascii/tanstore/something else entirely
* a good sense of humor
* slimeslimeslimeslimeslimeslimeslimeslimeslimeslimeslimeslimeslimeslimeslimeslimeslimeslimeslime
Category:Program forms
== dolfins grace ==
 @
 >S"slime"^^^^^S
== my-new-esolang.txt ==
 (Ptmjnf)
== JS ==
 while (true) {
 console.log("slime");
 }
== Outinp ==
 outslimejmp00000
The maniacs in Montana

The maniacs in Montana is not just your weakling esoteric programming language... No, for it is several layers deep!
==Layers==
===Layer 1===
Montana banned TikTok, you know.
 protest()
This command prints what is in it, and prints "BRING BACK TIKTOK" if it is empty.
Montana stole the city name "Rocky boy" for a reserve.
 BURN DOWN THE FOREST!!!
Asks for an input and saves to the cell the pointer is on.
Wouldn't it be better to move out of Montana?
 canada
This increments the cell at pointer.
 wyoming
This decrements the cell at pointer.
 idaho
This moves the pointer left.
 the dakotas
This moves the pointer right.
Montana is too cold.
 LIGHT THE CITIES ON FIRE!!!!!!!!!!!!!!
This outputs the cell at pointer as ASCII.
===Layer 2===
You really think Montana can get away with banning Tiktok?
 use tiktok[]
The square brackets work like BF's square brackets.
Montana banned unpasturized milk.
 not all that bad
This command is a nop. Montana banning that kind of milk is not all that bad.
But on the flip side, banning TikTok is all that bad.
 LIGHT THE ENTIRE STATE ON FIRE!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
This ends the program because there is no more state to complain about.
===Layer 3===
This is very deep. You can drown.
 scuba
This should be before you use any commands below this.
Montana government is... just very, VERY stupidThe new rules in Montana will have more far-reaching effects.
 EAT THE GOVERNMENT!!!!!!!!!!!!!!!!!!!!!!!!!!!!
This will unban TikTok, thus the commands protest() and LIGHT THE ENTIRE STATE ON FIRE!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! will not work anymore.
===Layer 4===
We have reached the core of the earth. Only here are the most pointless commands.
 SPIT FIRE AT MONTANA
This barely does anything.
 PUNCH THE CORE
This immediately ends the program.
 TAKE OFF THE SUIT
This also immediately ends the program.
 hehehe ima put mah pencil there
You lose your pencil. You cannot use idaho and the dakotas.
===Layer 5===
You have reached go-I mean dragon plushie.
 talk to the dragon plushie
This command immediately makes you, as a person, Plushie-complete.
==Examples==
===Hello World===
====Layer 1====
 protest("Hello, world!")
===Cat===
====Layer 1====
 BURN DOWN THE FOREST!!!
 LIGHT THE CITIES ON FIRE!!!!!!!!!!!!!!
====Layer 2====
 canada
 use tiktok[
 BURN DOWN THE FOREST!!!
 LIGHT THE CITIES ON FIRE!!!!!!!!!!!!!!
 ]
===Kiwiscript===
====Layer 1====
 protest("kiwi")
==Ref table==
Category:Languages
The mimic

The mimic is an esolang created by User:Sourceguy. it mimics the input
You can download the interpreter here: https://github.com/Aleksander-Sapieha/The-Mimic/releases/tag/1.0
== Hello world ==
Hello World
Output:
Hello World
==See also==
* Text
Category:Languages Category:Implemented Category:Total Category:Unusable for programming Category:Output only
The shift machine

the shift machine a form of imaginary machine invented by Yayimhere to translate into OSU(also known as (*U ). the shift machine runs in two diffrent modes (the "loop" mode and the normal mode) and uses a tape to store data. there are a few things this machine can do in the normal mode:
* increment current cell by 1
* go into the loop mode
* go to the next cell
* halt
* flip to block n(means run twice then second time go to block n)
the loop mode works like this:
# increment current cell by 1
# move to next cell
# decrement it by 1
# move to next cell
# if current cell is more than some constant go into the normal mode
# else repeat
* you can also do NOP
its unknown what computational class its in but if found translatable to USO it will be at least as powerfull as USO(i think). also its not translatable yet. Also technically there are as many variants if TSM as there are real numbers since it has a constant thatis not always the same. here is an example. the omega is the mode(which first gets mu which is normal, then lambda which is loop mode) and performs operations(each symbol explained):
1 \text{ } \omega \gets \mu \to (+ \gg + \updownarrow 2) \vdots 2 \text{ } \omega \gets \lambda \to ( \hbar ) \vdots3 \text{ } \omega\gets \mu\to (\gg \cdots +\gg +\updownarrow 1)
each block starts with their number then their mode(omega gets "mode")where mu is normal, and lambda is loop mode. then it uses the to statement which is the actual block. + is the increment, the arrows go to the next cell and the updown arrow will do the flip jump. the ... is just: do this command infinitely. this basically gets the pointer back to the first cell where it does the same block 1 and flips to block 2. also the hbar is the NOP of the loop mode
Category: Computational models
Theoretica

Theoretica is a theoretical language. No accurate-to-spec implementation of Theoretica can be produced on a physical machine, as an implementation would require not only infinite memory, but also infinite runtime.
== Description ==
The language is based around operating on sequences, and the language's functions can be split into 3 categories:
* Generators
* Operators
* Flow control
Input is implicit to a dedicated input stack, and the result of generators are stored in a second "infinite" stack.
=== Generators ===
Theoretica contains a generator builtin for any conceivable sequence of numbers, however those referenced by the spec are:
 i Generates an infinite collection of positive integers, starting at 0, in ascending order
 I Generates an infinite collection of negative integers, starting at 0, in descending order
 ! Generates an infinite collection of positive factorials, starting at 0!, in ascending order
 p Generates an infinite collection of primes, starting at 2, in ascending order
 ^# Generates an infinite collection of # exponents, starting at 1^#, in ascending order
 #^ Generates an infinite collection of exponents of #, starting at #^1, in ascending order
 m# Generates an infinite collection of positive multiples of #, starting at 1#, in ascending order
 f Generates an infinite Fibonacci sequence, starting at 0, in ascending order
 s"#" Generates an infinitely repeating collection of the ASCII values of #, uses input if # is not given
=== Operators ===
All Theoretica operators are designed to operate on an infinite collection generated by a generator.
 + Sum the collection
 R Sort the collection into a random order
 ;# Return the #th item of the collection
 _ Print
 @ Print as ASCII characters
 ? Print the result of the last conditional, as either "true" or "false"
 :# Concatenate the collection to the first # items
 l Get the length of the input
 ~#x Convert # to base x
=== Flow Control ===
Theoretica includes only basic flow control
 c If any item in the input stack is contained in the generator stack, run the next symbol
 C If no items in the input stack are contained in the generator stack, run the next symbol
 > Move to the start of the next line
 < Move to the start of the previous line
== Examples ==
=== cat ===
 _
 <
Infinite loop, keep printing.
=== Hello, World! ===
 s"Hello, World!":12@
Generate an infinitely repeating array of the ASCII values of "Hello, World!", concatenate it to the first 12 items, then print the resulting array
=== Square check ===
 ^2c>
 ?
Generate an infinite array of squares, check if the input is contained in that infinite array, if it is, run >, skipping to the start of the next line, which then prints the result of the last conditional. Otherwise, skip the >, and hit the end of the line, wrapping down to the start of the next line, which then prints the result of the last conditional.
Prints "true" if the input is a Square, and "false" otherwise.
=== Prime check ===
 pc>
 ?
Same as the square check, but with primes
=== Factorial check ===
 !c>
 ?
Same as the square check, but with factorials
Category:Languages Category:Uncomputable Category:Stack-based
There Once was a Fish Named Fred

There Once was a Fish Named Fred is a programming language similar to brainfuck, except there are seven commands, "there", "once", "was", "a", "fish", "named", and, finally, "Fred." This language was created by User:Star651 on December 23, 2011. There are spaces between the commands/words when programming. As you can see, there is no command that is like the , in BF.
Command	BF equivalent
there 	<
once 	>
was 	+
a 	-
fish 	.
named 	[
Fred 	]
== Hello world ==
 was was was was was was was was named once was was was was named once was was once was was was once was was was once was there there there there a Fred once was once was once a once once was named there Fred there a Fred once once fish once a a a fish was was was was was was was fish fish was was was fish once once fish there a fish there fish was was was fish a a a a a a fish a a a a a a a a fish once once was fish once was was fish
This is the example taken from brainfuck, converted into There Once was a Fish Named Fred.
== JavaScript Fred-to-brainfuck converter ==
 function fredToBrainfuck(code) {
 code = (code + " ").replace(/there /g, "<").replace(/once /g, ">").replace(/was /g, "+").replace(/a /g, "-").replace(/fish /g, ".").replace(/named /g, "[").replace(/Fred /g, "]");
 return code;
 }
Category:Languages
Category:2011
Category:Brainfuck equivalents
Category:Output only
Category:Turing complete
Theseus

Theseus is a reversible programming language that uses algebraic data types. 
== Links ==
* Fork by chessai of the Theseus implementation
* Original implementation by Roshan P. James and Amr Sabry of Indiana University
* Roshan P. James and Amr Sabry. Theseus: A High Level Language for Reversible Computing. Work-in-progress report in the Conference on Reversible Computation, 2014. PDF linked
Category:Languages
Category:2014
Category:Reversible computing
Category:Functional paradigm
Category:Turing complete
Category:Implemented