nyuuzyou/wikis huggingface dataset:
Array?

Array? is a APL-like language made by User:Ractangle
==Commands==
Command	Action
[...] 	Pushes array contents to the main array
∃...∄ 	Comment
\ 	Allowes the array separator () to be used in the main array without splitting the string
□ 	Takes user input
⌅ 	Double Bitwise not
==Examples==
===Hello, world!===
 [Hello\, world!]
===Cat program===
 □
==Implementation==
Array? folder in Thewierd Repo
Category:LanguagesCategory:2024Category:ImplementedCategory:Stack-based
ArrayFuck

ArrayFuck is a essoteric programing language based on a array
== Overview ==
The base of ArrayFuck is a array of integers on indexes from -32768 to 32767. By default, the array is initialized with the value 1. Each index can store values from -32768 to 32767.
An ArrayFuck program is made up from one assignment.
There are two possible ways to access the array:
- [-]: access the element at the index 0.
- [<expr>]: access the element at the index of the expression.
An expression can be either a access to an array or an assignment to an array.
To assign a value to an array, you can use the following syntax:
 [<expr>] = <expr>
Alternatively, you can use the following syntax:
 [<expr>] - <expr>
Which will subtract the value of the expression from the element at the index of the expression.
If an assignment is used as an expression, the value of the expression will be returned.
If the square brackets are left empty, it will be used as ASCII io.
=== Loops ===
To make a loop, the colon is used.
 <expr>:<assign>
The assignment will be executed until the expression is zero.
If used as an expression, the last value assigned will be returned, unless 
=== Comments ===
All characters except for [, ], `=, - and : are ignored.
== Examples ==
Cat machine:
 [[-]:[] = []] = [-]
Category:2022 Category:Cell-based Category:Implemented Category:Finite state automata
Arraything

Arraything is a programming language created while in class. It uses punctuation symbols, and brackets to program.
 Inside Loop Symbols
Symbols	Explanation
( 	Move Right on tape
) 	Move Left on tape
[ 	Add Selected Character on tape
] 	Subtract Selected
{ 	Multiply Selected
} 	Divide Selected
< 	Loop as many times as in the selected cell
> 	End the loop
, 	Print Selected as ASCII
. 	Print Selected as Number
? 	If Selected Cell is Not 0, Continue; else goto !
! 	From ?
The Language has a tape and a stack, for reasons.
 Outside Loop Symbols
Symbol	Definition
“ 	Start and End Loop
‘ 	Start and End Program
( 	Pop Stack from Varible
) 	Push Stack from Variable
[ 	Define Var from Input* (Example: [var)
] 	Return/Print Var (Example: ]var)
{ 	Begin Interpreting BF (I ran out of ideas)
} 	Stop Interpreting BF
< 	Define Var from Top of Stack
> 	Define Var from Bottom of Stack
. 	Print Entire Stack
, 	Print Enitre Tape
(* you can’t name a variable a number, [var2 will put 2 into var)
Hello World-ish
’{>+++++++++[<++++++++>-]<.>++++++[<+++++>-]<-.+++++++..+++.>> 
+++++++[<++++++>-]<++.------------.<++++++++.--------.+++.------.--------. 
>+.>++++++++++.}’
Cat Program
’[cat ]cat’
An exempt at a true hello world program, basically just screwed up brainflakes
’”
([[[[[[[[[<)[[[[[[[[(]>),([[[[[[<)[[[[[(]>)],[[[[[[[,,[[[,(( [[[[[[[<)[[[[[[(]>),]]]]]]]]]],)[[[[,]]]],[[[,]]]]]],]]]]]]]], ([,([[[[[[[[[[,”’
We need more examples
Category:Languages
Category:Unimplemented
Category:2023
Category:Stack-based
Category:Cell-based
Arrow

Arrow is an open-source language that is written in C#. It was created by User:Fallensn0w.
==Commands used in Arrow==
Arrow uses 9 different commands (counting a loop as a single command).
Cmd 	Description
# 	makes a pixel at the current position.
¤ 	resets the color of current X and Y position.
& 	resets the current X and Y position.
> 	moves the current X position to right.
< 	moves the current X position to left.
^ 	moves the current Y position up.
V 	moves the current Y position down.
[ 	Jump to the matching ] if the current cell is zero. (currently not used)
] 	Jump to the matching [ if the current cell is nonzero (currently not used).
/* */	multi line comment.
? 	makes a red pixel at the current X and Y to determine where the user is on the screen.
== Examples ==
This is the example program that is loaded with Arrow 3.0 every time you start the program.
 >>>>>VVVVV#>#>#>#<<<V#V#V#V#^^#>#>#<<VV>>>>>#^#^#^#^#>#>#>#V#V#<#<#>>V#V#>>#>#>#>#<<<^#
 ^#^#^#VVVV>>>>>#^#^#^#^#VVVV>#>#>#>>#>#>#>#<<<^#^#>#>#>#<<<^#^#>#>#>#<<<VVVV>>>>>#^#^#^
 #^#>V#>V#>V#>V#^#^#^#^#VV>>VV#>#>#>#^#^#<#<#<#^#^#>#>#>#>VVVV>#^#^#^#^#>V#>V#>V#>V#^#^#
 ^#^#>>VVVV#^#^#^#^#>#>#>#V#V#V#V#<#<#>>>>#^#^#^#^#VVVV>#>#^#^#VV>#>#^#^#^#^#VVVVVV#<#<#
 <#<#<#<#<#<#<#<#<#<#<#<#<#<#<#<#<#<#<#<#<#<#<#<#<#<#<#<#<#<#<#<#<#<#<#<#<#<#<#<#<#<#<#<
 #<#<#<#<#<#&?
FALLENSN0W will be printed to the screen.
==External resources==
* Download the latest version of Arrow 
*Arrow is open-source and the source code is available at github (old version).
==See also==
* Paintfuck
Category: Languages
Category: Implemented
Category: 2010
Category: Cell-based
Category: Brainfuck derivatives
Category: Low-level
ArrowFuck

ArrowFuck is a programing language created by User:Mipinggfxgbtftybfhfyhfn 100% backwards compatible with Brainfuck being the only diference that ArrowFuck stores memory in a 2D space.
===Commands===
Command	Function
> 	Moves the memory pointer to the right.
< 	Moves the memory pointer to the left.
^ 	Moves the memory pointer up.
v 	Moves the memory pointer down.
+ 	Increments the actual cell.
- 	Decrements the actual cell.
. 	Outputs the character corresponding to the value of the actual cell.
, 	Inputs a character and stores it's ascii value in the cell.
[ 	Jump past the maching ] if the cell is 0.
] 	Jump to the to the matching [ if the cell is nonzero.
Category:Languages
Category:Brainfuck derivatives
Arrowey

As this esolang is a work-in-progress there's currently no info to add. More information will later be included as soon as it exists ;) 
== Description ==
arrowey is an esolang that can be written in a readable way or in totally unreadable ways. It consists of instructions that can be written in four directions: left, right, up, down. These are connected using the Unicode arrow characters (←↓↑→) (therefore the name). 
An example hello world program can look readable like this: out:"Hello world"→end:<> or hard to understand like in this screenshot: . 
arrowey is an interpreted twodimensional language, meaning the interpreter's "playhead" starts in the top left and goes right until it hits an arrow. It then follows this arrow's direction until the next arrow and so on until it hits an end:<> statement. 
 
== Syntax ==
The "playfield" has to be rectangular (every line has to have the same length, filled up to the right with spaces). 
The "playhead" of the interpreter starts in the top left and moves initially to the right. If an arrow (←↑↓→) is hit by the "playhead" of the interpreter it will change directions based on the direction of the arrow. The code is read character by character so the instructions need to be spelled in the direction the playhead will be taking. 
Instructions are separated through the arrows and zero to infinite spaces before and after the arrows. 
Every character that is not hit by the "playhead" is considered a comment. Instructions can share characters with other instructions and comments by crossing them. 
Variables are marked by enclosing their name with angle brackets ("<" and ">"). Functions are also variables but to call them their name is written with a colon directly after it and then space-delimited arguments until the end of the instruction. 
There's a special nameless constant (<>) which corresponds to nothing, like null or the pythonic None. 
The 2D aspect of arrowey is just a preparsing step. A preparser follows the path and retrieves the one-dimensional actual source code that is then parsed and executed. In script mode (useful for creating and debugging) there is no 2D aspect to the language and every arrow is only interpreted as an instruction separator without changing the execution direction. 
== Additional stuff ==
An online arrowey interpreter is in the works on Lampe2020.de. There or on GitHub you can also get the latest LARK syntax definition. 
Category:Languages Category:Two-dimensional languages Category:Implemented Category:Works-in-Progress
Arrowhead

Arrowhead was once a fully fleshed out language, however the creator suffered a concussion and was unable to remember the details. This program was the only one written, but the compiler was not finished.
 😺😹😺😹😺😹😺😹😺😺😹😺😹😺😺😹😺😹😺😺😹😺😹😺😺😹😺😹😺😺😹😺😹😺😺😹😺😹😺😹😹😹😹😹😹😹😹😹😹😹😹😹😹😹😹😹😹😹😹😹😹😹😹😹😹😹😹😹😹😹😹😹😹😺😹😺😺😹😺 
This program takes a byte as input and outputs it again.
Category:Languages
Category:Turing complete
Category:Unimplemented
Arrows

Arrows is an unfinished esoteric programming language by User:SoundOfScripting (readers may also contribute, current contributors: User:Joaozin003) that only uses UTF8/Unicode arrows.
A list of accepted arrows can be found here.
==Syntax==
===Format===
Programs written in Arrows consist of two-dimensional grids of Unicode characters. Any characters that are not recognized are treated as comments.
===Threads===
An Arrows program's flow consists of multiple "threads" of binary data that follow the course of arrows throughout the grid. Each thread can hold a different amount of bits, usually corresponding to the number of arrows in a single character (i.e. ← holds one bit and ⇐ holds two).
===Thread movement===
Unless a thread is depending on another one, threads move one arrow at a time simultaneously. In the splitting example above, whichever thread that attempts to merge first must wait for the other one to catch up before merging into two bits.
Threads may also point towards themselves, allowing for infinite loops.
Threads moving into comments or thread sources will immediately be destroyed.
===Commands/arrows===
* ←, ↑, →, ↓, ↖, ↗, ↘, and ↙ transfer a one bit thread of data from the base of the arrow to the tip.
* ↚ and ↛ invert the value of the bit(s) they transfer (these arrows transfer any-sized threads).
* ↺ and ↻ create new one bit threads (0 and 1 respectively), which transfer to any thread-continuing arrows (arrows that use one or more threads as inputs) next to the ↺ or ↻.
* ⇐, ⇑, ⇒, ⇓, ⇖, ⇗, ⇘, and ⇙ transfer two bits threads from the base of the arrow to the tip.
* ⤙ and ⤚ split bigger threads into smaller ones and may duplicate threads into same sized parts (they work in the opposite direction they are named).
* ↜ and ↝ direct threads to their respective tips combined with a random direction from this list:
** Up
** Down
* ↭ splits threads, and each part goes to one tip and combined with a random direction from the list above.
* ↔ and ↕ direct threads left and down respectively if the first bit of a thread is 0, otherwise they're directed right and up respectively.
* ⟳ outputs a thread and destroys it.
* ⟲ gets a bit from input and creates a thread with it it (similar to ↺ and ↻).
==Example programs==
===Splitting and merging===
↺	 	A	n	y	 	t
↓	e	x	t	→	⟳	
⇒	⇒	⇒	⤙	c	a	n
↑	 	g	o	→	→	⟳
↻	 	h	e	r	e	.
This example outputs the binary string "01". It is definitely not the most efficient way to do so.
===Output infinite 1s===
↻	⟳
⤙	
 	↖
This program works by duplicating a one bit stream, outputting it, and repeating (the next duplication gets done after the output since threads don't move instantly).
===Thread creation failure===
⟲	⟲
⟳	⟳
This program outputs the first four bits from the input stream (in any order).
=== Truth machine ===
 	⟲	 	⟳
⟳	↔	⤙	1
0	 	 	↖
This program takes 1 bit of input, and if it is 0, it outputs 0, else it outputs infinite 1s.
==External resources==
* List of arrows - https://www.toptal.com/designers/htmlarrows/arrows/
Category:Languages
Category:2017
Category:Ideas
Category:Two-dimensional languages
Category:Unimplemented
Category:Concurrent programming
Arrows only

Arrows only is a programming language that is 2d and only uses arrows
== Commands ==
you start at top-right corner going right, the commands are relative, so up would be exactly the same direction your going
^ adds 1 to the stack
v checks if there is at least one 1, if so, go forward, else go backward
> go right
< go left
Category:Languages Category:Two-dimensional languages Category:Stack-based Category:Unusable for programming
Arsel

== Arsel ==
Arsel (A Really Small Esoteric Language) is a simple, minimalistic language, made by User:Kirbyiseatinghumanmeat in January 2021 with only 3 instructions.
=== How it works ===
Arsel works like this:
It has an array that contains alphabetical characters (a, b, c, etc.), numbers (0, 1, 2, 3, etc.), and a blank space, that looks like this:
 # Alphabetical chars (only supported lowercase)
 "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",
 
 # Numbers
 "1", "2", "3", "4", "5", "6", "7", "8", "9", "0",
 
 " "
An integer called `pos` will point the character at the board according to its value. For example: if `pos` is 5, it's pointing at the `f` character. The language works around this `pos`, increasing or reset it depends on the instructions.
=== Instructions ===
Instruction	Effect
+ 	Increase the `pos` by 1
0 	Prints the character at that `pos`
< 	Reset the `pos` to 0 ("a")
Any other characters will be considered as comments.
=== Examples ===
Here is a simple program that prints "hello" in Arsel:
 +++++++0<
 ++++0<
 +++++++++++0<
 +++++++++++0<
 ++++++++++++++0<
 ++++++++++++++++++++++++++++++++++++++++++++++0<
Here is the same in one line:
 +++++++0<++++0<+++++++++++0<+++++++++++0<++++++++++++++0<++++++++++++++++++++++++++++++++++++++++++++++0<
Here is the same but shorter:
 ++++++0<++++0+++++++00+++0
=== The interpreter ===
Here is the interpreter of this language, written in Ruby. You need to run this with a filename as input e.g. ruby arsel.rb the_file.ars runs this interpreter with the input file is the_file.ars.
 class Arsel
 def initialize(script)
 @script = script
 @pointer = 0
 @board = [
 # Alphabetical chars
 "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",
 # Numbers
 "1", "2", "3", "4", "5", "6", "7", "8", "9", "0",
 " "
 ]
 @pos = 0
 end
 def run()
 while @pos < @script.length
 current = @script[@pos]
 if current == "+"
 @pointer += 1
 @pos += 1
 elsif current == "0"
 print @board[@pointer]
 @pos += 1
 elsif current == "<"
 @pointer = 0
 @pos += 1
 else @pos += 1
 end
 end
 end
 end
 arsel = Arsel.new(File.read(ARGV[0]))
 arsel.run
Category:Languages Category:2021 Category:Implemented Category:Total Category:Unusable for programming Category:Output only
ArtState

ArtState is an esoteric proglang sketch by User:Rdococ. The premise is that an image can represent a finite state machine by using colour channels to represent the positions of future possible states.
== Execution ==
An ArtState program is a 32-bit RGBA bitmap image. Each pixel is a state with two transitions to other states, whose positions are described by the RG and BA channels respectively. The colour channels indicate signed offsets relative to the current pixel. Transitions past the edges of the image are looped.
A program may be run by tracking the current state and repeatedly asking the user which transition they want to follow. A black transparent pixel halts the program.
== Computational Class ==
Programs can only accept two input symbols, but more can be imitated by adding intermediate states. States can only transition to other states within a 256x256 pixel area around them, so I think not even all FSA can be expressed.
Category:Languages Category:Concepts Category:Non-textual Category:Finite state automata
Artemis

Artemis is a simple translation of reversible &brainfuck with support for procedure definitions. Artemis is concatenative and reversible. It was discovered by User:Orby in May of 2020.
==Definition==
Artemis operates on a right unbounded tape of unbounded cells. In addition to a data pointer, Artemis has an indirection count.
Command	Action
i 	Increment the current cell, then increment the indirection count.
d 	Decrement the current cell.
{ 	Decrement indirection count, then jump after matching } if the cell pointed to by the current cell is zero.
} 	Jump after matching { if the cell pointed to by the current cell is zero.
: 	Begin/end procedure definition. The next token is the name of the procedure.
Invoking d when the current cell is zero, and invoking { when the indirection count is zero have undefined effects.
===Definition of current cell===
The value of the current cell is defined as the value of the data pointer if the indirection count is zero. If the indirection count is one, then the value of the current cell is defined as the value of the cell pointed to by the data pointer. If the indirection count is two, then the value of the current cell is defined as the value of the cell pointed to by the cell pointed to by the data pointer, and so on.
===Relationship to &brainfuck===
All Artemis commands must be separated by white-space. Artemis exhibits the following simple translation to reversible &brainfuck
Artemis	&brainfuck
i 	>*
d 	<
{ 	&[
} 	]
&brainfuck	Artemis
> 	i { }
< 	d
* 	d i
& 	{ }
[ 	d i {
] 	}
==Defining procedures==
The following example defines procedures for something similar to Reversible Brainfuck operations. The : defines the beginning of a procedure, followed by the name of the procedure, followed by the definition, and finally it is terminated with :. For example
 : > i { } :
 : < d :
 : + d i > { } :
 : - d i < { } :
 : [ d i { :
 : ] } :
==See also==
* &brainfuck is the language that inspired Artemis.
* Simple translation is a concept that features prominently in this article.
Category:Languages
Category:Brainfuck_derivatives
Category:Cell-based
Category:Turing complete
Category:Turing tarpits
Category:Low-level
Category:2020
Category:Reversible computing
AsPL

Ascii Programming Language
ASCII Programming Language (also "AsPL") is a totally not esoteric programming language, and is used by many many people.
Design philosophy
The Design Philophy behind AsPL is just as simple as writing AsPL: "Why use more than one character when one will do?" or as the AsPL community calls it, "One character to rule them all."
Syntax
Basic Syntax
- "+" increments the value of the current cell
- "-" decrements the value of the current cell
- ">" moves the pointer to the right
- "<" moves the pointer to the left
- "r" resets the current cell to 0
- "p" prints the current cell value
- "c" prints the current cell as a character
- "i" takes input and stores it in the current cell
- "s" takes input and stores it in the current cell as a character
- "a" print all cells != 0 as a string of characters
- "h" holds the program until Enter is pressed
it is advised to use the "h" command at the end of the program, as it will prevent the program from closing before you can see the output.
Advanced Syntax
complex functions are made by using command blocks
- "[" starts a command block
- "]" ends a command block
Each command block consists of the command and the argumens, seperated by a comma.
the commands are:
- "[f, x]" finds the first cell with the value x and moves the pointer to it
- "[b, x]" sets the current pointer to x
- "[l, x]" sets the current cell to the roman numeral x
- "[o, x]" sets the current cell to the ordinal value of the character x
Examples
Hello World
-----------
 [o,H]>[o,e]>[o,l]>[o,l]>[o,o]>[o, ]>[o,w]>[o,o]>[o,r]>[o,l]>[o,d]<<<<<<<<<<<ah
This program prints "Hello World" by using the ordinal value of each character to set the current cell to the ordinal value of the character, then printing all cells != 0 as a string of characters.
How to use
to register .aspl files, run register_AsPL.py as admin (works only on Windows)
to run .aspl files, double click them or run them with python using:
 python run_Aspl.py <file_path>
AsPL was developed by @MixoMax
License
Ascii Programming Language is licensed under the MIT License
==External resources==
* AsPL on GitHub
Category:Languages Category:Cell-based Category:Implemented
Asd

asd is an esoteric programming language created by User:A which makes 123's syntax simpler. 
== Instructions ==
The pointer begins at location 0(Afterwards L0). All bits start at 0.
Instruction	Description
a 	Boolfuck: @<
s 	BF: >
d 	If the current bit is 1, skip back to the previous d or start of program.
Category:Languages
Category:2018
Category:Turing complete
Category:Turing tarpits
Category:Low-level
Category:Brainfuck derivatives
Category:Cell-based
Asdf

asdf is an esoteric programming language created by user:David.werecat which uses only 4 instructions: a, s, d and f.
== Instructions ==
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.
== 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
=== Toggle the bit at the current location and clear the toggle flag ===
 ass
=== Cat ===
 daasaasasaasssaasssasssf
== External resources ==
* Visual Basic .NET interpreter and sample programs
Category:Languages
Category:2012
Category:Turing complete
Category:Turing tarpits
Category:Low-level
Category:Implemented
Category:Brainfuck derivatives
Category:Cell-based