nyuuzyou/wikis huggingface dataset:
After

After is a programming language made by Username (talk).
== Introduction ==
After is a cell & stack programming language, however, in After, you can only store integers in cells, and characters in stacks.
== Syntax ==
Cmd 	Description
+ 	Gets the left value and the right value of the "+" and adds both of them before pushing it into the stack.
- 	Gets the left value and the right value of the "-" and subtracts both of them before pushing it into the stack.
/ 	Gets the left value and the right value of the "/" and divides both of them before pushing it into the stack.
* 	Gets the left value and the right value of the "*" and multiplies both of them before pushing it into the stack.
% 	Gets the left value and the right value of the "+" and mods both of them before pushing it into the stack.
o 	The pointer starts here.
> 	The pointer will travel right.
< 	The pointer will travel left.
v 	The pointer will travel down.
^ 	The pointer will travel up.
r 	Reverses the contents of the stack.
. 	Prints the character processed after the .. Code is ignored while . is running.
? 	The pointer will travel in random directions.
: 	Duplicates the top value and pushes it into the stack.
; 	Duplicates the bottom value and pushes it into the stack.
0-9 	Pushes 0-9 into the stack.
$ 	Deletes the top value of the stack.
_ 	Deletes the bottom value of the stack.
{ } 	Sets the value of pointer to anything inside of the { }. Default value is set to 0.
#() 	Index of stack.
##() 	Index of cell.
### 	Comment.
= 	Set to.
== 	Is equal to.
, 	Less than.
' 	Greater than.
r() 	Replaces index/#() or ##() with anything inside ()
dIO() 	Duplicates the index of stack or cell with anything inside ()
cS 	Set all stack values to 0.
cC 	Set all cell values to 0
nD(a=1, b=2, c=3)	Adds a new dictionary, when converting from stack to cell using c#()p.
c#()p 	Converts stack index to a cell integer using nD().
& 	Ends program.
Category:Languages Category:Stack-based Category:Unimplemented
Afterstar

Afterstar is a minimal esolang based on deterministic division and program-defined multiplication of a single unbounded memory value, designed by User:Keymaker in early 2024 but published near the end of the year.
==Program and execution==
The language operates on an array of integers, which is given as the program. There must be at least one integer and there is no limit to their amount or their size (other than that they be non-negative). Each integer has an index number that grows by one for each successive integer, the first being at index 1. The index pointer points to one of the integers, initially to the first.
The memory is an unbounded non-negative integer, initially the smallest prime, 2. If the memory ever becomes 0, the program halts.
One step of execution consists of first checking if the memory is 0, and halting if so. The instruction pointer attempts to divide the memory value with its current value (not the value it is pointing to in the array, but its own value), and if the memory is dividable (and remainder is zero), then it is divided by the index pointer's value. Right after, if dividing succeeded, the memory is multiplied by the integer in the array that the index pointer is pointing to. Then (whether dividing and multiplying happened or not), the index pointer is increased by one, unless it is already pointing to the last integer, in which case it is set to 1 (the first integer in the array).
==Program formats==
A program encodes the list of integers in a simple unary format. The character ( is repeated n times, followed by the character *. A sample program:
 (*
 (((((*
 (((*
 ((((*
 *
Because the size of the programs will easily become uncontainable on any hardware, there is an alternative format that allows for describing the array index (left) and the actual integer to store there (right). The integers at indexes that are not specified are set to match their index numbers. This would be the above program in the practical format:
 2:*:5
 5:*:0
==A simple interpreter==
Here is a simple no-IO interpreter in Python to showcase the simplicity of the language. A shorter one could no doubt be made, and in some golfing language it may be possible to squeeze this interpreter or something like it into a few characters.
 a = [1,5,3,4,0] # array of integers
 m = 2 # memory
 p = 0 # index pointer
 while m > 0:
 if m % (p + 1) == 0:
 m = (m // (p + 1)) * a[p]
 p = (p + 1) % len(a)
==Computational class==
The language is Turing-complete, as is shown via Minsky Machine translation. See external resources.
==External resources==
* Afterstar information (detailed explanations of the language and the MM translation, translator program, interpreter in Python)
Category:2024
Category:Low-level
Category:Languages
Category:Turing complete
Category:Turing tarpits
Category:Implemented
Category:No IO
Afz

Afz is invented by User:A.
Furthermore, I recommend that the official #esoteric character set of 12 different characters for transmitting messages redundantly through a 7-bit serial line shall be: +,07HOSTafz}. afz stands for Another Foolish ...what?
==Commands==
An afz program executes backwards. Items in a lookup table do not have to be even.
A string-pushing command starts when a character is alphabetic, and ends when the character is not the same case as that character or is non-alphabetic.
The stack is right-ended; that is, you push items from the right to the left, and you pop items from left to right.
Input will prepopulate the stack.
Command	Response
} 	Begin a lookup table preservation by taking items from the stack. At the end of the program the lookup table will be printed.
afz 	Push the string "zfa" onto the stack.
HOST 	Push the string "TSOH" onto the stack.
1-9 	Duplicate the top-of-stack string 1-9 times and push it.
0 	Duplicate the top-of-stack string 0 times and push it. I.e. push an empty string.
, 	Push all first-items in the rows of the lookup table onto the stack.
+ 	Concatenate all of the items. Different items are separated by spaces.
. 	Concatenate top two items. Different items are separated by spaces.
- 	Remove all characters in the top of stack that is in the second-to-top of stack. It is case-insensitive.
! 	Convert the top of the stack to lowercases
~ 	Opposite of !
^ 	Capitalize the first letter
@ 	Return the value for the first occurence of the top of stack in the lookup table
$ 	Remove the first occurence of the top of stack in the lookup table
: 	Duplicate every character in a string
==Examples==
===afz HOORAY===
+5YAROOHzfa}
===Exchange good and bad===
^!-DABDOOGdoog}
Category:Languages
Category:2019
Category:Stack-based
Category:Total
Category:Unimplemented
Aggressthon

Aggressthon is an esoteric programming language by Cameron Koehler (User:Vulture001) that is exactly like Python, yet uses aggressive tone uppercase variables as commands, rather than the native Python commands.
== Instructions ==
Instruction 	Description
FULMINATE() 	Starts program with 'Aggressthon 0.1 (def, Oct 16 2019, 07:33:32)'
BITCH "Hello, World!"	Prints string (in this case, Hello, World!) to console
LASHOUT 	Asks for an input, can be assigned to actual variable to print later using BITCH
LAYOFF 	Prints empty line for spacing (like \n)
WHO 	Returns the identity of an object (needs to be paired with BITCH)
WHATEVER 	Rounds a number
STORMOFF() 	Ends program with 'No more memory left to scan' printed to console
Each command is purely variables of Python, clearly used in a joking manner. The creator is currently working on a compiler to be able to execute commands in a program.
==Example code==
===Hello, World!===
 FULMINATE()
 BITCH('Hello, World!')
 STORMOFF()
would output:
 Hello, World!
===Identification of a string===
Note: (Identification of strings varies when compiled)
 FULMINATE()
 string = "Hello, I am a string!"
 BITCH(WHO(string))
 STORMOFF()
would output:
 140577084273808
===Rounding numbers===
 FULMINATE()
 number = 1.5
 rounded = WHATEVER(number)
 BITCH(rounded)
 STORMOFF()
would output:
 2
Category:Languages
Category:Joke languages
Category:2019
Category:Implemented
Ahead

Ahead is a fungeoid created by snail_ in 2018. It is inspired primarily by Befunge and ><> but with a slightly different approach. The reference implementation is available on GitHub.
== Overview ==
The primary difference Ahead has from other fungeoids is the structure of its playfield. Called the board, it does not extend infinitely in any direction. Rather, it is bounded at its edges. For example, this program
 Il&+1t~j+1*3\~/2<~<
 >:2)k~tO@~:k\: nl
forms a 20x2 character board, with gaps filled in by space characters.
The IP, or head, does not wrap around when it reaches the edge; instead, it turns around and travels the opposite direction. This makes some program structures in other fungeoids nontrivial in Ahead, but it lends itself to some other unique techniques.
You can also add walls , represented by #. These cells are like the edges of the board: they cannot be passed through and the head will just turn around when one is in its way.
Aside from these differences, Ahead is otherwise similar to other fungeoids, particularly Befunge and Fish, differing mostly in its instruction set.
Category:Two-dimensional languagesCategory:LanguagesCategory:2018
Aheui Turing-completeness proof

It can be proven that Aheui is Turing-complete by making a translation table from Brain%66uck (a known Turing-complete language) to Aheui. This document shows how to translate any Brainfuck program (minus input and output, which are not necessary for Turing-completeness) to Aheui.
This program uses three stacks. An alternative using two can be made, but that can be more difficult.
Simply take the Aheui blocks and stack them vertically.
Brainfuck 	Aheui	Note
Beginning of program	부 	
+ / Add 	발발나다붗
루떠떠벓벓	
- / Decrease 	밟밠밥따따받두
루떠떠벓벓벝더	Optional. This is still Turing complete without it.
> / Glide right 	싹순
수빠쑤
부수머
우어	Unconfirmed
< / Glide left 	싼숙
수빠쑤
부수머
우어	Unconfirmed
[ / Start loop 	빠우
우처아아아아아ㅡㅡㅡㅡㅡ아우
우어어어어어어ㅡㅡㅡㅡㅡ어우	The number of placeholder characters must match the number of placeholder characters in the corresponding end loop instruction.
] / End loop 	빠우
우차아아아아아ㅡㅡㅡㅡㅡ오우
우어어어어어어ㅡㅡㅡㅡㅡ어어	The number of placeholder characters must match the number of placeholder characters in the corresponding start loop instruction.
, / Input 	마밯밣붏
루떠떠벝	This can keep undefined characters from being pushed into the stack.
. / Output 	뿌
뭏 	
End of program 	바희 	
Category:StubsCategory:Proofs
Ais523

ais523 is a European mathematician and esoteric language creator. His most famous creation is Underload, but he has a lot of other interesting languages listed on his userpage User:ais523. He also maintains a modern Intercal interpreter.
ais523 also takes part in some software projects that aren't deliberately esoteric.
* He is a developer of the Nethack game since about 2015 and its fork Nethack4 and acehack since about 2012. These are a challenge because the organization of the source code originates from the 1980s before modern coding practices.
* aimake, a build tool for C programs that scans the linker symbols of object files to figure out what dependencies to link with each main executable. He used this to untangle nethack, in which some of the C source files are generated dynamically by auxiliary programs built by nethack, and the source codes overlap so much that small changes can easily cause circular dependencies.
* ayacc (darcs repository at http://nethack4.org/projects/ayacc ) is a new implementation of the traditional yacc parser generator. 
See also 2017 interview with ais523 at esoteric.codes.
Category:People
Aj

aj is an esoteric programming language created by User:A. 
Twin language: Ja
== Instructions ==
Instruction	Description
j 	jump to cell numbered as the input and jump to the input-th code command.
a 	add current cell by 1
== Example (Infinite Loop)(Set C1 to infinity) ==
Input: 0
 aj
Category:Languages
Category:2018
Category:Low-level
Category:Brainfuck derivatives
Category:Cell-based
Ajsone

Abusing JSON Esolang (Ajsone) is an esoteric programming language created by Alok Menghrajani. The language abuses JSON by using the JSON data format to represent everything: functions, variables, values, etc.
== Examples ==
The following computes the factorial of 5.
 {
 "fact": {
 "=if": {
 "cond": {"=<=": {"in1": "=n", "in2": 1}},
 "then": 1,
 "else": {
 "t": {"=-": {"in1": "=n", "in2": 1}},
 "=*": {"in1": "=n", "in2": {"=fact": {"n": "=t"}}}}
 }
 },
 "=fact": {"n": 5}
 }
== External resources ==
* More info and web based interpreter
Category:Languages
Category:2014
Category:Implemented
Akdrfsbathnede knem

akdrfsbathnede knem Is a esolang by User:Qawtykit that uses a tape of stacks to store data.
==Basics==
akdrfsbathnede knem has an unbounded tape of stacks. Those stacks can contain any integer.
You can also "carry" one value and place it somewhere else.
The tape is seven cells long, and the pointer starts in the center of it (leaving three cells in either direction).
==Commands==
Command	Description
> 	Same as in brainfuck
< 	Same as in brainfuck
# 	Push 1 onto the current stack
^ 	Pop the top of the current stack, and begin carrying it
v 	Push the carried value onto the current stack, and remove the carried value
V 	Push the carried value onto current stack twice, and remove the carried value
+ 	Remove the carried value and pop the top of the stack. Add them together, and push the result onto the current stack
- 	Same as +, but subtraction (popped value - carried value)
* 	Same as +, but multiplication
/ 	Same as +, but division (popped value / carried value)
% 	Same as +, but modulo (popped value % carried value)
G 	Remove the carried value, y, and pop the top of the current stack, x. If x > y, push 1, otherwise push 0
= 	Same as G, but it's equal to
| 	. The first | can still be jumped to, but it is otherwise ignored.
$ 	, but it goes to the next one instead
I 	Take a number from the user and push it onto current stack
O 	Remove the carried value and output as number
U 	Remove the carried value and output its corresponding Unicode character
==Examples==
===Infinite loop===
|#^#-|
===Truth-machine===
I##^-=$##^-^VO$|#^O##^-|$
===Fun Video Game===
<nowiki>##^-|^VI=$#^+|$>
##^+^V^V++#^+##^+^V*#^+^V+*^V^U
##^+V*^>V^<v#^+-^>>V^<<U
>##^+^*^<+^V^U
##^+#^++^V^U
##^+^V^*#^+^V^+#^++^V^U
##^+#^+-^V^U
>>##^+^V^*^+^U
</nowiki>
Category:Languages Category:Stack-based Category:Cell-based Category: Unimplemented
Al Dente/Examples

:
Examples of Al Dente code.
== Value conditional example ==
 BitStream
 {
 zero;
 one;
 BitStream tail;
 zero excludes one;
 tail.zero or tail.one requires zero or one;
 }
 BitStreamConditional
 {
 pickFirst;
 pickSecond;
 BitStream inputFirst;
 BitStream inputSecond;
 BitStream output;
 
 BitStreamConditional tail;
 
 pickFirst excludes pickSecond;
 output.zero requires pickFirst and inputFirst.zero or pickSecond and inputSecond.zero;
 output.one requires pickFirst and inputFirst.one or pickSecond and inputSecond.one;
 
 tail.pickFirst requires pickFirst;
 tail.pickSecond requires pickSecond;
 tail.inputFirst matches inputFirst.tail;
 tail.inputSecond matches inputSecond.tail;
 tail.output matches output.tail;
 }
These classes demonstrate how a choice can be made between two BitStreams. Another class can state that a BitStream matches each of the two input streams of a BitStreamConditional, and also set one or the other (but not both) of pickFirst and pickSecond. The values of pickFirst and pickSecond will cascade down the BitStreamConditional via the requires chains. The elements of the input streams will be immediately mirrored into the BitStreamConditional. The appropriate events will then be copied into output and mirrored in the output stream.
== Natural numbers and arithmetic ==
 Number
 {
 zero;
 succ;
 Number tail;
 
 zero excludes succ;
 tail.zero or tail.succ requires succ;
 }
 
 Copier
 {
 copy;
 Number in;
 Number out;
 Copier copier;
 
 copy requires ((in.zero and out.zero) or (in.succ and out.succ));
 copier.in matches in.tail;
 copier.out matches out.tail;
 copier.copy requires copy;
 copy requires copier.copy or in.zero;
 }
 
 Add
 {
 Number in1;
 Number in2;
 Number out;
 Copier copier;
 Copier in2copier;
 Copier outcopier;
 Add next;
 
 copier.copy matches in1.zero;
 copier.in matches in2;
 copier.out matches out;
 outcopier.copy matches in1.succ;
 outcopier.in matches next.out;
 outcopier.out matches out;
 next.in1 matches in1.tail;
 in2copier.copy matches in1.succ;
 in2copier.in matches in2;
 in2copier.out matches next.in2.tail;
 }
There you have it.
Hopefully multiplication won't be too complicated.
Category:Examples
Alan's dead fish

(This is my first esolang, please note any mistakes.)
Alan's dead fish is an esolang make by User:Bogdan192848 based on Deadfish. It has the same command set as Deadfish, but with 2 new commands:
*"!": If the accumulator isnt 0, jump to the next !. The even numbered ! are not runned (ex in !d!!i!, only the ! at the first and 4th character are runned)
*"g": Set the accumulator to the user's input.
The program also loops when it reaches the end.
==Examples==
===Truth-machine===
 !g!!oh!d!iod!i
===Countdown===
 !g!od!oh!
==Interpreters==
Category:Joke languages Category:Deadfish derivatives Category:Languages Category:Implemented Category:Unusable for programming Category:2024
Alan Turing

Alan Mathison Turing was a mathematician, philosopher, cryptographer, and pioneering computer scientist. "Turing" is surely the most common name mentioned on this wiki: Alan Turing invented the Turing machine and with it brought to light the concept of Turing completeness. Nowadays he is credited as the 'father of modern computing' although most of his recognition was posthumous. Much of his research in the field was through his prominent position in Bletchley Park, the team that cracked the Enigma cypher during the second world war, and as such was classified until after the war. He wrote the Church-Turing thesis with Alonzo Church, and discovered the Halting problem. He committed suicide in 1954 at age 41 after prosecution for his sexual orientation, which was then considered a crime in the United Kingdom.
==External resources==
* Wikipedia:Alan Turing
Category:People
Alarm Clock Radio

Alarm Clock Radio is a modified form of Brainfuck, designed to be stripped to the minimal instruction set needed to reproduce Brainfuck's functionality, except with a sleep instruction added.
Alarm Clock Radio was created by User:Deschutron one day because he couldn't find a variant of Brainfuck that has a minimal instruction set when the memory space wraps around.
An implementation was created by User:Conor O'Brien, written in ruby. It can be found here.
One of the key changes in Alarm Clock Radio is the removal of the '<' and '-' instructions,
since their effects can be produced by the correct number of '>' or '+' commands.
The result creates a similarity with common alarm clock radios,
that often have increment buttons for their minutes and hours settings,
but no corresponding decrement buttons.
This similarity is responsible for the name of this language.
The instructions are summarised as follows:
 > HR increments the memory pointer
 + MIN increments the current memory cell
 [ LOOP jumps past the matching ] if the cell under the pointer is 0 
 ] RETZ jumps back to the matching [ if the cell under the pointer is nonzero 
 , READ reads a byte into the current memory cell
 . WRITE writes the byte that is in the current memory cell
 @ SNOOZE sleeps for the number of seconds in the current memory cell
 } PAD sets the memory size to the inclusive distance between the two furthest non-zero cells,
 plus PADSIZE cells.
where PADSIZE is a number of memory cells.
==The PAD instruction==
The PAD '}' instruction is optional, and is included for when true Turing completeness is required. PAD allows the effective memory space to be unbounded and be cyclical.
PAD may be used both to allocate and free memory.
==Recommended memory dimensions==
For the sake of consistency in implementations, the following recommendations are made:
#The recommended initial memory size with the PAD instruction is 60 cells.
#The recommended initial memory size without PAD is 30000 cells, as in the original Brainfuck compiler.
#The recommended value for PADSIZE is 60 cells.
#The recommended memory cell range is 0-255, using 8 bits (1 byte)
Other suggested memory cell sizes are:
#{0, 1}, i.e. one bit per cell - for true minimalism, similar to Smallfuck.
#0-59, for closer similarity with alarm clock radios.
==Making an alarm clock==
Theoretically, it is possible to write an alarm clock in Alarm Clock Radio.
It is, however, probably not possible to write an alarm clock radio in Alarm Clock Radio, because setting the alarm clock, and receiving the audio data to "play" would require two input channels.
==See also==
*Alarm Clock Radio/implementation.rb, an implementation of Alarm Clock Radio in Ruby
*Brainfuck, the one that started it all...
*Smallfuck, a form of Brainfuck with a reduced instruction set would be Turing-complete if it wasn't specified to have bounded memory
Category:Languages
Category:Brainfuck_derivatives
Category:Cell-based
Category:Low-level
Category:Implemented
Category:2009
Alarm Clock Radio/implementation.rb

:
This is an implementation of Alarm Clock Radio in Ruby by User:Conor O'Brien.
== Implementation ==
 #!/usr/bin/ruby
 require 'optparse'
 # alarm clock radio
 
 # because Notepad++ freaks out with "%="
 def clamp(val, max)
 val % max
 end
 
 class AlarmClockRadio
 OP_HR = ">"
 OP_MIN = "+"
 OP_LOOP = "["
 OP_RETZ = "]"
 OP_READ = ","
 OP_WRITE = "."
 OP_SNOOZE = "@"
 OP_PAD = "}"
 def AlarmClockRadio.tokens(code)
 code.scan(/(([+.>,@])\2*|[\[\]}])/).map(&:first)
 end
 
 def initialize(program, padsize = 60, init_pad = 60, cell_max = 256)
 @memory = [0] * init_pad
 @padsize = padsize
 @code = AlarmClockRadio::tokens program
 @ptr = 0
 @i = 0
 @cell_max = cell_max
 @loops = {}
 
 preprocess_loops
 end
 
 def preprocess_loops
 locs = []
 (0...@code.size).each { |i|
 op = @code[i]
 if op == OP_LOOP
 locs << i
 elsif op == OP_RETZ
 src = locs.pop
 @loops[src] = i
 @loops[i] = src - 1
 # to compensate for @i += 1
 end
 }
 end
 
 def pad
 left = @memory.index &:nonzero?
 right = @memory.rindex &:nonzero?
 dist = right - left rescue 0
 dist += 2
 # inclusive distance??
 @memory = @memory[0...dist]
 @memory.concat [0] * @padsize
 end
 
 def step
 cur = @code[@i]
 head = cur[0]
 repetend = cur.size
 
 case head
 when OP_HR
 @ptr += repetend
 @ptr = clamp @ptr, @memory.size
 
 when OP_MIN
 @memory[@ptr] += repetend
 @memory[@ptr] = clamp @memory[@ptr], @cell_max
 
 when OP_LOOP
 if @memory[@ptr].zero?
 @i = @loops[@i]
 end
 
 when OP_RETZ
 unless @memory[@ptr].zero?
 @i = @loops[@i]
 end
 
 when OP_READ
 repetend.times {
 @memory[@ptr] = STDIN.getc.ord
 }
 
 when OP_WRITE
 STDOUT.putc @memory[@ptr] * repetend
 
 when OP_SNOOZE
 sleep @memory[@ptr] * repetend
 
 when OP_PAD
 pad
 end
 
 @i += 1
 end
 
 def running?
 @i < @code.size
 end
 
 def run
 step while running?
 end
 
 def debug
 p @memory
 end
 end
 
 options = {
 init_cell_size: 60,
 init_pad_size: 60,
 arguments: false,
 cell_max: 256,
 debug: false,
 }
 NAME = File.basename __FILE__
 parser = OptionParser.new { |opts|
 opts.banner = "Usage: #{NAME} [options]"
 
 opts.on("-O", "--out-cell-size=INT", Integer, "Set initial cell size (PAD)") { |v|
 options[:init_cell_size] = v
 }
 
 opts.on("-o", "--out-pad-size=INT", Integer, "Set initial pad size (PADSIZE)") { |v|
 p v
 options[:init_pad_size] = v
 }
 
 opts.on("-m", "--max=INT", Integer, "Set cell max (default: 256)") { |v|
 options[:cell_max] = v
 }
 
 opts.on("-a", "--arguments", "Read from command line arguments instead") { |v|
 options[:arguments] = v
 }
 
 opts.on("-d", "--debug", "Debugs final state") { |v|
 options[:debug] = v
 }
 }
 parser.parse!
 
 if ARGV.empty?
 STDERR.puts parser
 exit
 end
 
 source = ARGV.first
 
 if options[:arguments]
 source = ARGV.join
 else
 source = File.read source
 end
 
 a = AlarmClockRadio.new(
 source,
 options[:init_pad_size],
 options[:init_cell_size],
 options[:cell_max],
 ) 
 a.run
 a.debug if options[:debug]
Category:Implementations