nyuuzyou/wikis huggingface dataset:
‍true

true is a FALSE-like language created by User:Ractangle
==Commands==
===Implemented===
* Literals
** pushes a string to the stack
** pushes a number to the stack
** discards the first input character and pushes it to the stack
** lambda
* I/O
** prints the popped element 
** gets input and stores it some where
* Stack manipulation
** duplicate the top value of the stack
** discard the top value on the stack
* Arithmetic
** add the two top intergers together
** negates the top value on the stak
* Subroutine control
** call a subroutine
** create a subroutine
** return to the main code
* Other
** comments
The pointer goes to the beginning of the program when it gets to the end of the program, but does not encounter a newline
====Newline/IndexError====
You can consider this as a command (yes they're the same) if you want to
All it does is just halt the program
===Unimplemented===
* conditional
==Examples==
===Hello, world!===
 "Hello, world!".
 
===Cat program===
 ,»rr:'.»r
===Infinite loop===
As long as you don't encounter an IndexError and have your code be on one line, it will loop
==Implementations==
* File in User:Ractangle's website repo
Category:Implemented Category:Languages Category:Stack-based
—-

—- is an esolang by User:PythonshellDebugwindow. It uses only two characters, — and -.
==Memory==
—- has four wrapping unsigned 8-bit cells, each of which start at 0. It also has a wrapping cell pointer that starts at 0 to keep track of the current cell.
==Commands==
Command	Meaning
— 	Increment the current cell by 3, then increment the cell pointer
- 	Decrement the cell pointer
—- 	(M dash then normal dash) If the current cell is greater than 0, jump to the current cellth character; otherwise print the cell pointer + 1th cell as an (extended) ASCII character without a newline, then decrement the cell pointer
==Computational class==
—- has finite memory, thus it can be simulated by a finite-state automaton. However, the opposite is not true; there must be an FSA that cannot be simulated by a —- program (because it contains more states that can be encoded in the —- program, since they can only jump up to and including the 256th character of the source code).
==NodeJS Interpreter==
The interpreter is available on GitHub.
Category:2020 Category:Languages Category:Implemented Category:Cell-based Category:Finite state automata
′

′ (pronounced "nothing prime") is an esoteric programming language made by User:Rehydratedmango designed to have as few symbols as possible. In ′, every function is a string of prime symbols.
== Functions ==
By default, there is only one function: ′. It returns the same thing it gets as input, unless there is no input, in which case it returns ′.
When a function is called by itself, any returned values will be output to the console. Defining a new function is done by writing the function name, followed by a list of functions delimited by whitespace. The inputs of the main function are passed to the constituent functions in order from left to right, filling as many inputs as possible. The outputs of these functions are concatenated to become the main function's output. So ′′ ′ ′ defines a function named ′′ that takes two inputs and passes them both to ′, before concatenating the results and returning them.
If a function inside a function definition returns nothing, the next function in the definition will be skipped. So if you call ′′ ′′′ ′, and ′′′ returns nothing, then the whole output of the function will equal nothing.
== Examples ==
This program calculates 10+10 (pretty much the only thing this language can do)
′′′′′′′′′′ ′ ′ ′ ′ ′ ′ ′ ′ ′ ′
 ′′′′′′′′′′ ′′′′′′′′′′
′′
This program enters an infinite loop and never outputs anything
 
'''
The program ′ outputs itself, making it a very small quine
Category:Languages
Category:Unimplemented
Category:Unknown computational class
Category:2023
›*&«&^

==Syntax==
›*&«&^ is a esolang created by User:Ractangle with only three commands which are
 >* Adds one and multiples by 2
 << decrements the value by two
and
 ^ outputs the ASCII character of the value
==See also==
* ›*&«&^Jj
* The implementation in Interpret Esolangs Online made by User:Ractangle
Category:LanguagesCategory:Unusable for programmingCategory:2024Category:ImplementedCategory:Total
›*&«&^Jj

›*&«&^Jj was a attempt at making ›*&«&^ turing complete by adding some commands:
 J
Take user input and store as value
 j
Create another value or register or whatever
 /
Move to the left value or register or whatev
 \
Move to the right register or whatev
 &&
Set current value to the value to the left subtracted from the value on the right
 […]
brainfuck loop
==Example==
===Cat Program===
A repeating cat program, terminating merely on a 'null character' input, shall be adduced:
 J[^J]
===Truth-Machine===
The following example represents a truth-machine implementation:
 j\J^/&&j\\>*>*>*>*>*<<<<<<<<<<<<<<[<</<<\]/[/^\]
==Interpreter==
* Common Lisp implementation of the ›*&«&^Jj programming language. Please note that the concrete character set deployed constitutes a dependency on the Common Lisp implementation; in corollary, Unicode support may or may not be a feature incorporated in the personal environment. The interpreter at hand has been developed and tested with Steel Bank Common Lisp (SBCL) version 1.1.4 as part of the Lisp Cabinet 0.3.5 bundle.
Category:Languages Category:2024 Category:Implemented
ℒight

ℒight is a language that only does one thing, eliminate the darkness. It has no inputs and infinite outputs.
The best way to understand ℒight is to see how it is implemented.
Here's some pseudocode on how one might make an interpreter.
while true:
 print "#"
Here's the start of the output of a ℒight program:
############################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################
==External resources==
* The Life-ending Limited List of ℒight Interpreters by User:AmNow
Category:Joke languages
Category:Unusable for programming
Category:Languages
Category:Total
Category:Output only
Category:Implemented
Category:Zero-dimensional
ℕDQ

ℕDQ, or NDQ, is an extension of DQ that can simulate a minsky machine. It is also created by User:yayimhere.
== memory ==
The memory is now stored in 2(!) stacks. These work like the registers.
== additions ==
These commands have been added:
 Additions
Symbol(s)	Meaning
$ 	Go to the other stack
[]n 	Do the code in the brackets if the stack is not empty and continue. Else jump to line n. Lines are indexed in a one-based manner.
U 	Halt
Counterdistinguished from DQ, the program is not randomly executed.
== turing-completeness proof ==
Here follows a translation from the Short Minsky Machine Notation to ℕDQ. It must use two registers and also when another register is needed for use the $ commands is used:
 ℘xy</code> <-> [Q]x
 ℘y <-> 1
 ℘ <-> U
== Examples ==
The following example serves the endeictic purpose of presenting the conditional execution and line jumping: The first stack is extending from three to five elements by adminiculum of the second stack, ere the penultimate line skips the desinent one, immediately terminating the program without further modifications.
 111$11
 [Q$1$]6
 [Q$1$]6
 [Q$1$]6
 1111111111
==Interpreter==
* Common Lisp implementation of the ℕDQ programming language. Please note that the concrete character set deployed constitutes a dependency on the Common Lisp implementation; in corollary, Unicode support may or may not be a feature incorporated in the personal environment. The interpreter at hand has been developed and tested with Steel Bank Common Lisp (SBCL) version 1.1.4 as part of the Lisp Cabinet 0.3.5 bundle.
Category:Languages Category:Stack-based Category:Implemented Category:Turing complete Category:Output only
Ↄ

Pronounced un-C
If your C program fails to compile, it becomes a valid ↄ program.
==Language overview==
ↄ is a language made up of all the programs that fail to compile as C programs. Depending on the line(s) of code that fails to compile as C, a different ↄ command is written. Most C programs have spent at least some time as ↄ programs in development. ↄ is one of the most widely used languages in the world, even if not even a single program has yet been written for it intentionally.
==Commands==
The ↄ interpreter looks at where the error(s) occur, mod three.
# We get a NOP (no operation).
# The behavior is undocumented, but depends on the content of the C program itself and how that content relates to that specific line of code. It will produce the same behavior for the same C program every time.
# A ↄ syntax error. It produces a ↄ program with errors. It will run but it might fail to do nothing. However, in its failure to do nothing, it will not report an error, interact with other systems, or perform any I/O operations. Unlike other ↄ programs, its behavior is not deterministic.
Since each of these run very quickly, and none interact with the system in any other way, they can be hard to tell apart. And any C compiler that simply reports a C compilation error may also secretly be a ↄ interpreter.
==External Resources==
* Language home page
Category:Languages
Category:2016
Category:Unusable for programming
Category:Implemented
Category:No IO
↑110010000100110110010

↑110010000100110110010 is an esolang by User:PythonshellDebugwindow.
==Memory==
↑110010000100110110010 uses data (initialized to an right-unbounded infinite tape of zeros), a data pointer (initialized to 0), a command pointer (initialized to nil), and a jump offset (initialized to 0), all of which are unbounded signed integers (or, in the data's case, a right-unbounded tape of them).
==Commands==
The command is on the left, and the value of the command pointer is on the top.
 	Nil 	0 	1 	2 	Anything else
↑	Increment the data pointer 	Increment the data pointed to by the data pointer 	Increment the jump offset 	Increment the command pointer 	Set the command pointer to 2
↓	Decrement the data pointer 	Decrement the data pointed to by the data pointer 	Decrement the jump offset 	Decrement the command pointer 	Input an integer to the data pointed to by the data pointer
0	Set the data pointer to 0 	Set the data pointed to by the data pointer to 0 	Set the jump offset to 0 	Set the command pointer to 0 	Jump backwards the number of times specified by the jump offset
1	Set the data pointer to 1 	Set the data pointed to by the data pointer to 1 	Set the jump offset to 1 	Set the command pointer to 1 	Jump forwards the number of times specified by the jump offset
↕	Set the command pointer to 0	Print the data pointer, then set the command pointer to 2 	Print the data pointed to by the data pointer	Print the jump offset, then double the jump offset	Print the command pointer
↨	Set the command pointer to 3	Skip the next command if the data pointed to by the data pointer is not 0	Set the command pointer to nil 	Skip the next command if the data pointer is not 0	Set the command pointer to nil
Programming in this language takes a lot of trial and error, and sometimes simple effects can take 3 commands. Due to the command pointer, and the sometimes not-so-obvious ways to change it as desired, you have to go through the whole program character-by-character to find out what any one character does.
==Undefined behaviour==
It's undefined behaviour when the data pointer goes negative, or when a jump goes out-of-bounds.
==Snippets==
To set the command pointer to 1 if it's at nil:
 ↨↑↓
==Examples==
===One-time cat program===
 ↨↓↑↓↕
===XKCD Random Number===
 ↑↑↑↑↕↕
==Computational class==
Unbounded data storage is available, so memory isn't an issue for Turing-completeness; the real problem is constructing a while loop (to effectively use the jump offset, garbage output must be produced (e.g., it's print then double), but this doesn't really matter), but if the command pointer can be effectively altered, which I suspect it can be, then there's no problem there, and the language is quite likely Turing-complete.
==External resources==
* An interpreter on GitHub
Category:Languages Category:2020 Category:Implemented Category:Unknown computational class Category:Usability unknown Category:Cell-based
↑→↓

↑→↓ pronounced up to down(can be shortened to UTD as ill be writing it on this page) is a esolang invented by User:Yayimhere thats a abstract machine where you create states of 3 different simulated computers who can send their states to each other. each computer runs in order from computer 1 to computer 3.
== overview ==
each computer has a label which is as follows:
 labels
label	computer
↑ 	computer 1
→ 	computer 2
↓ 	computer 3
each computer can hold one value which can all be set to something else in a state. all commands that do not set a computers state needs to be in a state
== syntax ==
the syntax of UTD
 syntax of UTD
instruction 	description 	pseudocode
@A[B] 	set computer A's state to state B 	A.state() = state.B()
@A/[B][C]/[D][E]	if computer A's state is B set its state to C and if its D set the state to E 	if A.state() == state.B() do A.state() = state.C() elif A.state() == state.D() do A.state() = E.state()
[A]: 	define state A as all the lines underneath this line until the last indented line in the block of indented lines	state.A = lines.below until last.type(indented) in(block.indented)
@A-@B(+)=@C 	add the value in computer A's value and computer B's value and store it into computer C 	C.val = B.val + A.val
@A=#B 	set computer A's value to the value B 	A.val = B
@A[B]! 	loop B as long as computer A's value is non 0 	while A.val != 0 do B
@A:- 	negate computer A's value 	A.val = A.val * -1
; 	print all the computer values as ascii chars 	print(chr(↑.val, →.val, ↓.val))
: 	print all the computer values as numbers 	print(↑.val, →.val, ↓.val)
,@A 	set computer A's value to user input(number) 	A.val = input()
@A[] 	represnts the state of computer A 	A.state
== examples ==
truth-machine:
 [truth-machine]:
 ,@↑@↑[:]!:
 @↑[truth-machine]
Category:Low-level
→

→ is a nondeterministic string-rewriting
esolang by User:Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff.
== Syntax and semantics ==
A → program is made up of one or more substitutions, which take the form
 pattern → replacement 
Note that -> can be used instead of →.
The only characters allowed in the patterns and replacements are alphanumeric characters, and dollar signs. All horizontal whitespace is ignored, while newlines are used to separate substitutions. Comments may be included, running from # to the end of the line.
== Code execution ==
A → program is run line by line replacing patterns with their corresponding replacements in the datastring. When a replacement occurs, the program jumps back to the first line. The program starts at the start. If no substitutions occur, the program ends. The datastring begins as a dollar sign, followed by a random combination of alphanumeric characters.
== Special rule forms ==
There are some exceptions to the syntax rules, allowing other characters to be included in the rules. The pattern may be .* (matches everything), or it may begin with ( (only matches front), and it can end with ), (only matches back). The replacement may include a . followed by a number, which outputs the character associated with that Unicode codepoint. It can also include a @, which halts the program when the replacement is matched
== Examples ==
=== Hello, World! ===
 a → .72 .101 .108 .108 .111 .44 .32 .87 .111 .114 .108 .100 .33 @ 
 .* → a
 # This program prints "Hello, World!"
=== Looping counter ===
Here is one which uses actual computation.
($A → 
$A → aX$
X$) → G$X.10
X → 
G → 
E$ → $A.42
a$ → EE$
.* → a$
Category: String-rewriting paradigm Category: Languages Category: Nondeterministic Category: Usability unknown Category: Unknown computational class
Category: Meta-languages
↓110010000100110110010

↓110010000100110110010 is an esolang by User:Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff.
== Syntax ==
A ↓110010000100110110010 program is represented as a series of binary digits that represents the initial stack. Digits are pushed from left to right, one by one, such that the rightmost digit is on the top of the stack. Any character besides 0 and 1 in the source code is ignored and treated as comments.
== Execution ==
Each step an instruction is popped off of the stack and executed. The program halts when the stack is empty when trying to pop a value off of the stack for an instruction. If this happens the program prints an "H"
 Commands
Symbol	Effect
0 	Pop a value off of the stack, negate it, and then push it twice. If the stack is empty, halt and output a 0.
1 	Pop 0s until a one is popped. Then, if there were n zeros popped, duplicate the top 2n+1 elements of the stack. In case of a stack underflow, halt and print a 1.
== Example ==
Here is an example of how a ↓110010000100110110010 program evolves over time.
 1010
 1000
 1011 
 100
 111
 11
 halts
== Another one ==
Another one, this one goes into an infinite loop.
101101
101101
...
Category: Languages Category: Self-modifying Category: Stack-based Category: Unknown computational class
Category: Output only Category: Usability unknown Category:2024 Category:Unimplemented
∆

∆ (also known as Delta) is a joke esolang like Brainfuck but it takes a googol (1 with 100 zeros) years to do ONE COMMAND.
∆ was made by User:HammyHammerhead by the way.
Category:Languages Category:Brainfuck derivatives Category:Joke languages Category:Cell-based Category:Turing complete Category:Turing tarpits Category:Unimplemented Category:Low-level
∇

Undelta is an esolang created by User:Ractangle when the creator got his new phone (actually it's being made in it right now)
==Syntax==
Symbol	Action
~ 	Pop the top of the stack
` 	Push a number into the stack
 	Stops the program
= 	checks if an element on the stack is matching the element next to it
p 	Print an element from the stack as a character
P 	the same thing as p but prints an elemenent as a number
+ 	Add two elements together
/ 	Devide two elements together
* 	Multiply two element together
- 	Subtract two elements together
Category:Languages Category:Stack-based Category:2024
∞D

∞D, aka infinid, is a programming language that uses a ∞D cube for data and programming
== Commands ==
 >D move in the Dth dimension forwards
 <D do that but backwards
 %C write C on that place as an instruction
 # run the code
== Instructions ==
Instructions are ran the way it is facing
 >D rotate in the Dth dimension right
 <D do that but left
 + add one to internal var
 - subtract one from internal var
 * place the internal var here, aka making it external, vvv
 also makes a new internal var, when stepped on, swap the vvv
 new internal var and external var, aka making external be vvv
 internal and internal be external
 ?D if the internal var is 0, continue, else rotate right in the Dth dimension right
 !D do that but left
 @ output the internal var
== Example ==
 %+
 >1
 %+
 >1
 %+
 >1
 %@
 #
 execution, IV is internal var, O is output
 IV = 0
 IV = 1
 IV = 2
 IV = 3
 O = 3
∞^∞ RGB8 panel

∞^∞ RGB8 panel is an esolang created by Unname4798 in response to 16x16 RGB2 panel. The board has infinity of dimensions. Tape pointer starts at (0,0,0...0,0,0)
== Commands ==
! toggle the mode (color/value)
+ increment
- decrement
> right
< left
/ increment dimension the pointer is moving in
\ decrement dimension the pointer is moving in
[ from branflakes
] from branflakes
== Code execution ==
The tape travels to the previous or the next color channel (if color mode is enabled and < or > is executed, respectively).
Each ∞D voxel has 24 bits, 8 for red, 8 for green and 8 for blue.
Code is in a infinite loop. Each iteration outputs all the ∞D voxels. There are infinity of values.
Category:Languages
Category:2025
Category:Brainfuck derivatives
∠fuck

∠fuck is an esolang invented by User:None1. It is derived from brainfuck.
==Tape==
The tape can contain unbounded real numbers.
All cells are 1 at the start, unlike brainfuck.
==Commands==
p represents the current cell value.
< >: The same in bf
+: p\leftarrow\tan(p \ rad)
-: p\leftarrow\arctan(p \ rad)
[CODE]: While p isn't 1, do CODE
,: Input a character, if its extended ASCII value is a, then set the current cell value to -\log_2 (1-\frac{a}{256})
.: Output a character which has the extended ASCII value of \lfloor 256(1-2^{-|x|})+0.5 \rfloor
EOF returns 1.
==Examples==
===Cat Program===
 ,[.,]
==Computational class==
Turing-complete, because brainfuck with bit cells is Turing complete, and in ∠fuck, we can use 1 for 0 and \tan(1 \ rad) for 1.
Category:Languages
Category:Brainfuck derivatives
Category:2024
Category:Turing complete
∫∫∫∫∫∫∫∫∫∫∫∫∫

∫∫∫∫∫∫∫∫∫∫∫∫∫ (pronounced hiroshima level integral) which is a esolang where anybody can add a command that follows these rules:
* command must be computable
* no compiling other esolangs
* no sexual content
* no emojis
* commands go on O(א₀). this is for rules like "cant be negative" or smth
its a subsection of O(א₀) that is not command related
== special things ==
user added items that are not a command