nyuuzyou/wikis huggingface dataset:
AmBored--

AmBored-- is an esoteric language written by Is this the Krusty Krab. It is a Brainfuck derivative written in C++ which adds more commands and features very primitive graphics. It was named so due to the fact that I am bored, so I am making this for fun, and because it has less features than AmBored.
== Features ==
AmBored-- has an array the size of 64 by 64 cells, each cell represents a color.
Another feature of AmBored is a stack, which operates like a normal stack you probably studied in school, college, or your room at night instead of sleeping. The stack's size is 16.
== Syntax ==
The syntax is similar to Brainfuck syntax, with a few changes and additions.
CMD	Description
> 	Move the memory pointer right
< 	Move the memory pointer left
V 	Move the memory pointer down
^ 	Move the memory pointer up
* 	Change the pointed cell's color
+ 	Set the pointed cell to white
[ 	Jump past the matching ] if the pointed cell is 0 (black)
] 	Jump back to the matching [ if the pointed cell is nonzero (not black)
, 	Input a number and write the LSB to the pointed cell
. 	Refresh the screen
( 	Push the value of the pointed cell to the stack
) 	Pop the top value of the stack to the pointed cell
== Interface ==
As mentioned, the output is a screen of pixels, each with the color stored in them. There is also a command to refresh the screen. This is because the screen needs to be refreshed manually, to prevent the user from seeing the whole process of changing the frame.
Why? Because I said so.
The colors that can be represented by the pixels are white and black. Again, less than in AmBored.
==See also==
*AmBored
*AmBored++
Category:Languages
Category:Brainfuck derivatives
Category:Two-dimensional languages
Category:Stack-based
Category:Unimplemented
Category:Turing complete
Category:2018
Category:Graphical Output
Amnesia

Amnesia is an esoteric programming language created by User:Padarom in 2014. It is inspired by Malbolge and tries to be extremely hard to understand and to program with, though to be possible.
This page is under construction and details are being added while descriptions about the language are written.
==Overview==
The basic principle of Amnesia is, that every character in its code only represent its ASCII-code (which changes depending on the position within the program and the length of the programs code). Thus numbers don't represent their values, but instead they represent the result of a weird calculation ("Number transform"). Every character in ASCII between the decimal value of 32 and 126 is usable.
An Amnesia-program contains three stacks: A, B and C
=== Instructions ===
Character(s)	Decimal 	Description
cho_ 	99 104 111 	Select the provided stack (the one that replaces the underscore _)
= 	61 	Set the value of the selected stack to the value behind
+ 	43 	Adds the number in stack B with to number in stack A
- 	45 	Subtracts the number in stack B from the number in stack A
/ 	47 	Divides the number in stack A by the number in stack B
* 	42 	Multiplies the numbers in stack A and stack B
% 	37 	Performs a modulo-operation of stack A with stack B (A mod B)
Nm 	78 109 	If the value of the selected stack (A, B or C) is not equal to zero
: 	58 	The same as an opening bracket (Amnesia doesn't differentiate between the normal ( and { )
; 	59 	The same as a closing bracket (Amnesia doesn't differentiate between the normal ) and } )
disp 	100 105 115 112	Display the value of the currently selected stack
==Examples==
The following program is written using the standard characters, thus not taking the transform into account
 choA=BchoB=B*
The same program, written using the Transform function
 pucwovcjtny!p
==Interpreter==
An interpreter for Amnesia has yet to be written. I will be really happy if someone creates one before me.
Category:Languages
Category:Unimplemented
Category:2014
Category:No IO
Amo gus

Amo gus is a programming challenge created by user:tommyaweosme for meow.
== What it is? ==
An amo gus program does this:
* asks for input
* returns "gus" if input is "amo"
* returns "amo" if input is "gus"
* otherwise, do nothing
For programs like brainfuck, amo can be shortened into a, and gus can be shortned into g.
==Implementations==
=== dolfins grace ===
 >?99999999997++++++++++-\
 <^^^"amo"!/
 \"sug"^^^<
===///===
/amo/GUS//gus/AMO/
Category:2024Category:Program_forms
===DUP===
```111=[103,117,115,][97,109,111,]?
===Batch===
@echo off
set /p amogus=Input? 
if %amogus% EQU amo echo gus
if %amogus% EQU gus echo amo
pause>nul
===Wasaya Lua dialect===
a = io.read()
if a == "amo" then
 print("gus")
elseif a == "gus" then
 print("amo")
else
 print("")
end
This is also a Polyglot -- It works in Lua, too.
===Zyxonia(Non-documented)===
ENV <- System
do Main
OFFCMD
LET S <- INPUT("Input: ")
IF(S="amo"){PRINT "gus"}ELIF(S="gus"){PRINT "amo"}ELSE{NOP}
INPUT("Press any key to continue......")
end
Amycus Severus

Amycus Severus is a Turing-complete functional programming language that is a restricted variant of Amycus. Amycus is an esoteric programming language that was born from a misunderstanding by User:b_jonas over an esoteric programming language Amicus by David Madore.
== Definition ==
A value in Amycus Severus is either a natural number of unbounded size, or a finite size list of Amycus Severus values. Lists are written as <x1, …, xn> where n is a natural number, and x1, … xn are values. (You could think of Amycus Severus values as binary trees with a natural number in each leaf. A list can contain numbers or lists, or the two mixed. Amycus Severus cannot create circular or infinite lists.)
Amycus Severus programs are list values whose head is an opcode number. Amycus Severus takes such a program, and a single input argument which is an Amycus Severus value (number or list), and gives an Amycus Severus value as the result. Evaluation is defined by the following recursive definition, where E(p, x) = y means that the program p on the input x evaluates to the value y. 
;Rule 0. :E(<0>, v) = v
;Rule 1. :E(<1, c>, v) = c
;Rule 2. :E(<2>, <n: r>) = 1 + n
;Rule 3. :E(<3, n>, <v1, …, vn>) = vn, provided 0 < n
;Rule 4. :E(<4>, <m, n, u, v>) = (if m == n then u else v) provided m, n are both natural numbers
;Rule 5. :E(<5, q, p1, …, pn>, x) = E(q, <E(p1, x), …, E(pn, x)>)
;Rule 6. :E(<6>, <h, v>) = E(h, v)
== Notes ==
* Amycus Severus is a restricted version of Amycus. Any Amycus Severus program is also a valid Amycus program, and if evaluating Amycus Severus is defined on a program and an input, then evaluating it as an Amycus program is also defined and has the same result. 
* Amycus Severus is Turing-equivalent. It can read and write any natural number, so it can compute any computable function from natural numbers to natural numbers. 
* You can prove this by translating multivariate lambda calculus expressions and Peano arithmetic to Amycus, as outlined in the Amycus article. All of that translation works unchanged in Amycus Severus.
* Amycus Severus, however, cannot read or write arbitrary lists. Any Amycus Severus program can create lists of only a bounded size, can read only the first bounded number of elements of lists, and there are further restrictions on how it can access lists.
* David doesn't give a name for this language, so User:B_jonas gave the name “Amycus Severus”. 
Category:LanguagesCategory:Turing completeCategory:Functional paradigmCategory:2015Category:No IOCategory:Implemented
An Odd Rewriting System/Odd.hs

This is an implementation, written in Haskell by Chris Pressey, of An Odd Rewriting System. It is only a partial implementation, because it doesn't implement parsing or the halting symbol.
import Data.Char
data Defn = Defn {
 symbol :: Char,
 oddDefn :: String,
 evenDefn :: String
} deriving (Show)
data Program = Program {
 defns :: [Defn],
 initial :: String
} deriving (Show)
isOdd = isUpper
isEven = isLower
findDefn char defnGetter [] = error "No such defn"
findDefn char defnGetter (defn:defns) =
 if symbol defn == char then defnGetter defn else findDefn char defnGetter defns
run program = evolve (initial program) (defns program)
evolve dataString defns =
 let
 dataString' = step dataString defns
 in
 [dataString] ++ evolve dataString' defns
step dataString defns =
 let
 (transformedSymbols, _) = foldl (transformSymbol) ([],0) dataString
 in
 concat transformedSymbols
 where
 transformSymbol (newElems, numSeenOddSymbols) char =
 let
 defnGetter = if numSeenOddSymbols `mod` 2 == 0 then evenDefn else oddDefn
 replacement = findDefn char defnGetter defns
 numSeenOddSymbols' = numSeenOddSymbols + if isOdd char then 1 else 0
 in
 (newElems ++ [replacement], numSeenOddSymbols')
To show that this implements the semantics of An Odd Rewriting System you can write something like
testProg1 = Program{
 initial = "Cwg",
 defns = [
 Defn{ symbol='c', evenDefn="c", oddDefn="C" },
 Defn{ symbol='C', evenDefn="C", oddDefn="c" },
 Defn{ symbol='g', evenDefn="wg",oddDefn="wg" },
 Defn{ symbol='w', evenDefn="w", oddDefn="C" }
 ]
}
test1 = take 20 (run testProg1)
Category:Implementations
An Odd Rewriting System/odd.rs

rust interpreter by User:Pro465. invoke as rustc odd.rs && ./odd filename [max_cycles] where the optional max_cycles argument specifies maximum number of cycles to execute
use std::collections::HashMap;
use std::fs;
fn main() {
 let mut args = std::env::args();
 let prog = fs::read_to_string(
 fs::canonicalize(args.nth(1).unwrap_or_else(|| help()))
 .expect("could not canonicalize argument"),
 )
 .expect("could not read file");
 let mut state = State::parse(&prog);
 let lim = args.next().map(|n| n.parse().unwrap_or_else(|_| help()));
 if let Some(lim) = lim {
 for _ in 0..=lim {
 println!("{}", state.step());
 }
 } else {
 loop {
 println!("{}", state.step());
 }
 }
}
fn help() -> ! {
 println!(
 "usage: {} <filename> [max_iter]",
 std::env::current_exe()
 .unwrap_or_else(|_| "aors".into())
 .display()
 );
 std::process::exit(-1);
}
fn is_valid(x: char) -> bool {
 x.is_uppercase() || x.is_lowercase() || x == '$'
}
struct State<'a> {
 inp: String,
 rules: HashMap<char, [&'a str; 2]>,
}
impl<'a> State<'a> {
 fn parse(prog: &'a str) -> Self {
 let mut iter = prog
 .lines()
 .flat_map(|line| {
 line.split_once('#')
 .map(|i| i.0)
 .unwrap_or(line)
 .split_whitespace()
 })
 .filter(|x| !x.is_empty());
 let inp = iter.next().unwrap().to_string();
 let mut rules = HashMap::<_, [_; 2]>::new();
 for rule in iter {
 let parity = rule.as_bytes()[0];
 assert!((b'0'..=b'1').contains(&parity));
 let (sym, repl) = rule[1..].split_once(':').unwrap();
 let sym = sym.chars().next().unwrap();
 assert!(is_valid(sym));
 assert!(repl.chars().all(is_valid));
 rules.entry(sym).or_default()[(parity - b'0') as usize] = repl
 }
 Self { inp, rules }
 }
 fn step(&mut self) -> String {
 let mut parity = 0;
 let mut res = String::new();
 for c in self.inp.chars() {
 if c == '$' {
 res = String::new();
 break;
 }
 res.push_str(self.rules[&c][parity]);
 parity ^= c.is_uppercase() as usize;
 }
 std::mem::replace(&mut self.inp, res)
 }
}
Category:Implementations
An arch is simply a curve.

An arch is simply a curve., invented by User:A, is a self-modifying Arch-based language where the program itself is an arch. All commands are synonyms of different definitions of the word "Arch". It was partially influenced by Doug's variable structure, and partially influenced by the Arch data structure. It is designed to make programs be very hard to write; you have to eventually execute your data.
==Specification==
A cell in An arch is simply a curve. is 8 bytes, which is possibly specified in the Arch documentation (you can't represent 1.844674407371e+19 values with just one ASCII character anyway). Programs in An arch is simply a curve. will not halt.
An An arch is simply a curve. program will be run in an implicit infinite loop.
==Instructions==
The instruction counter is always 0, and the program right-shifts by default after a command (code executing backwards, that means you have to write code backwards)
Premier. (Push the value of the period register to the character after this command and shift the program right (avoiding executing that command).)
Primary. (Pop the character after this command and store this value to the register . (that is, the values of the register . represents a different ASCII character.))
Playful. (Move the code cyclically the value of the "." register times right.)
Semicircle. (Split the content of cell 0 into 2 cells with equal length.)
Short forms:
r.
y.
l.
e.
==Self-extending Trivial cyclic execution system==
y.r.
Category:Languages
Category:2019
Category:Unimplemented
An esoteric programming language (ess-oh-terr-ick), or esolang, is a computer programming language designed to experiment with weird ideas, to be hard to program in, or as a joke, rather than for practical use.

An esoteric programming language (ess-oh-terr-ick), or esolang, is a computer programming language designed to experiment with weird ideas, to be hard to program in, or as a joke, rather than for practical use., was created by User:Schmuui in late 2018 and is a direct spin off to ''.
== See also ==
*
Category:Languages Category:2018
An unusable esolang made with an one-line interpreter and a long name

An unusable esolang made with an one-line interpreter and a long name is an unusable esolang made by User:Mario0Fan
Inspired by 25 bytes o:
here's the interpreter in python ig:
 code = input('Enter code:');print(code.replace("An unusable esolang made with an one-line interpreter and a long name", "Unusable"))
It still has a program that lets you print something to the screen, look:
==Unusable program==
this program just prints Unusable to the screen:
 An unusable esolang made with an one-line interpreter and a long name
output:
 Unusable
==Hello world program==
the interpreter just prints out the code of the program but replaces
 An unusable esolang made with an one-line interpreter and a long name
with
 Unusable
so here's the hello world program:
 Hello, world!
output:
 Hello, world!
==Quine==
Because of the nature of this programming language, it is very easy to write a Quine.
 Hello, world!
Category:Languages Category:Unusable for programming Category:Total Category:Output only Category:Implemented
Anarcheat

Anarcheat is an esolang invented by User:A inspired by the limitations of Anarchy golf: there are only 3 possible sample inputs at maximum, and the test cases can only be a finite sequence of a string.
== Syntax ==
An odd line decides what the expected input is, and an even line decides what the corresponding output should be. Programs should be 6 lines at maximum.
== Hello, world! (13 bytes) ==
Hello, world!
This decides whether the input is null, and outputs Hello, world! based on the input. There is also an instruction : meaning that this line should respond to any other input.
== echo (13 bytes) ==
:$
Here $ means the input of the program.
== [golf.shinh.org/p.rb?hello+golfers Hello, golfers!] (? bytes) ==
Anarcheat matches suffixes by default, although a line can be modified to match prefixes.
g
Hello, golfers!
Hello, world!
:Hello, shinichiro.h!
Golfed.
.Hello, 
g
golfers!
world!
:shinichiro.h!
The . instruction outputs until the end of line without a newline.
== Dictionary ==
Anarcheat has a well-thought-out 95-word dictionary designed specifically for Anarchy Golf challenges.
== Digit sum until no change ==
http://golf.shinh.org/p.rb?digit+sum+until+no+change
^0
7@10 1@1@60 6@99 18 9@102 3@103 4@122 5@128 11 2@100 1
^6
124 7@121 4@96 15 6@91 10 1@102 3@113 5@101 2@114 6@131 5@119 11 2
^5
106 7@95 14 5@110 2@97 16 7@114 6@104 5@99 18 9@116 8@135 9@118 10 1
^ is the prefix-completion marker, @ means insert a newline. \ will escape the next marker.
Other than ^ there is also a position-based checker called %. When preceded by a number, it starts its completion in the position specifiedd by the number based on the current completion state.
Further golfed:
^0
7@X 1@1@60 6@99 18 9@X2 3@X3 4@Z2 5@Z8 Y 2@X0 1
^6
Z4 7@Z1 4@96 15 6@91 X 1@X2 3@Y3 5@X1 2@Y4 6@131 5@Y9 Y 2
:X6 7@95 14 5@Y0 2@97 16 7@Y4 6@X4 5@99 18 9@Y6 8@135 9@Y8 X 1
X pushes 10, Y pushes 11, Z pushes 12.
Category:Languages
Anarchysm

The Anarchysm language is based on anarchism, meaning that this language doesn't have rules.
== How to use it ==
The program, of course, has complete free will and can do as it pleases. Programming in Anarchysm is mostly about encouraging it to do what you want.
== Examples ==
=== Hello world ===
If the program wants, the next code will output "Hello, World!".
 please, oh gracious program, output the text "Hello, World!".
=== Cat program ===
If the program wants, the next code will do the cat program.
 copy the input to the output forever, please.
=== 99 Bottles of beer on the wall ===
If the program wants, the next code will output the 99 Bottles of beer song.
 please output the "99 bottles of beer" song.
=== An accurate real life simulator with nice graphics ===
If the program wants, the next code will simulate an accurate real life simulator with nice graphics.
 can you please simulate a universe accurately with graphics? thanks.
== Turing-completeness proof ==
Why this is Turing-complete? Because it can simulate a Turing machine (if it wants to).
=== Source code ===
The next code will simulate a Turing machine (If the program wants)
 Can you simulate a turing machine, please? Thanks!
== Warning ==
This is anarchysm! So, if the program wants to shut down your computer, or install various malware, it will.
== Implementation ==
List of implementations:
*2b2t Minecraft server
Category:Joke languages
Category:2020
Category:Turing complete
Category:Unusable for programming
Category:Zero-dimensional
Category:Languages
And then

And then is like BF, but you need to put " and then" between commands.
=It works like this=
We have our sweet little cute program in BF.
 +>
We add the and thens.
 + and then > and then end.
We add the preamble (does nothing but is required):
 #(lalalagrrrrrrrkaboom)pffffzipcodeadressdenied<[program name], AUTHOR([author all caps])> and then start; define start as this big thing past the colon: + and then > and then end.
Tada! We have our program in and then!
category:Joke languages
category:Brainfuck equivalents
Category:Languages
Andrew's Programming Language

Andrew's Programming Language is a work-in-progress language created by User:Afarnen. It also needs a name (please help; I'm horrible at naming).
==Intro==
Let's create a variable x with a value of 5, you'd write:
 x=5
Now, let's create another variable y:
 y=2*x
In this example, y equals 10. Now what if we updated the value of x:
 x=3.5
Would y update along with x? Yes, y now equals 7. You can implement many simple functions similarly. For example:
 c=(f-32)*5/9
is a simple fahrenheit to celsius convertor. The variable c updates every time f is updated. But what about recursive functions, like the fibonacci function?
 fib(1)=1
 fib(2)=1
 fib(x)=fib(x-2)+fib(x-1)
Since variables cannot recurse, we use actual function notation, in this example to implement the fibonacci function.
Creating an array is simple:
 x=1,2
It's just creating a variable with more than one value, separated by commas. You can perform regular operations on a whole array at a time:
 y=2*x
Each item in the array is operated on separately, and then put back together. In this case, y would equal 2,4. Functions can also perform on arrays:
 fib(5,7)
Since the 5th and 7th fibonacci numbers are 5 and 13 respectively, this example would return 5,13. Now what if our function accepted two arguments, such as a power function:
 power(x,y)=x^y
Function parameters, as well as array items, are separated by commas, so how would we work around this if we wanted to perform the above function on an array? "power(1,2,3,2)" could be interpreted many different ways, so we..
 power((1,2,3),2)
Use parenthesis to distinguish each parameter. Here we're squaring the array 1,2,3, so we get 1,4,9.
== Conclusion ==
It's basically "set-by-name". As far as we know, functions are array transforms.
Category:Languages Category:Unimplemented Category:Unknown computational class Category:2008
Andrew Code

. = low or one tap
 - = high or two tap
== Key ==
 a = .
 b = -
 c = ..
 d = .-
 e = -.
 f = --
 g = ...
 h = ..-
 i = .-.
 j = .--
 k = -..
 l = -.-
 m = --.
 n = ---
 o = ....
 p = ...-
 q = ..-.
 r = ..--
 s = .-..
 t = .-.-
 u = .--.
 v = .---
 w = -...
 x = -..-
 y = -.-.
 z = -.--
 = --..
 . = --.-
 , = ---.
 = ----
Category:Concepts
Andromeda

Andromeda is a two-dimensional, queue-based programming language in which, apart from the usual direction-changing arrows (which also serve additional purposes), there is only one additional command. The language was created and implemented in 2018 by User:ZM.
==Syntax==
Andromeda is a two-dimensional language. It uses a square grid whose top and bottom (but not left or right) are joined together.
The language has five commands: the directional arrows ><^v, which are used for changing the direction of the instruction pointer and pushing items onto the queue, and the question mark ?, which pulls items from the queue and can be used for control flow. Any characters other than the five mentioned are ignored.
The instruction pointer starts at the top left edge of the grid, moving right. Program execution ends when the instruction pointer exits the left or right edge of the grid.
The directional arrows serve two purposes:
* When the instruction pointer hits an arrow which points neither in the same direction or the opposite direction as the instruction pointer, it turns to face the same way as the arrow. 
* If, however, the arrow points the same direction as the instruction pointer, it pushes a 1 onto the queue.
* If the arrow instead points in the opposite direction as the instruction pointer, a 0 is pushed onto the queue.
? pulls the oldest item from the queue. If it is a 1, the instruction pointer is rotated counterclockwise; if it is a 0, the instruction pointer is rotated clockwise.
==Examples==
coming soon
==Computational class==
Andromeda is Turing-complete; the easiest way is probably via cyclic tag, which can be easily translated into Andromeda using the following structure:
(initialization)v>(ones and zeroes translated into > and <)v> v 
 >? >? ... >v
 > ^> ^ 
 ^ <
==Restrictions==
Although Andromeda in its base state is already a rather minimal language, some commands can actually be removed from the language without affecting Turing-completeness. ? can obviously not be removed, lest the language loses its only control flow mechanism. Similarly, one arrow is required to allow for data storage. The author conjectures that this is enough for Turing-completeness, but no formal proof exists.
==Implementation==
An interpreter is available here; it doubles as a simple Andromeda program.
==See also==
* Re:direction
* Nopfunge
Category:2018
Category:Implemented
Category:Languages
Category:No IO
Category:Queue-based
Category:Turing complete
Category:Two-dimensional languages
Angry people outside my house

Angry people outside my house is an esolang created by User:Tommyaweosme
== Commands ==
 HEY! - starts program
 DONT FUCK WITH ME - flips bit
 THIS SHIT WILL GET YOU EVICTED - goes to next cell
 YOU SON OF A BITCH - goes to previous cell
 SHITHEAD LITTLE PUNK - outputs current bit and next 7 bits as ascii
 SHITHEAD - outputs current bit
 *pause to intimidate* - inputs current bit and next 7 bits as ascii
 *pause* - inputs current bit
 PEICE OF SHIT - [
 I CAN GO IN YOUR HOUSE WHENEVER I WANT - ]
== Examples ==
=== Truth Machine ===
 HEY!
 *pause*
 SHITHEAD
 DONT FUCK WITH ME
 PEICE OF SHIT
 DONT FUCK WITH ME
 SHITHEAD
 DONT FUCK WITH ME
 I CAN GO IN YOUR HOUSE WHENEVER I WANT
=== Print "g" ===
 HEY!
 DONT FUCK WITH ME
 THIS SHIT WILL GET YOU EVICTED
 DONT FUCK WITH ME
 THIS SHIT WILL GET YOU EVICTED
 THIS SHIT WILL GET YOU EVICTED
 THIS SHIT WILL GET YOU EVICTED
 DONT FUCK WITH ME
 THIS SHIT WILL GET YOU EVICTED
 DONT FUCK WITH ME
 THIS SHIT WILL GET YOU EVICTED
 DONT FUCK WITH ME
 YOU SON OF A BITCH
 YOU SON OF A BITCH
 YOU SON OF A BITCH
 YOU SON OF A BITCH
 YOU SON OF A BITCH
 YOU SON OF A BITCH
 YOU SON OF A BITCH
 SHITHEAD LITTLE PUNK
== Implementations ==
* Python Interpreter - EOF convention is 0
Category:Languages Category:Pseudonatural Category:Cell-based Category:Turing complete Category:Implemented