nyuuzyou/wikis huggingface dataset:
Recursor

Recursor is a recursion based (loosely) functional programming language created by Ettore Marmo.
==Overview==
In this language you can define quickly and clearly recursive functions:
 f(x) = f(x-1) + f(x-2); [1,1]
is a valid example. The array after the function body defines the seeds of the function
and is to be read like so:
 f(0) = 1
 f(1) = 1
The seeds can also be strings, arrays or floats.
Obviously nested functions are valid statements:
 H(n) = n-H(H(H(n-1))); [0]
While f(x) behaves like you would expect, returning the xth term of the function,
 f(*x)
returns an array of all the values of the function ranging from 0 to x (inclusive).
==Conditionals==
This language is also capable of if/else statements with a syntax similar to that of the ternary operator.
Keep in mind that these statements can only be defined inside a function.
 F(x) = x % 2 == 0 | x > 30 ?
 x - F(x-1)
 ; F(x-1) + x
 ; [0]
The symbol between the two conditions is one of the three logical operators implemented:
 & : and | : or || : xor
Of course the conditionals can also be nested.
==Output==
There are two options if you want to print something on the screen:
 @1,2,"A"
prints its arguments with a trailing newline.
 @@"Hello", "\", "World"
prints everything on the same line, note that because the interpreter is dumb you have to write "\" for the space character.
The print functions can be used also inside the body of a function.
==Suffixes==
There is a bunch of already implemented functions that can be appended after a token, separated with :.
g = [1,2,3] : function()
For arrays only:
Function	Definition
sort() 	returns the array sorted
join(x) 	returns a string containing the array element joined with x
For strings/char only:
Function	Definition
split(x)	returns an array of the string split at every x
up() 	returns the string with uppercase characters
down() 	returns the string with downcase characters
ord() 	returns the ordinal associated to the char
For ints/floats only:
Function	Definition
chr() 	returns the character associated to the int
abs() 	returns the absolute value of the number
odd() 	returns true if the integer is odd
gcd(x) 	returns the greatest common divisor between the number and x
lcm(x) 	returns the lowest common multiple between the number and x
zero() 	returns true if the number is zero
For arrays and strings:
Function	Definition
[x] 	returns the xth element of the array/string
[x,y] 	returns the sliced array from the xth index to the yth
len() 	returns the length of the array/string
:x 	appends x to the array/string
rev() 	reverses the array/string
count(x)	counts every occurrence of x
del(x) 	delete every occurrence of x
null 	returns true if the array/string is empty
An example:
 f(x) = f(x-1) + f(x-2) ; [1,1]
 @f(*10):[3,6]:rev():join(",")
and it correctly outputs
 34,21,13,8,5,3
==Iterators==
coming soon
==Interpreter==
coming soon
==More Examples==
coming soon
Redcircle

"Redcircle" or "Redcircle Symbolic" is a language scheme conceived by user:Jabutosama. The scheme describes a language family that is by definition context-sensitive in interpreting the meaning of the source code symbols. It is inspired by human nature to interpret nearly anything as symbols based on context. 
==Essentials==
The language scheme has the only definition:
* ' The language being Redcircle Symbolic has no singular one-to-one mapping from symbols to instructions
In order for the symbols to gain any readable meaning and thus programmable function, their context of the symbols is interpreted based on surrounding code, from reading the preceding symbol to classifying the entire script. This results in the compiler being required to be extremely smart.
Example:
 >
This symbol could mean multiple things and could be used equivalently to ".next()" in some functional language, for example. Semantically both ">" and ".next()" are lists of characters with a clear, readable meaning depending on their context, while the other one is simply less verbose and approaches near-absolute minimalism.
==Example Pseudocode==
Hello World
 📝this is a comment
 📝following code corresponds to "system.print("hello world")
 💻✒Hello, World!
99 Beers on the wall
 🍺99
 🔄🍺↗1👇
 💬🍺+beers on the wall. take one down,
 🍺📥-1
 💬1 beer on the wall, take one down,
 💬no more beers on the wall.
Category:Program forms
RedefineFuck

RedefineFuck is brainfuck but you need to redefine symbols to run loops, if statements, etc.
==Instructions==
There are 5 instructions and 6 symbols. whitespaces are ignored, cAsE SeNsItIvE.
===Initial instructions===
 Instructions
instruction	meaning 	brainf**k rough equalivant
@ 	increase 1 	+
[ 	data pointer goes right 	>
&x&...* 	(re)define x to be ... then ptr left	None
] 	if x==0 skip else x-=1 	[->->++<]>>[-<<+>>]<<[[-]>-x<][-<+>]<
$ 	input if x==0 else output x-1 	>[-]<[>+<-.[-]]>[<,>-]<
Instruction name can NOT contain any of the initial instructions.
Brackets should match, or a @ have a 1% chance to fail.
==Computational level==
Turing-complete.
 BF to RF
BF 	RF 	Notes
+ 	@ 	
- 	&-&*[]- 	
> 	[ 	
< 	&!&* 	
[...]	&_&*[&a&@...]a_*]a_ 	'a' is a placeholder, each symbol should be different
, 	&_&*[&a&@&-&*[]-]a_*]a_$	
. 	@$&-&*[]- 	
==Example(s)==
Hello, World! (using wraps on 256)
 @&_&*[&a&@&-&*[]-&-&*[]-[&-&*[]-&_&*[&a&@[[@[&-&*[]-&-&*[]-&-&*[]-&-&*[]-&-
 &*[]-&!&*&!&*]a_*]a_&!&*&-&*[]-&-&*[]-&!&*&-&*[]-&-&*[]-&-&*[]-]a_*]a_[&-&*
 []-@$&-&*[]-[[[@@$&-&*[]-[[@$&-&*[]-@$&-&*[]-@@@&_&*[&a&@@$&-&*[]-[]a_*]a_&
 !&*&!&*&!&*&!&*@$&-&*[]-@@@@$&-&*[]-&-&*[]-&-&*[]-&-&*[]-&-&*[]-&-&*[]-&-&*
 []-@$&-&*[]-&!&*&!&*&-&*[]-@$&-&*[]-[[[[@@$&-&*[]-]-]-]-]-]-]-]-]-]-]-]-]--
Cat, eof returns 0
 [[[[@&_&*>&a&@&_&*>&b&@&-&*[]-]b_*]b-$@$&-&*[]-]a_*]a_
Looping counter
 @&_&*[&a&@[[&_&*[&r&@[]r_*]r_@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&_&*
 [&r&@&!&*]r_*]r_[&_&*[&r&@@$&-&*[]-[]r_*]r_@@@@@@@@@@@$&-&*[]-&-&*[]-&-&*[]
 -&-&*[]-&-&*[]-&-&*[]-&-&*[]-&-&*[]-&-&*[]-&-&*[]-&-&*[]-&!&*&_&*[&r&@&!&*]
 r_*]r_&!&*]a_*]a_
Category:Brainfuck derivativesCategory:2024Category:Turing completeCategory:Turing tarpitsCategory:Unimplemented
Category: Languages
Redefine Symbol

Redefine Symbol is an esolang by User:ChuckEsoteric08 inspired by Emmental.
==Commands==
\ is an escape symbol for push command.
Command	Function
[abc] 	Push string abc to the stack.
% 	Swap top elements
" 	Duplicate top element
$ 	Pop top element and discard it
. 	Replace top element with last element popped.
= 	Pop two elements, a and b. Then redifine symbol a as Redefine Symbol program b. If interpreter will reach symbol a then it would replace that symbol with program b.
+ 	Pop two elements, a and b. Then push ab.
; 	Output top element.
? 	Push user input.
==Computational class==
This program is Underload interpreter, proving that Redefine Sumbol is Turing-complete
 [%][~]=[:]["]=[*][%+]=[(][\[]=[)][\]]=[a][\[\\\[\]+\[\\\]\]%+]=[S][;$]=[^][$.]=?$.
Category:Languages Category:Turing complete Category:Turing tarpits Category:Unimplemented
Redivider/Underload Interpreter

An Underload interpreter written in Redivider, by User:MizardX
= Code =
 main: run("").
 
 run(stack):
 { /~/;
 fst: head[stack];
 snd: next[stack];
 stack: rest[stack];
 stack: push(fst)[stack];
 stack: push(snd)[stack];
 run(stack) }
 | { /:/;
 fst: head[stack];
 run(push(fst)[stack]) }
 | { /!/;
 run(tail[stack]) }
 | { /\*/;
 fst: head[stack];
 snd: next[stack];
 stack: rest[stack];
 run(push(fst + snd)[stack]) }
 | { /\(/;
 value: content;
 /\)/;
 run(push(value)[stack]) }
 | { /a/;
 fst: head[stack];
 rest: tail[stack];
 run(push("(" + fst + ")")[stack]) }
 | { /[\^]/;
 fst: head[stack];
 rest: tail[stack];
 run(rest)[fst + /.*/] }
 | { /S/;
 fst: head[stack];
 rest: tail[stack];
 fst + run(rest) }
 #| { invalid: /.+/;
 # "\nInvalid command: \"" + invalid + "\"" }
 | "".
 
 paren: /\(/ + content + /\)/.
 content:
 /[^()]+/ + content
 | paren + content
 | "".
 
 head: { item: /.*?(?=<>)/; /<>/; item }.
 tail: { head; /.*/ }.
 next: { head; head }.
 rest: { head; head; /.*/ }.
 push(value): value + "<>" + /.*/.
Redstone

Redstone is used for electronics in the game Minecraft. Although not intended to be a programming language, a compiler is technically possible. All the redstone data is "mostly" boolean. That is, redstone is either on or off, but also has a signal strength of 1-15 if on.
Input can be received from buttons, pressure plates, and many other blocks. Output blocks include pistons, sticky pistons, redstone lamps, dispensers, note blocks, and many other blocks.
https://minecraft.wiki/w/File:Redstone_wire_as_circuit_component.png
Redstone dust transfers power, but the signal strength decreases each block, turning off at a strength of 0. Redstone dust can go up or down 1 block at a time, and connects to all nearby redstone dust. Redstone dust will not connect through opaque blocks. Redstone dust lights up when powered.
To continue redstone signals farther than 15 blocks, a repeater can be used. If there is power behind the repeater, redstone dust in front will have a signal strength of 15 with a editable delay. Powering a repeater by a repeater from the side causes it to "lock," keeping its output constant despite input changes until it is unlocked (no longer powered from the side). Other blocks, such as torches and comparators, also affect the strength of the dust.
A redstone torch is normally on, but when the block it is attached to is powered, the torch turns off. A comparator can either subtract the strength of the side inputs from its main input, or make the input 0 when the side inputs are greater or equal and the main input otherwise. Comparators also have the ability to read from containers, such as chests, hoppers, and lecterns.
Because Minecraft has OR gates (connecting 2 lines of redstone to each other) and NOT gates (redstone torches), any other boolean logic gate is possible, and is a Bounded-storage machine. There are claims that a suitable machine would be able to build an infinite track or tape to elevate this to Turing complete (ignoring the world border). Alternatively, using subtick mechanics, entities can be stacked and seperated from others in the same stack, allowing incrementation and decrementation in a finite space.
Category:2010 Category:Turing complete
Refer

Refer is a programming language that uses referring instead of variables
== Normal ==
=== Print ===
 print "hello"
 printl "hello" #adds a newline
==== Noprint ====
 noprint "hello" #does not print
=== Comments ===
 #its obvious
 #these are comments
 #they tell whats happening in the code
==== Multiline ====
 #*
 hello
 yay
 i can type anything
 *#
=== Lambda ===
 (a:a) "hi" #hi
 (a:a a)(a: a a) #Ω combinator
== Non-Normal ==
=== This ===
refer to the current calculation
 print this #max stack size exceeded
=== That ===
refer to the previous calculation
 (a:a)
 that "hi" #hi
 print "hi" #hi
 print that #hi, no error because of printing print, print is identity function, and when you just have expressions just there, no statements
 #it puts it into output
==== Extension ====
chaining "that"s
 (a:a)
 noprint that
 noprint that
 noprint that
 noprint that
 that "hi" #hi
=== The one <n> line(s) ago ===
refer to one of the ones in the past
 (a:a)
 print "hi" #hi
 print "yay" #yay
 print "ok" #ok
 (the one 4 lines ago) "hi" #hi
== MORE Non-Normal ==
=== The next one ===
refer to the next calculation
 print the next one #hi
 noprint "hi"
==== Future extension ====
chaining the next ones
 print the next one #hi
 noprint the next one
 noprint the next one
 noprint the next one
 noprint the next one
 noprint "hi"
=== The one <n> lines later ===
refer to one of the ones in the future
 print the one 5 lines later #hi
 #nothing
 #ok
 #yeah
 #fine
 noprint "hi"
=== Goto ===
you can use goto to goto the reference
 print "hi" #hi
 goto that #goes back to the previous one
== LESS NORMAL ==
=== A paradox ===
 noprint the next one
 noprint that
== NOTE ==
the lines are kind of variables
 noprint "hi" #effectivly store "hi" in line one
 print that #refers to the value in the previous line
Category:Languages Category:Unimplemented
Reference

Reference is an esolang invented by User:None1 that can read its source code, but not modify it.
==Commands==
 Command table
Command 	Meaning 	Example
[i~j] (i,j are positive decimal integers)	Output the i-th to the j-th characters of the source code	[3~5] prints the third to the fifth characters of the source code
\ 	Escape character 	\x prints x.
Other characters 	Print themselves 	a prints a
When the parser sees a [, it tries to find the nearest ], if there is no nearest ] or the things between the two brackets do not follow the [i~j] format, the [ is treated as Other characters.
Files in Windows use CR+LF as newlines, to avoid this issue, an interpreter removes all CR characters in the source code read before interpreting it.
==Examples==
===Hello, World!===
 Hello, World!
===Quine===
 Quine
===Another Quine (cheating)===
 [1~5]
===Output [===
 \[
===Output ]===
 ]
===Never Gonna Give You Up===
We're no strangers to love
You know the rules and so do I (do I)
A full commitment's what I'm thinking of
You wouldn't get this from any other guy
I just wanna tell you how I'm feeling
Gotta make you understand
Never gonna give you up
Never gonna let you down
Never gonna run around and desert you
Never gonna make you cry
Never gonna say goodbye
Never gonna tell a lie and hurt you
We've known each other for so long
Your heart's been aching, but you're too shy to say it (say it)
Inside, we both know what's been going on (going on)
We know the game and we're gonna play it
And if you ask me how I'm feeling
Don't tell me you're too blind to see
[214~384]
[214~384]
[387~578]
[149~211]
[214~384]
[214~384]
[214~384]
===Truth-machine===
Only works if it supports nested reference (interpret the selected characters), and input 0 prints 0[0~6.
 [11~2x]____[5~5][0~6]
x is the input.
Category:Languages
Category:2023
Category:Output only
Category:Total
category:unusable for programming
RegRep

RegRep is a language that can be compiled down entirely to JavaScript replaceAlls or sed expressions.
==Syntax==
The program is split into two parts, separated by //. The first part is a list of regular expression replacements, in the format of regex/replacement, such as (\d)\d/$1, which matches a pair of digits and replaces it with the first one. \/ can be used for a literal slash, and \\ can be used for a literal backslash. In the replacement, \n can be used for a newline. If the separating slash does not exist, it is implicitly appended to the end. Any line starting with a space will be ignored.
The second part of the program is the input. For problems that contain an "input", such as cat, the input can be appended to the program. All replacements will be run on the input from top to bottom, until no replacements can be done anymore.
==Example Programs==
===Infinite Loop===
a/a
//
a
===Hello, World!===
//
Hello, world!
===Cat===
//
===Truth Machine===
1/1
0
//
===FizzBuzz===
 inc1 -> 2
 inc2 -> 3
 etc.
inc(\d+)/inc0$1~01234567890
(?<=inc.*)(\d)(?=9*~\d*?\1(\d).*?)/$2
inc(.*?)~\d*/inc$1
inc0*(.*?)/evalfive$1
 takes the last number in the input and creates a new line with inc#num#
(\d+)$/$1\ninc$1
 is divisible by 5...
evalfive(\d*[05])(?!\d)/evalthree$1 1
evalfive(\d*)/evalthree$1 0
 is divisible by 3... modified from https://stackoverflow.com/a/10992534
evalthree((?:[0369]+|[147](?:[0369]*[147][0369]*[258])*(?:[0369]*[258]|[0369]*[147][0369]*[147])|[258](?:[0369]*[258][0369]*[147])*(?:[0369]*[147]|[0369]*[258][0369]*[258]))+)\s(1|0)/map$1 1 $2
evalthree(\d*)/map$1 0
 map these indicators to actual words
map(\d*) 0 0/$1
map\d* 1 0/Fizz
map\d* 0 1/Buzz
map\d* 1 1/FizzBuzz
//
evalfive1
==Implementations==
A simple implementation written in JS exists.
class RegRep {
 constructor(input) {
 const parsed = this.parse(input);
 this.reps = parsed.reps;
 this.text = parsed.text;
 }
 parse(input) {
 const parts = input.split('//\n');
 if (parts.length !== 2) throw new Error('Incorrect number of program parts.');
 const reps = [];
 for (const line of parts[0].split('\n')) {
 if (line === ) continue;
 if (line.startsWith(' ')) continue;
 let s1 = ;
 let s2 = ;
 let escaped = false;
 let past_bar = false;
 for (const c of line) {
 if (past_bar) {
 if (escaped) {
 if (c == 'n') s2 += '\n';
 else s2 += c;
 escaped = false;
 } else {
 if (c == '\\') escaped = true;
 else s2 += c;
 }
 } else {
 if (escaped) {
 if (c == '/') s1 += c;
 else if (c == '\\') s1 += c;
 else s1 += '\\' + c;
 escaped = false;
 } else {
 if (c == '/') past_bar = true;
 else if (c == '\\') escaped = true;
 else s1 += c;
 }
 }
 }
 reps.push({ reg: new RegExp(s1, 'g'), rep: s2 });
 }
 return { reps: reps, text: parts[1] };
 }
 step() {
 let ntext = this.text;
 let match = false;
 for (const rep of this.reps) {
 if (rep.reg.test(ntext)) {
 match = true;
 ntext = ntext.replaceAll(rep.reg, rep.rep);
 }
 }
 this.text = ntext;
 return match;
 }
 run() {
 let match = true;
 while (match) {
 match = this.step();
 }
 }
}
Category:Languages Category:2024 Category:Implemented Category:String-rewriting paradigm
RegexPL

RegexPL is a programming language where computation is based entirely on matching strings against regular expressions. The programming language was designed and implemented by Daniel Korsgård in May 2010.
The intention of the programming language was to show how a not too unreasonable programming language could be made, where computations consist entirely on mutation of character strings.
The author of the language was tired of seeing an increasing number of esoteric languages that are essentially copies of existing popular esoteric languages. The author therefore created this RegexPL based on a fundamentally and radically different kind of computation than existing esoteric languages.
==Language overview==
RegexPL is a Turing complete programming language where strings are the only datatype. Only three basic operations are implemented, namely: function call, regex/string matching, and string concatenation.
The syntactical constructs of RegexPL are fairly elaborate, structured, and readable, unlike most esoteric languages.
As a result of the relatively complex grammar rules, refer to the .
A RegexPL program consists of one or more function declarations.
A function consists of a mix of test statements and return statements. Those statements consists of strings, names, index expressions, and concatenation expressions.
Definition:
 def Main()
 ! "Hello world"
Statements:
 def if_A_is_true(A)
 A /^true|TRUE$/ # Tests the string in parameter A against the regular expression /^true|TRUE$/
 ! "Yay, A is true :D" # Return "Yay, A is true :D" if the previous test matched
 ! "Buhuu, A is not true :C" # Otherwise...
Nested tests:
 def hungry(Food1, Food2)
 Food1 /pancake|cookie/
 Food2 /chocolate milk|soft drink/
 ! "very" # Both tests matched
 ! "maybe" # Only first test matched
 ! "no" # First test did not match
Capturing:
 def extract_number(Str)
 Str /([0-9]+)/ # Tests for and captures a number
 ! Str[1] # If a number was found, it will be returned
 ! "" # If no number was found, empty string will be returned
Recursion and Concatenation
 def extract_all_numbers(Str)
 Str /^[^0-9]*([0-9]+)(.*)$/ # Test for number, then capture first occurrence of a number and any text behind number
 ! Str[1] "-" extract_all_numbers(Str[2]) # Concatenate the found number with '-' and any following numbers
 ! ""
==Interpreter==
RegexPL programs are written in plain text files, either encoded as UTF-8 or ASCII.
Currently there is only one known compiler - the original - which will perform parsing, semantical checking, conversion to internal byte code, and lastly execution of that byte code.
==Related Languages==
The computation approach of the language Thue is also based on text replacement, but in a much simpler way.
The computational model of RegexPL was therefore already discovered in the year 2000.
The property of Turing completeness of RegexPL was however discovered independently.
The basic computational model of RegexPL can be reduced to that of Thue.
==External resources==
* RegexPL page
Category:Languages
Category:String-rewriting paradigm
Category:Turing complete
Category:Implemented
Category:High-level
Category:2010
Regimin

Regimin is a minimal 2D Turing-complete esolang by User:PythonshellDebugwindow.
==Program format==
The program is expected to be a perfect square. Whitespace is ignored by the interpreter, and so can be used for formatting.
==Registers==
The three registers are arbitrary signed integers.
==Instruction pointer==
The IP gets stuck on the end, so this:
 >
would be an infinite loop, the IP moving right and hitting a wall.
==Instructions==
 ^>v< : direction change
 1 : increment register 1
 2 : increment register 2
 3 : increment register 3
 4 : decrement register 1
 5 : decrement register 2
 6 : decrement register 3
 7 : conditional skip for register 1
 8 : conditional skip for register 2
 9 : conditional skip for register 3
Conditional skips skip the next instruction in the current direction if register N is 0.
==Examples==
Set the registers to 0 each:
 >7v>8v>9v
 4 5 6
 ^ <^ <^ <
==Computational class==
Regimin is Turing-complete through prime factorization, and the conditional skips provide enough flow control.
==External resources==
* A graphical interpreter written in Python that displays the IP's path and the registers on every tick
Category:2020 Category:Languages Category:Implemented Category:Turing complete Category:Turing tarpits Category:No IO Category:Two-dimensional languages Category:Low-level
Register

Register is a language designed to be as close to the programming language of basic computers.
Created by User:WhyNot? Work In Progress!
=== Memory and Registers ===
Register has 4 registers, 0-3. It also has infinite memory. But the thing is, the program is saved in the memory!
Example:
 * this line is a byte in the memory with the address 0
 * same thing, except address 1
 * etc.
(btw, * are comments)
Each instruction/variable takes up 1 byte in the memory. You set the memory when you run the program. Then, the computer runs the code starting from memory address 0. Important! Each byte must take up it's own line.
=== Commands ===
Each command is in binary, which is then converted into hex.
 00000000 * End program
 001; memory location(5 bits) * Jump
 010; 0 for output, 1 for input; register (2 bits);00 * Input/Output
Register Automaton

Register Automaton is a simple esolang invented by User:A which only has 1 instruction:
 @x=y?Lx
==Explanation==
 Flip cell x. If that content is equal to the content of cell y, go to line Lx.
==Example==
 @0=1?L100
 @1=0?L0
It is an infinite loop, changing cells 0 and 1 forever.
==Computational Class==
Since a program can only access the cells mentioned in it, which are bit valued, there is no unbounded memory. Register Automaton is therefore at most a finite-state automaton.
Category:Languages Category:2018 Category:Finite state automata Category:Unimplemented Category:OISC
Registry

A Registry is the most common data model used in computing for non-esoteric languages, but is rarely used in esolangs.
== Operations ==
A traditional registry consists of a number n-1 (usually where log2(n)∈ℕ) of "registers" that, when using unsigned integers, can hold any value from 0 to m where m≥n. Less traditional registries have dynamic type, but still must be able to map all registers to a value.
=== Interaction ===
The following table lists operations used for interacting with a registry, including the operation, its name, its meaning, and an example in "Generic Registry Language" (GRL), a language used solely for example purposes. 
Op 	Name	Meaning 	GRL
SET r v 	Set 	Set Regs[r] to v 	REGS[r]←v
MOV r1 r2	Move	Set r2 to the value held in r1	REGS[r1]←REGS[r2]
Category:Data Types and Structures