nyuuzyou/wikis huggingface dataset:
AAAAAAAAAAAAAAaaaaaaaaaEEEEEEEaaaaaaaaaaaa

AAAAAAAAAAAAAAaaaaaaaaaEEEEEEEaaaaaaaaaaaa is a joke programming language created by User:Linker-Error. It consists of a 999 character program and a 26 byte memory tape. Each byte in the 26 byte tape can be referred to individually by an instruction.
== Instructions ==
==== Single-Character: ====
# Capital Letter: Increments tape[letter]
# Lowercase Letter: Decrements tape[letter]
==== Multi-Character: ====
Let a represent the second character of the command, whatever it is.
# `a: Take single-character input and store it in tape[a].
# _a: Output the ascii value of tape[a].
# ^a: If tape[a] is equal to zero jump to another part of the program in some sort of orderly fashion that User:Linker-Error has forgotten the details to, and is definitely not the result of a bug that User:Linker-Error was too lazy to fix.
== Funny (Totally Intended) Quirks ==
* After the execution of a multi-character instruction, the second character will still be interpreted as a single-character instruction.
* If a single-character instruction isn't a letter and has an ASCII value greater than 122, it will write to a location out of bounds of the memory tape.
* If a program is longer than 999 characters it will lead to undefined behaviour with (and possibly crashing of) the interpreter.
* "AAAAAAAAAAAAAAaaaaaaaaaEEEEEEEaaaaaaaaaaaa" is a valid program in AAAAAAAAAAAAAAaaaaaaaaaEEEEEEEaaaaaaaaaaaa that will not lead to undefined behaviour but will do nothing.
* In the process of programming the interpreter, User:Linker-Error's finger slipped and they deleted all unneccessary whitespace, renamed all the variables to one character names, defined a macro that set "E" to be interpreted as "else if" in the compiler. Doing so, User:Linker-Error accidentally obfuscated their code.
== Hello World Program ==
The following produces a Hello World program in AAAAAAAAAAAAAAaaaaaaaaaEEEEEEEaaaaaaaaaaaa:
"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK_A_B_C_D_E_F_G_H_I_J_K"
AAAAAAAAAAAAAAaaaaaaaaaEEEEEEEaaaaaaaaaaaa Source

#include <stdio.h>
 #define E else if
 int main(){int c,d,i,e=0;char b[1000],a[26]={0};gets(b);for(i=0;b[i]>0;++i){c=b[i];d=b[i
 +1];if(e){if(c>93){--e;++i;continue;}if(d==0)b[i]=-1;}if(c
 >96)a[c-97]--;E(c>95)a[d-65]=getchar();E(c> 
 94)putchar(a[d-65]);E(c>93&&a[d-65]==0)e=1;E(c>64)a[c-65]++;}}
Category:Implementations
AAEEEEEEEEEI

AAEEEEEEEEEI [a:ee:e'] is an esolang dedicated to be stupid as a brick and also un-implementable. It exists solely to cause brain damage for people stupid enough to philosophize about it.
=Overview=
The language is procedural-functional and object-oriented at the same time. It is partially compiled before execution.
The language is compromised of two parts, which share some of the same vocabulary and logic, but not all. During execution, the language uses internal machine language to communicate with itself.
==Emergent Field==
This is a file describing a root access to any part of the OS as an address format. During execution, you can rewrite the text file to dynamically change the emergent field's emergent addresses. The code written in an emergent field matches to a style of surreal regex.
Take note that emergent field is the only way to access information and it has to be constantly updated to keep the program flow.
==Function Space==
This is an abstract file containing abstract control flow. Function space will be used to both change current emergent field and functional spaces while applying data to the Heart Furnace. The code used for function space is a declarative, abstract notation which borrows part of its vocabulary through the emergent field's usage. 
It is the main operative part of the language and has to be compiled before run.
==The Heart Furnace==
Heart furnace is an abstract subthread running during program execution. It allows for specific inputs and outputs, being extremely fast and concurrent to the other control flow. One example of input-output is xor, which takes up to 64 inputs and at once lays out the answers in corresponding 64 outputs. The programmer has to memorize the logic behind the system, since it is arbitrarily defined.
Whenever any change exists between function and emergent field spaces, a neutral feedback response will happen by itself at heart furnace. This can be used for extra control flow, like error catching.
Finally, heart furnace has special exit-inputs to modify the code of emergent field and function space.
==The internal language==
The language uses, for sake of security, machine-generated Subleq for its internal machine code which runs in assembly level. Because of this, the program's content is nearly impossible to track.
=Usage=
The user creates files for both emergent field and function space. Then they script in duals, adding emergent field instructions and defining control flow in function spaces. When ready to execute, one runs the function space in compiler and then runs it. If there are multiple ones, one runs the function space that is chronologically first in execution.
Category:Usability unknownCategory:Joke languagesCategory:2020Category:Concurrent programming
Category:Languages
ABC

:Not to be confused with tom7's ABC (compiler), AlPhAbEt, nor Abc.
ABC is an esoteric programming language created by User:Orange. The language is very simple and easy to implement. This language has nothing to do with the real programming language ABC.
==Instructions==
 a - Increment the accumulator
 b - Decrement the accumulator
 c - Output the accumulator
 
 d - Invert accumulator
 r - Set accumulator to a random number between 0 and accumulator
 n - Set accumulator to 0
 
 $ - Toggle ASCII output mode. When on, the c instruction prints the accumulator as an ASCII character.
 l - Loop back to the beginning of the program. Accumulator and ASCII mode does not reset.
 ; - Debug. Prints out accumulator as a number and ascii character.
Unknown instructions are treated as NOPs.
==Examples==
===Print out 1337===
 acaaccaaaac
===Simulate a dice throw===
 aaaaarac
===Random phone number generator===
 ac
 
 naaaaaaaaradc
 naaaaaaaaarc
 naaaaaaaaarc
 
 naaaaaaaaradc
 naaaaaaaaarc
 naaaaaaaaarc
 
 naaaaaaaaradc
 naaaaaaaaarc
 naaaaaaaaarc
 naaaaaaaaarc
===Hello World===
 $aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaacaaaaaa
 aaaaaaaaaaaaaaaaaaaaaaacaaaaaaaccaaacnaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
 aacbbbbbbbbbbbbcaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaacaaaaaaaa
 aaaaaaaaaaaaaaaacaaacbbbbbbcbbbbbbbbcnaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaac
===Count infinitely===
 acl
===Beep infinitely using ASCII code 7 (bell)===
 aaaaaaa$cn$l
==Resources==
===Interpreters===
====Java====
 public class ABC{
 public static void interpreter(String code){
 int acc=0;
 boolean stringMode=false;
 for(int i=0;i<code.length();i++){
 switch(code.charAt(i)){
 case'a':++acc;break;
 case'b':--acc;break;
 case'c':if(stringMode)System.out.print((char)acc);
 else System.out.print(acc);
 break;
 case'd':acc*=-1;break;
 case'r':acc=(int)Math.floor(Math.random()*(acc+1));break;
 case'n':acc=0;break;
 case'$':stringMode=(stringMode==false)?true:false;break;
 case'l':i=-1;break;
 case';':System.out.print(acc+" "+(char)acc);
 }
 }
 }
 }
==== Python ====
 import sys
 import random
 
 prog = """
 aaaaarac
 """
 
 acc = 0
 pc = 0
 ascii_mode = False
 while True:
 if prog[pc] == 'a':
 acc += 1
 elif prog[pc] == 'b':
 acc -= 1
 elif prog[pc] == 'c':
 if ascii_mode:
 sys.stdout.write(chr(acc))
 else:
 sys.stdout.write(str(acc) + ' ')
 elif prog[pc] == 'd':
 acc *= -1
 elif prog[pc] == 'r':
 acc = random.randrange(0, acc)
 elif prog[pc] == 'n':
 acc = 0
 elif prog[pc] == '$':
 ascii_mode = not ascii_mode
 elif prog[pc] == 'l':
 pc = 0
 elif prog[pc] == ';':
 print(acc, chr(acc))
 pc += 1
 if pc == len(prog):
 sys.stdout.write('\n')
 break
====External Interpreters====
* ABC in PHP 
* ABC in Python 
* ABC in Java 
* ABC in scheme 
===Discussions===
* Talk for ABC 
* Thread about ABC on 4chans /prog/ text board. Contains many implementations, including the above Algorithmic Language implementation. 
Category:Languages
Category:2008
Category:Implemented
Category:Unusable for programming
ABCD

ABCD is an esoteric programming language made by user:Billlam. It's unusable for programming and it's totally Turing incomplete. 
Every program has one and only one cell to do anything with.
== Basic Commands ==
Cmd	Description
A 	Cell = Cell + 1
B 	Cell = Cell - 1
C 	Input to cell
D 	Output cell
== Examples ==
For readability, the programs are padded to 64-character rows.
===Cat program===
There's no loop instruction here, to write a CAT program you must write something like this:
 CDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCD
 CDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCD
 CDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCD
 CDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCD
 ...
===Output Example===
It's too hard to write a program that outputs a loooooong string (The coding will drive you crazy.) so the example just output FUCK to the console.
 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
 AAAAAADAAAAAAAAAAAAAAADBBBBBBBBBBBBBBBBBBDAAAAAAAAD
===Hello, World!===
Unless you know how to autogenerate programs, that is.
 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
 AAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAADDAAADBBBBBBBBBBBB
 BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBDBBBBBBBB
 BBBBDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAA
 AAAAAAAAAAAAAAAAAAAAADAAADBBBBBBDBBBBBBBBDBBBBBBBBBBBBBBBBBBBBBB
 BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBDBBBBBBBBBBBBBBBBBB
 BBBBBD
==Interpreter==
Here is an interpreter written in C#. The program is the first line of input. If you pass the -g parameter followed by a string, it will generate a program to output that string.
 using System;
 using System.Linq;
 
 class ABCD
 {
 static void Main(string[] args)
 {
 char c = '\0';
 if (args.Length > 1 && args[0] == "-g")
 {
 string gen = String.Join(" ", args.Skip(1));
 for (int i = 0; i < gen.Length; i++)
 {
 if (gen[i] > c)
 Console.Write(new String('A', (int)(gen[i] - c)));
 else
 Console.Write(new String('B', (int)(c - gen[i])));
 c = gen[i];
 Console.Write('D');
 }
 return;
 }
 string prog = Console.ReadLine();
 for (int i = 0; i < prog.Length; i++)
 switch (prog[i])
 {
 case 'A':
 c++;
 break;
 case 'B':
 c--;
 break;
 case 'C':
 c = (char)Console.Read();
 break;
 case 'D':
 Console.Write(c);
 break;
 }
 }
 }
==See also==
* ABCDE
Category:Languages
Category:Joke languages
Category:Unusable for programming
Category:Implemented
Category:2011
Category:Total
ABCDE

ABCDE is a Turing complete extension to ABCD made by User:CodeLongAndProsper90.
==Extra commands==
Name	Function
E 	Marks the beginning of a loop
F 	Jumps back to the next E if the current cell is not zero
G 	Moves the tape up by one
H 	Moves the tape down by one
ABCDE is Turing complete since it can be compiled to Brainf*** trivially.
=== Cat ===
 AEGDCHF
=== Hello world ===
 AAAAAAAAEGAAAAEGAAGAAAGAAAGAHHHHBGGAGAGBGGAEHGHBGGGCGBBBCAAAAAAACCAAACGGCHBCHCAAACBBBBBBCBBBBBBBBCGGACGAAC
=== Long output ===
Unlike ABCD, ABCDE can do string output easier if you can factor.
== Compiler == 
An ABCDE to BrainF compiler can be written in 4 lines:
 import sys
 with open(sys.argv[1]) as input, open(sys.argv[2], 'w') as output:
 code = input.read()
 code = code.replace('A', '+').replace('B', '-').replace('C', '.').replace('D',',').replace('E', '[').replace('F',']').replace('G', '>').replace('H', '<')
 output.write(code)
==See also==
* ABCD
Category:Languages
Category:2020
Category:Turing complete
Category:Implemented
ABCDXYZ/Python interpreter

:
The esolang ABCDXYZ had no real interpreter before 2024 (previous implementations were all transpilers to another language). As such, User:None1 created the first real interpreter for ABCDXYZ on June 15th 2024. It is written in Python. (Due to Python's recursion limit, the call stack cannot be longer than 1000, you can change the recursion limit using sys.setrecursionlimit), you can also see this program at Pastebin.
# First real interpreter for ABCDXYZ, in Python, by User:None1
# Usage: python abcdxyz.py <filename>
import sys
call_stack=[]
objects=[]
class ABCDXYZ:
 data=0
 def __init__(self,event,num):
 self.event,self.num=event,num
 def x(self,num):
 t=objects[num].data
 objects[num].data=[1,2,3,0][objects[num].data]
 if t==1:
 objects[num].fire()
 def y(self,num):
 t=objects[num].data
 objects[num].data=[1,2,3,0][objects[num].data]
 if t==2:
 objects[num].fire()
 def z(self,num):
 if objects[num].data:
 objects[num].data=[0,3,1,2][objects[num].data]
 def fire(self):
 global call_stack
 if self.num in call_stack:
 raise RecursionError('Recursion is forbidden')
 call_stack.append(self.num)
 for i in self.event:
 if i[0]=='"':
 if len(i)!=2 or i[1] not in '0123456789N':
 raise SyntaxError('" must be followed by digits or N')
 else:
 print('\n' if i[1]=='N' else i[1],end=)
 elif i[0]=='X':
 try:
 num=int(i[1])
 except:
 raise SyntaxError('X must be followed by a number')
 else:
 self.x(num)
 elif i[0]=='Y':
 try:
 num=int(i[1])
 except:
 raise SyntaxError('Y must be followed by a number')
 else:
 self.y(num)
 elif i[0]=='Z':
 try:
 num=int(i[1])
 except:
 raise SyntaxError('Z must be followed by a number')
 else:
 self.z(num)
 else:
 raise SyntaxError('Unknown command: {}'.format(i))
 call_stack.pop()
with open(sys.argv[1],'r') as f:
 c=f.read().split()
n=0
e=[]
if c[0]!=str(n)+':':
 SyntaxError('Cannot find object 0')
del c[0]
while c:
 n+=1
 while c and c[0]!=str(n)+':':
 e.append(c[0])
 del c[0]
 if c:
 del c[0]
 objects.append(ABCDXYZ(e,n-1))
 e=[]
objects[0].fire()
Looks very object oriented, doesn't it?
Category:Implementations
ABCDirection

ABCDirection is a 2 dimensional esolang by User:BoundedBeans.
==Instructions==
A	Turn right.
B	No-op.
C	Execute a command depending on the direction.
* right: Move pointer left.
* left: Move pointer right and flip the bit.
* up: If the value at the pointer is 1, turn left. Otherwise, go straight.
* down: Output like in Boolfuck.
D	Execute a command depending on the direction.
* right: Enqueue the current cell into the queue.
* left: Dequeue the current cell from the queue.
* up: Input the current cell like in Boolfuck.
* down: If the value at the pointer is 1, set direction to down. Otherwise, dequeue a value from the queue. If the front of the queue is 1 and the cell is 0, set direction to up. Otherwise, if the front of the queue and the cell are both zero, dequeue another value from the queue. If the value dequeued is 0, set direction to left. If the value dequeued is 1, set direction to right.
The pointer starts at the top left, and starts by going downwards.
Note there can be no spaces in the code, other than after a line with six consecutive D’s, B should be used instead.
After the file reader reads 6 consecutive D’s in one line of code, from left to right, it reads the rest of the line, then stops. If you need to use D six times in a row more than once on different lines horizontally, use B to separate it.
The file reader needs to be stopped like this (6 D’s are required). Since it has stopped reading the file, anything can be written afterwards. This is a comment mechanism.
Category:Languages
Category:Unknown computational class
Category:Unimplemented
Category:Two-dimensional languages
Category:Queue-based
Category:Cell-based
ABCDirectionE

ABCDirectionE is an esolang by User:BoundedBeans. It's identical to ABCDirection, but with an extra command allowing self-modifying. It also has the extra restriction that the code should be a power of two in size in both directions, or the E command will just act like B. 
==6 D's==
The rule of having 6 consecutive D's to be included the last line in the program is still in effect, meaning that the program must always be at least 8 cells in width if you want to use the E command. The line with the D's counts as a line towards the power of two. The D's can also be modified out of the program, unlike with plain ABCDirection. This doesn't expand the field, since the D's are just a read-time construct.
==The E command==
Execute differently depending on the direction:
* Right: Dequeue enough values within the queue to reach anywhere in the x axis bounds of the program in binary, do it again for the y axis, and increment the letter contained within, E becoming A.
* Left: Do the same dequeue thing (don't modify the code), and then enqueue:
** 1 if the cell is A
** 11 if the cell is B
** 111 if the cell is C
** 1111 if the cell is D
** 11111 if the cell is E
** Note: If you want to tell which one it is, it's probably a good idea to enqueue a zero afterwards (you'll have to do that manually).
* Up: Change direction based on the cell above.
** A or B: Right
** C or D: Left
** E: Keep going up, then execute this same command. (So keep going up until the command is not E).
* Down: Reset the board to its original state.
Category:Languages
Category:Two-dimensional languages
Category:Unknown computational class
Category:Unimplemented
Category:Self-modifying
ABCR

ABCR is a queue-based programming language created by Steven Hewitt.Github repo It uses three FIFO queues known as A, B, and C that store unbounded integer values, as well as a single register R that stores the result of the last operation. Most of the commands have a different symbol for each of the three queues, and each queue serves a slightly different function.
==Commands==
Commands that do not have a register-variant (R-variant)	Commands that do not have a register-variant (R-variant)	Commands that do not have a register-variant (R-variant)	Commands that do not have a register-variant (R-variant)	Commands that do not have a register-variant (R-variant)
A-variant 	B-variant 	C-variant 	R-variant 	Description
a 	b 	c 	 	Dequeues a single value into R from the given queue.
A 	B 	C 	 	Enqueues a single value from R into the given queue.
1 	2 	3 	 	Peeks, or copies the front of, the given queue into R.
! 	@ 	# 	 	Sets R to the length of the given queue.
* 	+ 	, 	 	Dequeues a single value, adding it to R's current value.
- 	. 	/ 	 	Dequeues a single value, subtracting it from R's current value.
o 	p 	q 	 	Peeks at the front of the queue to print it as a number.
O 	P 	Q 	 	Peeks at the front of the queue to print it as a character.
Commands that have an R-variant 	Commands that have an R-variant 	Commands that have an R-variant 	Commands that have an R-variant 	Commands that have an R-variant
4 	5 	6 	7 	Loop start; jumps in front of the matching mark if the front of the queue (or, in the case of R, the register value) is zero.
x 	x 	x 	x 	A mark; unconditionally leaps back to execute its matching loop start.
 	 	 	( 	Decrements the register value by 1.
 	 	 	) 	Increments the register value by 1.
 	 	 	i 	Accepts a signed number from input.
=== Queue defaults ===
When an empty queue is peeked or popped, its behavior will differ based on which queue it is:
* A defaults to 0 for both popping and peeking.
* B defaults to 1 for both popping and peeking.
* C defaults to grabbing the character code of the next input character (the rest of which, of course, are queued if more than one input character is given) if popped, or to the current register value if peeked. 
Popping from an empty C-queue is the only way to input characters.
== Examples ==
===Hello, world!===
 ))))))))))AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
 (((((BBBBBBBBB
 ******+))C
 ***(C
 +))C
 C
 )))C
 -------..)C
 ********+))C
 .(((C
 )))C
 .(C
 .(((C
 ------.((C
 aC6Qcx
Output:
 Hello world!
===Cat program===
 cC6QcCx
===Truth-machine===
 iA4oxo
== References ==
==External resources==
* Github repo
Category:Implemented
Category:Queue-based
Category:Languages
Category:2016
ABC (compiler)

ABC is a compiler to an esoteric language by Tom Murphy VII (tom7), published on 2017-03 for the SIGBOVIK 2017 eso-conference. 
The compiler outputs such DOS EXE executables that contain only printable ASCII characters, don't modify their own code in memory while running, and only execute instructions made of only printable ASCII characters. The compiler inputs C with some reasonable restrictions. IO access of the program is very limited. 
The conference paper is plain ASCII text without newlines printed 160 characters per column, and that text is the executable of an example program created by the compiler. 
== Challenges ==
One of the biggest challenges faced by the all-ASCII restriction is that the program cannot execute any jump backward, and cannot jump forward more than 127 bytes at a time. Thus an executable output by ABC just keeps looping around its 64 kilobyte long code segment, hopping over parts of the code it doesn't need.
== Links ==
* ABC homepage
* Printed form of the paper “ZM~~ # PRinty# C with ABC! ”
* Raw executable form of the paper
* Compiler source code
* Tom's blog post (see top entry on page)
* Tom's video explaining the paper
* SIGBOVIK 2017 proceedings
Category:Proofs Category:Implementations
ABCs

ABCs is an esoteric programming language created by User:paul2520 in 2015. It uses the letters of the alphabet as commands.
== History ==
ABCs was created in 2015 as a language that would enable works of literature such as poems or books to be executed. More realistically, English phrases can be written that would execute meaningful combinations of instructions. 
Initially, this language was designed to be an acrostic, where each command stood for a word or phrase describing what it does. This is true for some of the commands.
The goal for implementations is to allow programs to do multiple things if the set of instructions are changed. The user may specify lower (default) or upper-case letters to be interpreted. The user may alternatively change which commands are used by passing in a string of characters of length 26. In this way, programs can be obscured if the command list is not given. Also this means that one code listing may be able to do many different things by changing the input set of commands.
== Specification and Instruction list ==
The default instruction list is as follows. All other characters are ignored.
 a adds the numeric value of the next valid character to the accumulator
 b subtracts the numeric value of the next valid character from the accumulator
 c clears the accumulator
 d deletes current item in queue
 e empty (prints the current value in the queue and sets it to zero)
 f function; the next valid character is the name of the function
 g execute function where the name is the next valid character
 h hold (pause)
 i input value and store at end of queue
 j jump to k
 k location for jump to land
 l load value from queue to accumulator
 m multiplies accumulator with next element in queue
 n move to next element in queue
 o move to previous element in queue
 p move to top of queue
 q query user "?" --> enter y or n; branch to r or s, respectively
 r label for y
 s label for n
 t test if value in accumulator is 0 or 1; branch to u or v, respectively
 u branch for 0
 v branch for 1
 w while queue not empty, run commands up to next 'x'
 x jump back to w
 y "yell" --> print numeric value in accumulator to screen
 z zero out current element in queue
For interpreter implementations, the user may switch the instruction set of "abcdefghijklmnopqrstuvwxyz" with a 26-character array of their choosing.
== Examples ==
=== Hello world ===
 aheaeealealeaoeaqaqbabaeaweaoearealeade
== External resources ==
* Interpreter (in progress) written in C.
Category:2015‏‎
Category:Implemented
Category:Languages