nyuuzyou/wikis huggingface dataset:
DirectBrainFUCK

DirectBrainFUCK is a brainfuck-like programming language, but you can directly move the pointer.
== Peculiarity ==
DirectBrainFUCK is derived from brainfuck; however, the number of cells has to be limited to 64, accessible by a one-based index.
Also, its nearly impossible to change the value of a cell that the memory pointer is pointing at, unless you use the input instruction to let the user press a key corresponding to an ASCII value.
The language lacks the control flow commands [ and ], excluding it in particular from offering conditional and iterative facilities.
== Instructions ==
Character	What it does
< 	Moves the memory pointer one cell to the left.
> 	Moves the memory pointer one cell to the right.
mv 	Moves the memory pointer to the cell with the one-based index v, for which must hold: 1 ≤ v ≤ 64.
, 	Prompts the user for an input character and stores its ASCII code in the current cell.
. 	Prints the ASCII character associated with the value of the current cell.
== Examples ==
The following example provides a one-time cat program:
 ,.
This cat program demonstrates the utilization of direct cell access using the dedicated m instruction:
 >>,<<m3.
== Implementations ==
A very simple implementation in Common Lisp is provided:
 (defun interpret-DirectBrainFUCK (code &aux (position 0))
 (declare (type string code) (type fixnum position))
 (symbol-macrolet ((token (the character (char code position))))
 (let ((memory (make-array 64 :element-type 'integer :initial-element 0))
 (pointer 0))
 (declare (type (vector integer 64) memory) (type (integer 0 63) pointer))
 (loop while (< position (length code)) do
 (case token
 (#\< (decf pointer))
 (#\> (incf pointer))
 (#\m (incf position)
 (setf pointer
 (loop with start of-type fixnum = position
 while (and (< position (length code)) (digit-char-p token))
 do (incf position)
 finally (return (1- (parse-integer code :start start :end position)))))
 (decf position))
 (#\, (format T "~&Please input a character: ")
 (setf (aref memory pointer) (char-code (read-char)))
 (clear-input))
 (#\. (write-char (code-char (aref memory pointer))))
 (T NIL))
 (incf position)))))
Category:Joke languages
Category:Languages
Category:Brainfuck derivatives
Category:Languages
Direction

This is a esolang that uses 2d syntax, plus orthogonal directions
== The but ==
 every direction command when you step on it it gets deleted
== Commands ==
 <>^v: direction commands
 I: get input and push it to stack
 ?: pops from stack and if that is 0 turn left >0 turn right, also doesnt disappear
 O: pops from stack and outputs it
 D: duplicate top of stack
 +: add top two
 -: sub top two in b-a where a is top
 *: mult top two
 /: div top two in b/a where a is top
 1: add one to stack
 0: add zero to stack
 S: make it so if next command will disappear, make it not
 N: make it so if next command wont disappear, make it
 E: stop program
== 321 program ==
 111++SvS <
 v?DO1-Sv S
 E S 
 >S^
Category:Languages Category:Two-dimensional languages Category:Stack-based
Directional

Directional is an esolang invented by User:None1 and inspired by TinyBF, it is actually a 2D version of TinyBF.
==Data Storage==
A tape and a pointer is used to execute the TinyBF commands.
==Commands==
Command	Meaning
↑ 	Set IP direction to up, and execute the TinyBF = command.
↓ 	Set IP direction to down, and execute the TinyBF + command.
← 	Set IP direction to left, and execute the TinyBF > command.
→ 	Set IP direction to right, and execute the TinyBF | command.
Other characters are NOPs. IP starts at top left corner and is direction is right initially. When it goes out of bounds, the program terminates.
==Example programs==
===Increment current cell===
 ↓
Please add Hello World, cat program, Truth Machine please!
Category:Languages
Category:Turing complete
Directionation

Directionation is an esolang made by User:Tommyaweosme
== Commands ==
The commands are:
 T pointer (starts going right)
 > go right
 < go left
 ^ go up
 V go down
 ? go random
 O toggle output mode
 A toggle add mode
 S toggle subtract mode
 C toggle check mode
 I sets value to user input before script starts
Escaped pointers dont mess up anything, and when every pointer is escaped, the program is terminated.
== Modes ==
Output mode outputs every value that the pointer runs across.
Add mode adds together every value that the pointer runs across.
Subtract mode subracts the first value it runs over from the second, and changes the second.
Check mode splits off a new pointer going up whenever it runs onto a positive value.
== Scripts ==
=== hello world ===
 TOhelloV
 dlorw<
=== kiwiscript ===
 TOkiwi
=== XKCD random number ===
 TOv
 >4<
=== actual random number (1-3) ===
 V
 3
 TO>?2<
 1
 ^
=== truth machine ===
 V
 O
 TC>I
 ^
=== cat ===
 TOI
=== infinite loop ===
 T>V
 ^<
=== 5 bottles of beer ===
 V <
 TS 1 V 
 V < 
 >O 5 bottles of beer on the wall^
 ^ <
=== dna-code ===
 V
 >t?c<
 TO?<
 g
 ^
== logic gates ==
=== and ===
 >S1V
 I o
 TAI^ ^<
Directions

Directions is a deque-based 2D esolang.
The PC moves in various directions on tiles(#). If it turns, nothing happens. If it didn't, an instruction will be executed. 
The tile which the PC comes from will be ignored. 
Priority:
 5 4 3 4 5
 4 2 1 2 4
 3 1 1 3
 4 2 1 2 4
 5 4 3 4 5
If there is a # on the position marked 1, it will ignore those on 2345. If not, try on 2.
If there are multiple tiles of the same priority, The direction depends on the box. 
Take the remainder of dividing the box by the number of tiles. Rotate clockwise from the north and count the tiles. If the count matches, go to that tile.
If there are no tiles, the program terminates.
==Commands==
Right movement	Up movement	Meaning
-1 	-1 	NOP
-2 	-2 	NOP
-2 	-1 	Restart the program while remain data unchanged
-1 	-2 	Halt
-2 	0 	Push the box to the frontend
-1 	0 	Push the box to the backend
0 	-2 	Pop from the frontend
0 	-1 	Pop from the backend
Category:Languages Category:Deque-based Category:2024 Category:Unimplemented Category:Two-dimensional languages Category:Unknown computational class Category:Usability unknown
Dis

Dis is an esoteric programming language designed by Ben Olmstead to walk the line between humanly impossible to program in and just extremely painful. While it is not quite as fearsome as Malbolge, Dis is still pretty bad.
==Differences from Malbolge==
Dis is very similar to Malbolge in many respects. Here's a summary of the differences:
* The need for decryption of the instruction prior to decoding is eliminated.
* Instructions are not encrypted after execution.
* The crazy operator is replaced by a tritwise subtract without borrow.
* The opcodes are remapped: ji*p/<vo become *^>|}{!_ respectively.
* The output instruction can end the program immediately when a 2222222222 ternary is written.
* Comments may be used, enclosed in parentheses. They can't be nested.
* Unused memory is zero-padded.
==Sample programs==
There are not many examples of Dis code. This cat program comes from the author:
(Unix 'cat' in Dis. This is the language test; I shall be working on a)
('Hello, world' program presently. In the meantime, here's cat with )
(explanation: )
 * (Set the data pointer to 42--from the ASCII code of '*')
 ^ (Jump to label 1, below, via the ! at the new data pointer.)
||||||||||||||||||||||||||||||||
 (Placeholders.)
 (label 1:)
 }{ (Read a character, write, automatically die on EOF.)
 * (Set data pointer back to 42.)
 ^ (Read character, write character, repeat.)
||||| (More placeholders.)
 !||* (Data for jump and data pointer instructions which are used
 elsewhere.)
hello world program, by User:Pro465:
('Hello, world!' program in Dis.)
 * (Set the data pointer to 42--from the ASCII code of '*')
 |{
 |||{
 |{{
 |||{
 |{
 |||{
 ||{
 |||{
 |||{
 |||{
 |{
 ||{
 ! (Halt the program.)
 ||
 (Placeholders.)
 $|QQ7|J||QQW|j|QQ]|Qf|QQb|QQW|QQW|&|QL|
 (Data.)
==Computational class==
Due to having a limited amount of memory, Dis is in the class of bounded-storage machines. However, if Dis were modified to be able to address an unbounded area of memory, like Malbolge Unshackled, it would likely be Turing complete as its operations are complete, and similar techniques used in Malbolge for conditional execution could be used in Dis.
==See also==
* Malbolge
* Wimpmode: Dis can be thought of as a wimpmode of Malbolge.
==External resources==
* including the original interpreter
* 
Category:Languages
Category:Cell-based
Category:Usability unknown
Category:Bounded-storage machine
Category:Implemented
Category:Self-modifying
Category:1998
Disan

Its only command, D, implements the Disan Count.
==Examples==
===Implement the Disan Count===
 D
==Interpreter==
The following implementation is realized in Common Lisp:
 (defun interpret-Disan (code)
 "Interprets the piece of Disan CODE and returns NIL."
 (declare (type string code))
 (loop for token of-type character across code do
 (if (char= token #\D)
 (let ((n (parse-integer (read-line))))
 (declare (type integer n))
 (let ((a 0))
 (declare (type integer a))
 (loop while (< a n) do
 (when (evenp a)
 (format T "~&~d is even!" a))
 (incf a 1))))
 (error "Invalid character: \"~c\"." token))))
Category:Languages Category:2018 Category:Implemented Category:Total Category:Unusable for programming
Disan Count

A Disan Count is a program designed to test whether a programming language can execute infinite loops, conditionals, I/O and basic arithmetic operations successfully. The intention was that any programming language able to implement this function would also be usable to implement a Turing machine Tapes and Turing machines, allowing a Disan Count to be used to test the Turing completeness of any given language. However, it turned out to be insufficient for this purpose.
== History ==
Disan Counts were proposed by Matías Di Santo by late 2016, as a way to test basic Turing completeness of simple programming languages. As Di Santo explained, any programming language able to implement an arbitrarily long jump cycle effectively could also be used to mimic the movement of an infinite Turing Automata tape. By also introducing means of testing (in)equality and value storage, the read from and write to the tape operations could also be simulated, thus rendering the given language Turing complete.
In response to the definition, languages were created that could perform a Disan Count but fell short of Turing-completeness for other reasons. For example, BuzzFizz is a linear bounded automaton, where the amount of usable memory effectively depends on the size of the input; this technique makes it possible to have enough memory to implement a Disan Count regardless of the size of the input, but not to implement arbitrary Turing machines (because for any computable function from inputs to memory sizes, there's a Turing machine that requires at least that amount of memory, and you can pick a Turing machine whose memory requirements grow too fast with the input for BuzzFizz to handle).
== Algorithm ==
The algorithm is defined (in pseudo-code) as follows:
 n ← input n
 a ← 0
 Start:
 If a is even:
 print a + "is even!"
 a ← a + 1
 If a < n:
 Jump to Start
For example, a C/C++ equivalent could be written as:
 #include <stdio.h>
 int main() {
 int n;
 scanf("%d", &n);
 int a = 0;
 while(a < n){
 if(a % 2 == 0) printf("%d is even\n", a);
 a++;
 }
 }
The Disan Count test was defined to disallow 'cheating' the algorithm by increasing the iteration variable by any number other than one, using finite-state loops (like for loops) or avoiding conditionals.
==See also==
* Fibonacci sequence
* 99 bottles of beer
== References ==
Category: Program forms
Disan Count (language)

Disan Count is an esoteric programming language created by User:TheCanon2 to demonstrate the insufficiency of using the Disan Count as a proof for Turing-completeness.
==Commands==
Disan Count (language) has a single accumulator, x and 2 commands.
Command	Action
i 	Set x to an input
D 	Print the Disan Count for x
==Examples==
===Disan Count===
iD
===Computational class===
The Disan Count fails as a proof of Turing-completeness because it is susceptible to the HQ9+ problem, in which a language can perform popular problems that imply Turing-completeness despite being computationally limited to said problems.
Disan Count (language) is not Turing-complete because all programs halt.
==Implementations==
The following Python script is an interpreter.
prgm = input('>Disan Count ')
x = 0
for i in range(0, len(prgm)):
 if prgm[i] == "i":
 x = int(input('>i '))
 if prgm[i] == "D":
 for j in range(0, x, 2):
 print("%d is even!" % j)
Category:Joke languages
Category:Accumulator-based
Category:Implemented
Category:Total
Category:Low-level
Category:Unusable for programming
Category:2025
Disan Count Pesudocode

Disan Count Pesudocode (or DCP) is a esolang created by User:Ractangle based on this pesudo-code:
 n ← input n
 a ← 0
 Start:
 If a is even:
 print a + "is even!"
 a ← a + 1
 If a < n:
 Jump to Start
==Syntax==
Command 	Action 	Example
A ← B 	Assigns variable A with value B 	B ← 5
A ← B
input A 	Takes input and stores into a variable	input i
A: 	Creates label A 	none
If A: 	Conditional 	If A is 10
 print "Hello, world!"
print A 	Prints A 	print "hello :D"
Jump to A	Goto statement 	none
==Examples==
===Hello, world!===
 print "Hello, world!"
===Cat program===
 input i
 print i
===Disan Count===
 input n
 a ← 0
 Start:
 a ← a+1
 If a is even
 print a + "is even"
 If a < n:
 Jump to Start
Category:Languages Category:Unimplemented
Dish

Dish (or Dead fISH) is a deadfish inspired esolang created by User:Ractangle
==Syntax==
Command	Action
i 	deadfish command.
d 	if a!=0, decrement a. Else skip to the next .
s 	Push the accumulator to the stack.
o 	if len(s)>0, print the top element on the stack as a character. Else print a as a number.
h 	Halt program.
+ 	Adds two stack elements together and pushes the result into the stack.
- 	Same as but does subtraction instead
b 	Goes to the previous .
u 	Gets user input.
v 	Sets the value on the stack and gets popped.
~ 	Discards the top value on the stack.
==Examples==
===Truth-machine===
 udobdoh
===The powers of two===
 iiidss+v~ob
Category:LanguagesCategory:2024Category:UnimplementedCategory:Stack-basedCategory:Deadfish derivatives
Disney queue

A Disney queue is a parodical and esoteric data structure. It is a variant upon the queue that supports a FastPass line, a Single Rider line, as well as other features of queues at Disney (any user who knows of a feature of queues at Disney parks that is not mentioned here is free to add it).
== Operations ==
=== Enqueue group === 
 DQueue.enqueue_group([group members])
This operation enqueues a group into the main line. It accepts a list of items that it puts at the end of the line. These members are kept associated for the dequeueing process.
=== Enqueue with FastPass® === 
 DQueue.enqueue_with_FastPass®([group members])
Enqueues associated group [group members] into the FastPass line after a time limit. Only a certain number of these can be done every hour.
=== Enqueue Single Rider ===
 DQueue.enqueue_single_rider_(rider)
This operation adds one unassociated rider to the Single Rider Line.
=== Dequeue ===
 DQueue.dequeue(n)
The dequeuing operation is rather complicated. Here, we will discuss a simplification of it. N is equal to an integer indicating the length of the array to output to from the function. The way that this works is: Groups are added from the FastPass and Main lines in alternating sequence until there isn't room for the next group in line. Then, if any are available in the Single Rider line, N is met by adding single members of the SRL until the quota is met. If there are not enough Single Riders to meet n, then the array is returned with nulls in place of the riders that could not be met.
==== Child swap ====
At Disney, a child swap occurs when two parents and a child reach the front of the line for a ride that the child does not meet the requirements to ride. Parent A rides while Parent B stays behind with the child at the front of the line, then when Parent A reaches the end, Parent B rides while Parent A stays with the child.
In Disney queues, to emulate a child swap, this process is followed: if an item which does not meet the requirements to ride set upon queue creation is entered into the queue, a "child swap" may occur when that group reaches the front of the line. All but one member of the group (excluding all objects unable to be dequeued) are dequeued, then the one remaining member is dequeued and the child is dropped from the queue. This roughly emulates an actual "Child Swap" at Disney parks.
Category:Data Types and Structures
Ditch

Ditch is an esolang by User:BoundedBeans where syntax is irreversibly changed periodically.
==Syntax==
Ditch is a bit like Forth. It has a stack and words that operate on it, though you cannot define your own. However, in Ditch, all data is strings. Strings are enclosed in double quotes and only have two escape sequences: ?", for escaping quotes, and ??, for escaping question marks.
==Levels==
At level 0, the following operations can be performed in postfix:
+ 	concatenation of two strings
> 	the first character
< 	everything except the first character
 	The following 5 commands definitions are the same as in Forth.
: 	dup
/ 	swap
$ 	drop
% 	rot
^ 	over
 	End forth copying.
_ 	pop x and use its length as a zero-based index from the top of the stack, pick that element and copy it to the top.
= 	pushes "a" if the top two strings are equal, "" otherwise
 	pushes the length of the string in unary "a"
begin ... until 	as in forth, but the empty string is falsy and everything else is truthy
if ... else ... then	as in forth, but the empty string is falsy and everything else is truthy
. 	outputs the top string
, 	inputs a line
After 5 instructions excluding keywords and string literals, the program automatically and irreversibly "ditches" the code to the next level, resetting the counter back to zero. The stack is preserved when ditching.
At any level besides level 0, there is only one operation:
@	eval the top string as the previous level. It is an error if a ditch occurs inside of this, unless enclosed within a block. Note that the 5 instruction limit applies to every level, but separately. 5 instructions on level 1 can simulate 25 instructions at level 0. Eval uses the same stack as normal. Eval can have the string preloaded ahead of time, and when it's executing the contents, instructions can manipulate the stuff below.
Inside of a block, the level is separate. It is possible to have a block ditch and then recover once it exits the block (from any amount of levels). This is to allow conditionals and loops that are longer than a tiny amount of commands. Because of this, commands inside of blocks do not count towards the 5 outside the block, but they do inside. This would require a stack of levels to implement. It can just as well do this inside of eval, although it would need to get down to level zero in order to even use blocks.
Let's make a one line cat and see how it transforms.
Level 0:
 , .
Level 1:
 ", ." @
Level 2:
 "?", .?" @" @
Level 3:
 "?"???", .???" @?" @" @
Level 4:
 "?"???"???????", .???????" @???" @?" @" @
==Examples==
===Hello world!===
 "Hello world!" .
===Truth-machine===
 , : "0" = / / "if . else begin : . ?"?" until then" @
Category:Languages
Category:Unimplemented
Category:Stack-based
Category:2023
Division

Division is a stupid language created by User:None1.
==Syntax==
Any valid program in Division looks like this:
 a/b
a and b are non-negative decimal numbers.
Any invalid program raises a syntax error:
 Syntax error
For a valid program, if b is 0, it raises an error:
 You can't divide by zero!
Otherwise, it raises an error:
 I'll raise an error because you don't want me to!
For any program, Division will always raise an error.
==Example Programs==
===Division by Zero===
 1/0
===Quine===
 Syntax error
==Interpreter==
===Python===
a=input().split("/")
if len(a) != 2:
 print("Syntax error")
else:
 try:
 b,c=int(a[0]),int(a[1])
 except:
 print("Syntax error")
 else:
 if b<0 or c<0:
 print("Syntax error")
 elif b==0:
 print("You can't divide by zero!")
 else:
 print("I'll raise an error because you don't want me to!")
=== Another Python Interpreter ===
a=input().split("/")
if len(a) != 2:
 raise SyntaxError
else:
 try:
 b,c=int(a[0]),int(a[1])
 except:
 raise SyntaxError
 else:
 if b<0 or c<0:
 raise SyntaxError
 elif b==0:
 raise ZeroDivisionError("You can't divide by 0!")
 else:
 raise SyntaxError("I'll raise an error because you don't want me to!")
Category:Total
Category:Output only
Category:Unusable for programming
Category:Languages
Category:Joke languages
Category:Implemented
Do-code

This language is made by User:Unicodes
Do-code runs on a array of 2048 numbers from 0 to 255, where there is a program pointer at cell 0.
== Syntax ==
Every statement run has to be in a "do (#)" block.
There are 2 types of do blocks: "do (#)" and "do (do (#) and do (#))".
The # are nested do blocks or instructions.
 Instructions
Instruction	Action
+p 	move pointer index by 1
-p 	move pointer index by -1
+i 	add 1 to current pointed value
-i 	add -1 to current pointed value
n 	nothing
pr 	print current character as number
pra 	print current character as ascii character
rd 	set current pointed value to inputted character index
rdn 	set current pointed value to inputted number
q 	quit
Do block attachments are bits of text that change the condition of execution of the do block.
 Do block attachments (X can be a number between 0 & 255)
Attachment 	Action
if X > pt do (#) 	executes the do block if X is bigger than current pointed value
if X = pt do (#) 	executes the do block if X is equal to current pointed value
if X < pt do (#) 	executes the do block if X is smaller than current pointed value
if X >= pt do (#)	executes the do block if X is bigger or equal to current pointed value
if X <= pt do (#)	executes the do block if X is smaller or equal to current pointed value
if X <> pt do (#)	executes the do block if X is not equal to current pointed value
wh X > pt do (#) 	executes the do block repeatedly while X is bigger than current pointed value
wh X > pt do (#) 	executes the do block repeatedly while X is bigger than current pointed value
wh X = pt do (#) 	executes the do block repeatedly while X is equal to current pointed value
wh X < pt do (#) 	executes the do block repeatedly while X is smaller than current pointed value
wh X >= pt do (#)	executes the do block repeatedly while X is bigger or equal to current pointed value
wh X <= pt do (#)	executes the do block repeatedly while X is smaller or equal to current pointed value
wh X <> pt do (#)	executes the do block repeatedly while X is not equal to current pointed value
You can make a comment like this:
| comment |
== Examples ==
=== Truth Machine ===
 do ( do ( rdn ) and do ( wh 1 = pt do ( pr ) and do ( pr ) )
Category:Languages Category:Cell-based Category:Finite state automata Category:Low-level
DoEverything();

doEverything(); is an esolang by Cortex that can do anything and everything, including everything. Its syntax is very similar to JavaScript.
==Commands==
Command 	What it does 	Example
doEverything(); 	Runs every possible program in any programming language (including this one) that does not contain a syntax error simultaneously. 	doEverything();
cure(diseaseName);	If diseaseName is the name of a disease, syndrome, plague, anything, step-by-step instructions on creating a cure will be printed 	cure(cancer);
becomeSentient(); 	He achieves sentience. 	becomeSentient();
run(x); 	Runs any program (possible values of x: helloWorld (standard hello world program), superMarioBros, jsdE (doEverything(); compiler in JavaScript), 	run(jsdE);
AI.converse(x); 	Upon entering a message (x), he will reply with an appropriate response. Yields a divide by zero error if placed before a becomeSentient(); command.	AI.converse(hey what's up can i get uhhh THE MEANING OF LIFE);
b(x); 	Prints x 	b(5t4tgko7);
xt4tgkoy 	Returns x+y 	b(5t4tgko7);
== Hello, World! ==
 b(Hello, World!);
or
 run(helloWorld);
== A+B Problem ==
Takes in a random number
 becomeSentient();
 AI.converse(give two random numbers and assign the variables E and F to them PLEASE);
 b(Et4tgkoF);
Category:Languages
Category:Joke languages
Category:2018
Category:Uncomputable
Category:Unimplemented