nyuuzyou/wikis huggingface dataset:
Asdfjkl;

asdfjkl; is an extension of asdf and 1234.The pointer begins at memory location 3. It can be moved left or right infinitely. IO is memory mapped. To read from the console, toggle the bit at location 0 twice without moving or hitting a loop; this will read one bit from the console into location 2. To write to the console, toggle the bit at location 1 twice without moving or hitting a loop; this will write one bit from location 2 to the console. Since all console IO is bytewise, all reads and writes to the console are buffered (8 bits).
Instruction	Description
a 	Toggles the bit at the current location and sets the toggle flag.
s 	If the toggle flag is clear, move the pointer right. If the toggle flag is set, move the pointer left. Either way, clear the toggle flag.
d 	If the bit at the current location is 1, jump forward to the matching f. Also, clear the toggle flag.
f 	If the bit at the current location is 0, jump backward to the matching d. Also, clear the toggle flag.
j 	Flip the current bit and move the pointer left. If the pointer ends at location -4, the pointer is moved to location 0.
k 	If the pointer is at location -3, read a character from the console and put it in locations 0 through 7; then move the pointer to location 0. If the pointer is at location -2, write a character to the console corresponding to locations 0 through 7; then move the pointer to location 0. At any other location, move the pointer right.
l 	Specifies a jump symbol. If the pointer is below 0, do nothing. If the current bit is TRUE, skip back to either the previous jump symbol or the start of the program. If the current bit is FALSE, skip forward to either the next jump symbol or the end of the program.
; 	Specified code-jump. Jump right the number of the pointed byte in the code.
== Examples ==
=== Hello, world! ===
 asaasaasssasaasssasaaaasssasaasssasaaaaaaaasssasaaaasssasaaaasssasaasssasaasssasaasssasaasssasaaaasssasaasssasaaaasssasaaaaaasssas
 aaaasssasaasssasaaaasssasaaaaaasssasaaaasssasaasssasaaaaaaaasssasaaaasssasaasssasaasssasaaaasssasaaaaaaaasssasaasssasaaaaaaaaaaaas
 ssasaaaaaasssasaasssasaaaaaasssasaasssasaaaasssasaasssasaaaaaaaasssasaasssasaaaaaasssasaaaasssasaasssasaaaasssasaaaasssasaasssasaa
 aasssasaaaaaasssasaaaasssasaaaasssasaasssasaaaaaaaasssasaasssasaaaaaaaasssasaa
=== Move the pointer right, regardless of toggle bit (note: may perform I/O at low addresses) ===
 aasss
=== Move the pointer left, regardless of toggle bit (note: may perform I/O at low addresses) ===
 aas
=== Cat Program ===
 jjjkjkjjk
Category:Languages
Category:2017
Category:Turing complete
Category:Turing tarpits
Category:Low-level
Category:Brainfuck derivatives
Category:Cell-based
Ases

Ases (Assembly esotérico, or in English "esoteric Assembly") is an esoteric programming language developed by a Brazilian called Luiz Felipe.
The objective of the esolang is to be as functional as possible in order for it to be possible to develop more complex algorithms but with limitations in order to turn it into a challenge.
Some characteristics of the language (like registers and stack) are based on the Assembly language of the x86 architecture.
== Interpreter ==
The interpreter of the esolang was developed in C. The source code is distributed under the MIT license and can be found in the GitHub repository of the language.
== Characteristics ==
One-line comments in Ases are defined with the ; (semicolon) character. Any character that is not an instruction is ignored.
Ases has a memory with a size of 256 bytes and a maximum code size of 256 bytes.
This limit is because pointers have a size of 1 byte. Thus it is only possible to point to 256 different bytes in memory.
All instructions in Ases are just one character long.
== Examples ==
Hello World in Ases
+++++ +++++ c ; C = 10
--- b ; B = 7
@
	C4 ; A += C
	D++++d ; D += 4
B-b%) ; Repeat B times
D++++d ; D += 4
; A = C * B
; D = 32
.++ 4 ; A += 2
.+++++! ; Memory[0] = 5
A1 ; "H"
=44444-4 A1 ; "e"
=4---4 A1 ; "l"
 1 ; "l"
.+++ 4 A>!< 1 ; "o" - Memory[1] = 'o'
 D1 ; " "
=5555-5 A1 ; "W"
>=a< A1 ; "o"
.+++ 4 A1 ; "r"
=5 .+ 5 A1 ; "l"
=5--5 A1 ; "d"
Category:Languages
Category:Low-level
Category:2018
Category:Finite state automata
Category:Implemented
Ashtol

Ashtol is a programming language created by Gábor on March 11th, 2014. It uses "encrypted" directives to operate on numbers, and in the end convert those numbers into characters as output. A prototype Ashtol interpreter written in Java can be found here (run in console). Ashtol was somewhat inspired by Malbolge.
==Code==
Coding in Ashtol is based on the standard qwerty keyboard, or the keys in the following fashion:
 1 2 3 4 5 6 7 8 9 0 - =
 q w e r t y u i o p [ ]
 a s d f g h j k l ; ' \
 z x c v b n m , . /
The first character in an Ashtol program denotes which key the sequence of keys will begin with. Every character after the first is one of four operations: increment, decrement, multiply, divide, and they all follow this "move" rule:
 s
 - +
 0 1 2 3 4 5 6 7 8 9
If you wanted to increment, you would have to type the key that is 1 down and 2 to the right of the start position (s), which, in the case of "1" being the last key pressed is the "e" key. Each new operation treats the last key pressed as the starting position for a new move. When one goes "out of bounds" of the keyboard it wraps around (e.g. incrementing after a "v" would be done with a "6").
Other rules:
* Whitespace (and any character that does not appear on the above keyboard) is ignored, but each new line represents a character to be outputted.
* Operations on each new line begin by manipulating the number zero.
* All lines must begin by incrementing 0.
* An incrementation cannot follow a decrementation and vice-versa.
* Multiplication only occurs if a "number" is supplied when the last "-crementation" was an incrementation.
* Division only occurs if a "number is supplied when the last "-crementation" was a decrementation.
The following program outputs an exclamation mark:
 1
 ez2e
# Moving from "1" to "e" increments 0 to 1. (Starting with 0, because this is the beginning of the first character)
# Moving from "e" to "z" multiplies 1 by 1.
# Moving from "z" to "2" decrements 1 to 0.
# Moving from "2" to "e" decrements 0 to -1.
# The final output of the program (-1) is then taken and the sign is switched to give 1, and then 32 is added to that, to give 33.
# 33 is converted to an exclamation mark based on the Unicode character list, and outputted.
==Examples==
One (simpler) way to write "Hello world!" in Ashtol:
 3
 tc4th4ybu,
 0k.0[.-;9'x3rg3tb
 7gn7in8\2efb6fnt
 j5yj,yk0sc4th4yb
 7gn7in8l0\v
 6fb
 7gn7in8j9db7o
 '9p'x]s7h8p
 \0[\cqd2f9p'
 cqsc4svy/-]ax]s1
 ez2ef2rcwv6i;-
 q.0[
==External resources==
* Prototype Ashtol interpreter written in Java 
* 
* Ashtol-Interpreter written in Lua by Michael Armbruster . It is used as external script for a game, so output is cached. (Licensed under GPLv3)
Category:Languages
Ask-calculus

The SKA-calculus and the ask-calculus are products of a thought experiment by Chris Pressey in or around May 2020 to produce a concatenative version of the SKI combinator calculus.
We start with combinatory logic with the S, K basis. We are told this is an "applicative language", and that there is also a kind of language called a "concatenative language" which everyone supposes is a different thing, and no-one supposes SK-calculus to be. So we apply a series of transformations to turn it into a concatenative language.
First, combinatory logic has parentheses, but concatenative languages do not. We observe that it only needs parentheses because there is a tacit infix "apply" operator which is not associative. We replace it with an explicit prefix operator which we notate as A, obtaining the "SKA-calculus". For example, where in combinatory logic we would write SSK (taken to be parenthesized as (SS)K) and S(SK), in SKA calculus we would instead write AASSK and ASASK. We have thus eliminated the need for parentheses.
Second, we observe that the SKA-calculus eliminates parentheses by being, essentially, forward Polish notation, but also that we are told that concatenative languages almost universally use reverse Polish notation instead. So we define the "ask calculus" thusly: for every string s in the language of SKA-calculus, there is a string t in the ask-calculus which is equal to s except it is lower-case and reversed. Importantly, t has the same meaning in the ask-calculus as s has in the SKA-calculus. So the equivalents of the above two examples, in ask-calculus, are kssaa and ksasa.
The operational semantics of the ask-calculus are intentionally not specified. Perhaps a programmer who programs in concatenative languages would say that k pushes the K combinator onto the stack, s pushes the S combinator onto the stack, and a pops two combinators from the stack, applies the first to the second, and pushes the result back on the stack -- I mean I don't want to put words in anyone's mouth but it sounds like a reasonable guess any reasonable programmer might make, right? -- but it should be stressed that nowhere in the definition of the ask-calculus is there any mention of a stack. Conversely, someone who writes parsers all day might wonder instead why there is no mention of a stack in the SKA-calculus, nor in the SKI-calculus from whence it came, when it is crystal clear that something like a stack is required to parse it correctly.
From this experiment we can only conclude that function composition is a special case of function application, and also vice versa, or something.
===Computability class===
Both SKA-calculus and ask-calculus are Turing complete by virtue of being derived directly from SKI combinator calculus which is Turing complete.
Category:Computational models Category:Turing complete Category:2020
Asmlang

Asmlang is an Work-in-progress language.
Here is the concept file:
Instruction set
F is an adress,pointing to an 8-bit value.
W is an 8-bit accumulator.
Stack have 2 levels :)
0<=b<8
Add,And,Or,Subtract,XOR W with F to D
Rotate left/right thru carry,Swap halves,Complement,increment/decrement(with optional skip if zero),Move f to dest.
Clear/set bit b in reg f,Skip if bit b in f is zero/one.
And,Or,Move,Xor literal to W.
NOP
CONTROL-FLOW:
Call subroutine(Push PC to stack)
Unconditional jump
Return and place literal in W(PC -> Stack top,pop stack)
Category:Languages
Assemblei

Assemblei is a esoteric programming language made by Oklomsy
it uses binary to form words, the interpreter doesn't decode the binary (Because Python.)
== Syntax ==
In assemblei, there are 8 cells, each cell is a digit in binary, you can move to different cells and change them.
a, b, c, d, e, f, g and h
Command	Description 	Example
! 	Moves forward to a different cell. 	!! (Moves from a to b)
? 	Moves backwards to a different cell. 	? (Moves from a to (Empty) )
# 	Prints every cell's content. 	# = 00000000 (If no cells were changed.)
. 	Prints the cell you are currently on 	. = a (If you are on the a cell.)
+ 	Increases the cell's value. (There is no subtraction command)	+ (will turn a from 0 into 1, if cell a is 0)
, 	Clears all variables. 	, (will turn all cells into 0)
== Interpreter ==
You can get the python interpreter at assemblei repo
The interpreter was updated/improved by Matt07734
== Programs == 
Hello World program
 !!+!+!!+#,!!+!+!!!+!!+#,!!+!+!!+!+#,!!+!+!!+!+#,!!+!+!!+!+!+!+#,!!!+#,!!+!+!+!!+!+!+#,!!+!+!!+!+!+!+#,!!+!+!+!!!+#,!!+!+!!+!+#,!!+!+!!!+#,!!!+!!!!!+#,
Category:2020Category:Joke languagesCategory:Unusable for programming
Category: Implemented
Category:Languages
AssemblerFuck

AssemblerFuck is a language made by User:Sesshomariu and is a version of brainfuck that uses assembler-like words instead of symbols.
== Specification and instructions ==
There are 5 instructions:
 ADD <VALUE> Adds a value to the current cell.
 SUB <VALUE> Subtracts a value from the current cell.
 MOV <TARGET>, <OBJECT> Moves the object to the target. This does only work with cells and not with values.
 UNTIL 0 Jumps to the matching END if the current byte is equal to 0. Else, it executes the code between UNTIL 0 and END.
 END Jumps to the past matching UNTIL 0 if the current byte is equal to 0.
== Valid targets and objects ==
Targets:
 P The pointer itself.
 LEFT The cell left of the pointer.
 RIGHT The cell right of the pointer.
 OUT The output.
Objects:
 P The pointer itself.
 LEFT The cell left of the pointer.
 RIGHT The cell right of the pointer.
 IN The input.
== Examples ==
=== Hello World ===
 ADD 8
 UNTIL 0
 MOV RIGHT, P
 ADD 4
 UNTIL 0
 MOV RIGHT, P
 ADD 2
 MOV RIGHT, P
 ADD 3
 MOV RIGHT, P
 ADD 3
 MOV RIGHT, P
 ADD 1
 MOV LEFT, P
 MOV LEFT, P
 MOV LEFT, P
 MOV LEFT, P
 SUB 1
 END
 MOV RIGHT, P
 ADD 1
 MOV RIGHT, P
 ADD 1
 MOV RIGHT, P
 SUB 1
 MOV RIGHT, P
 MOV RIGHT, P
 ADD 1
 UNTIL 0
 MOV LEFT, P
 END
 MOV LEFT, P
 SUB 1
 END
 MOV RIGHT, P
 MOV RIGHT, P
 MOV OUT, P
 MOV RIGHT, P
 SUB 3
 MOV OUT, P
 ADD 7
 MOV OUT, P
 MOV OUT, P
 ADD 3
 MOV OUT, P
 MOV RIGHT, P
 MOV RIGHT, P
 MOV OUT, P
 MOV LEFT, P
 SUB 1
 MOV OUT, P
 MOV LEFT, P
 MOV OUT, P
 ADD 3
 MOV OUT, P
 SUB 6
 MOV OUT, P
 SUB 8
 MOV OUT, P
 MOV RIGHT, P
 MOV RIGHT, P
 ADD 1
 MOV OUT, P
 MOV RIGHT, P
 ADD 2
 MOV OUT, P
=== Cat Program ===
 MOV P, IN
 UNTIL 0
 	MOV OUT, P
 	MOV P, IN
 END
=== Truth-machine ===
A truth-machine is implemented in the following:
 MOV P, IN
 MOV OUT, P
 UNTIL 0
 SUB 2
 MOV RIGHT, P
 ADD 1
 UNTIL 0
 MOV RIGHT, P
 MOV RIGHT, P
 END
 MOV LEFT, P
 UNTIL 0
 MOV OUT, P
 END
 MOV LEFT, P
 MOV LEFT, P
 END
==See Also:==
*brainfuck
*Minifuck
*AssemblerFuck++
==Interpreter==
* Common Lisp implementation of the AssemblerFuck programming language.
Category:2016
Category:Languages
Category:Cell-based
Category:Brainfuck derivatives
Category:Turing complete
Category:Implemented
AssemblerFuck++

==Creator and Name==
AssemblerFuck++ is an esoteric language created by User:Esolang1. This language is AssemblerFuck, with few more features containing if statements, more loops, and an accumulator. (E1-0003)
==Code==
===Syntax===
The syntax is simply
 INSTRUCTION PARAMETER(S)
===Instructions===
 ADD <VALUE> Adds <VALUE> to current cell
 SUB <VALUE> Subtracts <VALUE> from current cell
 SET <VALUE> Sets the current cell value to <VALUE>
 MOV <TARGET>, <OBJECT> Moves <OBJECT> to <TARGET>
 UNTIL <VALUE> Executes code until cell value is equal to <VALUE>
 DO <VALUE> Executes code <VALUE> times
 IF <VALUE> Executes code if current cell value is equal to <VALUE>
 END Marks the end of the code of a loop, or an if statement
<VALUE> can be any non-negative integer. 0 is used to create infinite do loops.
===Valid <OBJECT> Content and usage===
 P Pointer, move pointer
 IN Input, save input
===Valid <TARGET> Content and usage===
 P Pointer, save input
 LEFT Left, move pointer
 RIGHT Right, move poiner
 OUT Output, print value
===Variables===
This language is cell-based and no instructions related to declaring variables exist.
==I/O==
Inputs and outputs are controlable with the MOV instruction.
Getting a single characer input and saving to current cell:
 MOV P, IN
Printing the current cell value:
 MOV OUT, P
Printing the input immediately won't save the input to the cell:
 MOV OUT, IN
==Examples==
===Truth-machine===
 MOV P, IN
 IF 48
 MOV OUT, P
 END
 IF 49
 DO 0
 MOV OUT, P
 END
 END
===Infinite cat===
 DO 0
 MOV OUT, IN
 END
==Interpreter==
* Common Lisp implementation of the AssemblerFuck++ programming language.
Category:2022
Category:Languages
Category:Cell-based
Category:Brainfuck derivatives
Category:Turing complete
Category:Implemented
Assembly code

:
Assembly code is a notation for machine code designed to aid readability. A machine code instruction consisting of binary digits representing an operation and possibly addresses or integers is represented by a mnemonic code representing the operations, and labels or numerals representing addresses or integers. Assembly codes differ from other programming languages in that the relationship between an assembly code and its machine code form is direct, making the implementation of a compiler - known as an assembler - in machine code straightforward.
As is the case with machine code, any programming language can be regarded as assembly code for a hypothetical machine with machine code instructions corresponding directly to the instructions of the language, but this concept is usually reserved for esoteric programming languages for which a compiler to an existing machine code is very small, such as Brainfuck (whose 680x0 compiler was 240 bytes in size).
==Some Example==
Example01: 
ASSUME CS:CODESG
CODESG SEGMENT
START:
 MOV AX, 0123H
 MOV BX, 0456H
 ADD AX, BX
 ADD AX, AX
 
 MOV AH, 4CH
 INT 21H
CODESG ENDS
END START
==See also==
*Machine code
Category:Concepts
Assemblyfuck

AssemblyFuck is a language made by User:asdf and is a version of brainfuck that uses assembler-like words instead of symbols.
== Specification and instructions ==
There are 6 instructions:
 ADD <VALUE> ,<TARGET> Adds a value to the cell numbered as...
 SUB <VALUE> ,<TARGET> Subtracts a value from the cell numbered as...
 MOV <VALUE>, <TARGET> Moves the object to the target.
 CMP <CELL NUMBER>,<NNUMBER>Compares the cell with a number.
 JE <TAG> Jumps to the tag if CMP is equal.
 JNE <TAG> Jumps to the tag if CMP is unequal.
== Valid tags ==
Targets:
 ...
=== Hello World ===
== implementations ==
===python===
 compiler made by Baldibacak (talk)
 https://github.com/serpentis64/Assemblyfuck/tree/main
 
==See Also:==
*brainfuck
*Minifuck
Category:Languages Category:implemented Category:2020 Category:Low-level Category:No IO
Assign

Assign is an esoteric programming language that is a subset of JavaScript. In Assign there are no assignment, increment or decrement operators.
==Strategy==
I found that to write programs in assign I would need to use one of two strategies (maybe there are others). The first strategy is to use recursive functions instead of loops in all cases. This actually leads to some very elegant (and short) programs. The second strategy is to use an array to store values. We initialize the array by passing [] into a function, and then provided set and get operations which modify elements in the array.
==Example Programs== 
====Primes #1====
 function checkPrime(a, b){ 
 if(a == b)
 return true 
 return ( b % a != 0 ) && checkPrime(a+1, b) 
 } 
 
 function isPrime(x){ 
 return checkPrime(2, x)
 } 
 
 function printPrimes(a, b){ 
 if(isPrime(a))
 console.log(a)
 if(a < b)
 printPrimes(a+1, b)
 }
 
 printPrimes(2, 30)
====Sort====
 function merge(arr1, arr2){ 
 if( (arr1.length > 0) && (arr2.length > 0) ){ 
 if(arr1[0] < arr2[0])
 return [arr1[0]].concat( merge(arr1.slice(1), arr2) )
 else
 return [arr2[0]].concat( merge(arr1, arr2.slice(1)) )
 } else { 
 return arr1.concat(arr2)
 }
 }
 
 function sort(arr){ 
 if(arr.length < 2)
 return arr
 return merge( sort( arr.slice( Math.floor( arr.length / 2 ) ) ), sort( arr.slice( 0, Math.floor( arr.length / 2 ) ) ) ) 
 }
 
 console.log(sort([4, 3, 2, 1, 5]))
====Primes #2====
 function run(arr, size){
 function init(){ 
 arr.push([])
 arr.push([])
 while(arr[0].length < size){
 arr[0].push(0)
 }
 }
 
 function set(pos, value){ 
 while(arr[0].length > (pos + 1))
 arr[1].push(arr[0].pop())
 
 arr[0].pop()
 arr[0].push(value)
 
 while(arr[1].length > 0) 
 arr[0].push(arr[1].pop())
 }
 
 function get(pos){ 
 return arr[0][pos] 
 }
 
 init()
 
 function isPrime(x){ 
 set(1, 2)
 while(get(1) < x){ 
 if(x % get(1) == 0)
 return false
 set(1, get(1) + 1)
 }
 return true
 }
 
 for(set(0, 2); get(0) < 30; set(0, get(0)+1 )){ 
 if(isPrime(get(0)))
 console.log(get(0))
 }
 
 } 
 
 run([], 10)
====Quine====
 ((q,d)=>{console.log(d+q+`',`+q+d+q+`)`)})('"',"((q,d)=>{console.log(d+q+`',`+q+d+q+`)`)})('")
Category:Languages Category:Esoteric subset Category:Turing complete
Assignless

Assignless is a work in progress esoteric programming language by User:Rdococ.
== Overview ==
Assignless is an esoteric programming language without assignments. Rather, you must pass modified values to subroutines.
void loop(int step, int input) {
 printf("Step %d.\n", step);
 if(step < input)
 loop(step + 1, input); # We (automatic) return here to take advantage of tail call optimization.
}
int main() {
 loop(1, inputf("How many steps?: %d\n")); # yep, this is input.
 return 0;
}
This program lists all of the entries in an input array. Note how nowhere is a variable technically assigned by the programmer, not even in a for loop. Rather, each subroutine in the program must pass modified values onto another subroutine in order to assign variables - perhaps using some form of recursion, too. This is the basic premise of the language.
Category:Languages Category:Unimplemented
Astridec

Astridec is a programming language created by User:PixelatedStarfish. It is designed for Starstuff, such that any sequence of characters can be converted to runnable Astridec code. Astridec is designed to be extremely simple, with 10 instructions and virtually no errors. It is very similar to bf; memory is stored as bytes on a circular, unbounded tape (similar to a deque). Bytes wrap around such that all values must be between 0 and 255 inclusive.
To clarify, the tape is initially at a size of 64 cells. Incrementing to cells 65 and beyond extends the length of the tape. Decrementing to cell -1 causes the pointer to jump to the highest cell on the tape.
==Commands==
 
Command 	Desc.
0 	Set cell to 0
1 	Add one to byte
2 	Subtract one from byte
3 	Increment cell pointer
4 	Decrement cell pointer
5 	If cell is 0, go to previous 5, or to start if there is no previous 5.
6 	If cell is 0, go to next 6, or to end if there is no next 6 (halt).
7 	Take input as an ASCII character
8 	Print ASCII char
9 	Halt
*comment*	A comment
==Program Examples==
===Hello World===
 11111111111111111111111111111111111111111111111111111111111111111111111183 *H*
 11111111111111111111111111111111111111111111111111111111111111111111183 *E*
 111111111111111111111111111111111111111111111111111111111111111111111111111183 *L*
 111111111111111111111111111111111111111111111111111111111111111111111111111183 *L*
 111111111111111111111111111111111111111111111111111111111111111111111111111111183 *O*
 1111111111111111111111111111111183 * * 
 11111111111111111111111111111111111111111111111111111111111111111111111111111111111111183 *W*
 111111111111111111111111111111111111111111111111111111111111111111111111111111183 *O*
 111111111111111111111111111111111111111111111111111111111111111111111111111111111183 *R*
 111111111111111111111111111111111111111111111111111111111111111111111111111183 *L*
 1111111111111111111111111111111111111111111111111111111111111111111183 *D*
 *the newlines are not required*
===Truth Machine===
 72222222222222222222222222222222222222222222222226
 501111111111111111111111111111111111111111111111111805
 601111111111111111111111111111111111111111111111118
 *prints '0' if input is '0', prints '1' forever otherwise. Newlines not required*
===Cat===
 78
==External Links==
*Java Interpreter
*Online Java Interpreter
Category:Languages Category:2021 Category:Implemented Category:Cell-based Category:Turing complete