nyuuzyou/wikis huggingface dataset:
RomanF

romanF is a Brainfuck derivative, but using Roman numerals. It is made by User:Gilbert189.
==Translation to Brainfuck==
romanF	Brainfuck
I 	+
V 	-
X 	>
L 	<
D 	.,
C 	[
M 	]
==Conversion to Arabic numeral==
Using straight-up Roman numerals is fine, but using Arabic number is supported as well (and probably even more challenging to program with). Here's an example of romanF program, written in Arabic numerals:
 600 500 1000
The numbers are then converted into Roman numerals:
 DC D M
Then the numbers are combined into one:
 DCDM
==Examples==
===HELLO program===
 IIIIIIIICXIIIIIIIIILVMXCXIXILLVMXDCVMXVVVCLILIXXVMLDCVMLIIIIIIICXIXILLVMXDCVMXCLILIXXVMLDCVMLIIICXIXILLVMXDCVMX
or in Arabic numerals:
 3 3 2 113 3 3 55 1090 19 1 50 55 1010 605 1015 5 5 151 59 15 1050 605 1053 3 1 119 1 50 55 1010 605 1090 51 59 15 1050 605 1053 119 1 50 55 1010 605 1010
===Cat===
 DCDM
or in Arabic numerals:
 600 500 1000
==External resources==
* The interpreter
Category: Languages
Category: Brainfuck derivatives
Category: Implemented
Rotary Quine

A rotary quine is a program P with the following properties:
# P must not contain any comments or unnecessary whitespace or similar.
# P is a quine.
# P must not be just a number of copies of a single character. Equivalently, P has at least one rotation Rx where Rx is not equal to P.
# All rotations Rx must be quines.
== Examples ==
In HQ9+ the quine Q+ would be a rotary quine.
Category:Program forms
Rotpai

Rotpai is an esoteric programming language made by User:Mipinggfxgbtftybfhfyhfn.
==Syntax and execution==
A Rotpai program is a list of ordered pairs of characters:
 ah ba bd fg
Each line of the program is independent of every other line unless the last character of the last pair in it is ., then the line with this property and the next line are considered to be just one line:
 a.
 bc
is the same as:
 a. bc
At each step of the program, to generate the next state, the interpreter goes through this process for each pair:
# If the pair doesn't match in any of its ends to the adjacent pairs, it is rotated (ab ca cd => ab ac cd)
# If the pair matches in one of its ends, it is swapped with the pair at the end (ab ac cd => ab cd ac)
# If the pair matches on both of its ends, do nothing to it (ab bc cd => ab bc cd)
An end touching the edge is considered to always match.
The program halts when none of the pairs can be rotated.
==Computational Class==
Rotpai's computational class is unclear, but it is most likely a finite state automaton.
==Examples==
===Simple Rearrangement===
The program
 ab cb cd
requires a single cycle for its patration's accomplishment, limning the following trajectory:
 ab cb cd
 ab bc cd
===Line Continuation===
This program
 a. b.
 d. .e
perambulates across the evolutions
 a. b. d. .e
 a. .b .e d.
 .b .e a. d.
 .b e. .a d.
until no internal rotation may be applied anymore.
==Interpreter==
* Common Lisp implementation of the Rotpai programming language.
Category:LanguagesCategory:2019Category:Unknown computational classCategory:Implemented
Rotten

Rotten is a joke esolang whose programs can have 2 forms:
* <string> - Implicitly converted to 13$<string>
* <n>$<string> - Unescape the string (i.e. \n becomes a newline), with \i becoming a byte of input (if one doesn't exist then null bytes are assumed), then print it in ROT-<n>
== Examples ==
=== Hello, World! ===
0$Hello, World! or Uryyb, Jbeyq!
=== Cat ===
(only works for 5 bytes of input)
\i\i\i\i\i
=== Fibonacci Sequence ===
Rotten is so convenient to program in, that if your program is a sequence, then the sequence elements (although only the ones you specified) are printed!
1, 1, 2, 3, 5, 8, 13
(prints 1, 1, 2, 3, 5, 8, 13)
==Interpreter==
Written in NodeJS.
function rotten(code)
{
 if(code.match(/^[0-9]+(, ?[0-9])*$/))
 console.log(code.replace(/,([^ ])/g, ", $1"));
 else if(code.match(/^[0-9]+\$/))
 console.log(rot(code.replace(/^[0-9]+\$/, ""), parseInt(code.split("$")[0])));
 else
 console.log(rot(code, 13))
}
function rot(s, n)
{
 let res = "";
 for(let i = 0; i < s.length; ++i)
 {
 if(s.charAt(i).match(/[A-Z]/))
 {
 res += String.fromCharCode((s.charCodeAt(i) - 65 + n) % 26 + 65);
 }
 else if(s.charAt(i).match(/[a-z]/))
 {
 res += String.fromCharCode((s.charCodeAt(i) - 97 + n) % 26 + 97);
 }
 else
 {
 res += s.charAt(i);
 }
 }
 return res;
}
Category:Languages Category:Joke languages Category:Total Category:Unusable for programming Category:Implemented
Rube Goldberg

Rube Goldberg is a language created by the Stack Exchange user Mega Man for the code golf challenge "Rube Goldberg".
== Syntax ==
In this language, every program outputs "Rube Goldberg" (without the quotes).
== Interpreters ==
This is a really short interpreter in Python 3:
 print("Rube Goldberg")
Category:Languages
Category:Joke languages
Category:Unusable for programming
Category:Output only
Category:Implemented
Rubik's Cube

Rubik's Cube is an esolang by User:Tommyaweosme where every rubik's cube algorithm is a valid program. (It adds on missing brackets at start and end)
== Commands ==
 L <
 R >
 F +
 B -
 U [
 D ]
 U2 .
 D2 ,
== Ascii loop ==
 F U U2 F D
This leaves the Rubik's Cube like this:
== Print "A" ==
 F F U R F F L B D R U L F F R B D L U R F F L B D R U R F R F R F R F R F R F R F R F L L L L L L L L D R R R R R R R R F U2
This leaves the Rubik's Cube like this:
== Checker pattern ==
Depending on which way you do it, this can either be a one-time cat, do nothing, crash certain brainfuck emulators, print start of text, print ■ (or þ depending on the emulator), or do something else I haven't figured out yet.
== Nikolas algorithm ==
This triggers unescapped bracket loops and prints a single character (ASCII 0).
== Cat program ==
 U2 D2
This leaves the Rubik's Cube like this:
Category:Languages Category:Brainfuck derivatives Category:Brainfuck equivalents Category:Turing complete Category:Turing tarpits Category:Cell-based Category:Low-level
Rubyで作る奇妙なプログラミング言語

Rubyで作る奇妙なプログラミング言語　～ヘンな言語のつくりかた～ ("Making Esoteric Programming Languages in Ruby ~How to Make Weird Languages~") is a Japanese book about esoteric programming languages written by Yutaka Hara. It uses Ruby as an implementation language. The book covers concepts like Turing machines, Turing completeness and virtual machines, as well as the languages (chronologically) HQ9+, brainfuck, Whitespace, Starry, Bolic, Befunge, Wierd, Shakespeare, Chef, Unlambda, Grass, False, NULL, AAAAAAAAAAAAAA!!!!, INTERCAL, Malbolge, KEMURI and Taxi.
The book was originally published in December 2008, but went out of print. It was due to be reprinted in dead tree and PDF formats on January 7 2014.
==Editions==
*First edition: 2008-12-20, Dead tree, ISBN 978-4-8399-2784-4
*Second edition: 2014-01-07, Dead tree & PDF, ISBN 978-4-8399-4953-2, Mynavi
==External resources==
*Official site
*Source code from the book on GitHub
Ruck

Ruck is an esolang invented by User:None1, it has one extra command than Minimized BF: < and its tape has infinite size, making it Turing complete.
==Examples==
===Hello World (unoptimized)===
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++>
===Cat program===
===Truth Machine===
This program works on the original language (Minimized BF) as well, and since non-interactive I/O is used, the program doesn't print 1 when the input is 1, instead, it runs an infinite loop which exausts infinite memory by rewriting all the cells with the ASCII values of 1, which is 49.
 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++[>+++++++++++++++++++++++++++++++++++++++++++++++++]
==Implementations==
The following Python-script is an interpreter
tape = [0]
for i in range(0, 65536): # Expand
 tape.append(0)
pointer = 32768
prgm = input('>Ruck ')
init = input('>i ')
for i in range(32768, len(init)+32768): # Expand
 tape[i] = ord(init[i-32768]) # Expand
# Executes the program
loop_table = {}
loop_stack = []
for ip, inst in enumerate(prgm):
 if inst == "[":
 loop_stack.append(ip)
 elif inst == "]":
 loop_beginning_index = loop_stack.pop()
 loop_table[loop_beginning_index] = ip
 loop_table[ip] = loop_beginning_index
inst = 0
while inst < len(prgm):
 if prgm[inst] == "+":
 tape[pointer] += 1
 tape[pointer] %= 256
 elif prgm[inst] == "<":
 pointer -= 1
 elif prgm[inst] == ">":
 pointer += 1
 elif prgm[inst] == "[":
 if not tape[pointer]:
 inst = loop_table[inst]
 elif prgm[inst] == "]":
 if tape[pointer]:
 inst = loop_table[inst]
 else: pass
 inst += 1
pointer = 32768 # Expand
while tape[pointer]:
 print(chr(tape[pointer]), end="")
 pointer += 1
64K implementation, but it can be expanded.
Category:Languages
Category:Brainfuck derivatives
Category:2023
Category:Implemented
Category:Turing complete
Ruined BASIC

Ruined BASIC is an overly simplified BASIC dialect invented by User:A in order to break what people think of BASIC (a very easy to use language).
== Documentation ==
In practical programs, the only constant that can appear is the constant 1. All variables are set to 0. Variable names were limited to A to Z (which stores integers, non case-sensitive), giving a maximum of 26 possible distinct variables. 
rem rem: Comments
rem Example
 10 rem Stops
rem let: Initialize ariables
rem Structure: let variable expression
rem This sets the variable to variable - expression.
 10 let A 123
rem if: Conditional statements. Checks if the variable A is equal to 0.
rem Structure: if expression line-number
rem Expressions in if statements can only contain one lexical item.
 20 if 40
rem There is an alternate version if var 40, which is what all examples use.
rem input: input A from the keyboard
 30 input
rem print: Output A to console
 40 print
==Example programs==
10 input A
20 if 70
30 let B 10
40 let A B
50 print A
60 if z 10
70
rem Uncondtional jump simulator
rem This simulation jumps to line 12.
rem make sure that the accumulator a was 0.
11 if 12
12 rem goes to here.
13
===Cat program(limited to integers)===
10 input a
20 if a 50
30 print a
40 if z 10
50
===Copying values===
10 rem This copies the value of z to a.
20 let b b
30 let b z
40 let a a
50 let a z
== Computational class ==
It could be compiled to the Minsky machine with 2 registers quite easily. Make sure that there are line numbers.
INC a, b :=
let c 1
let a c
rem sets a -> z (preserves a)
let j j
let j a
let z z
let z a
rem sets a to 0
let a a
rem jump!
if b
Recovery process:
rem copies the content of z to a (recovering a)
let j j
let j z
let a a
let a z
JZDEC a, b, c :=
rem TODO
let a 1
if b
rem preserves a
let j j
let j a
let z z
let z j
let a a
if c
Recovery process:
rem copies the contents of z to a
rem copies the content of z to a (recovering a)
let j j
let j z
let a a
let a z
Category:Unimplemented
Category:2019
Category:Languages
Category:Turing complete
Category:Turing tarpits
Rule

Rule is a slide-rule-oriented esoteric programming language by User:Rdococ.
== Semantics ==
Rule programs operate on a slide rule, consisting of an unbounded array of slideable sections.
The only statement is section1:x::section2:y. It slides section1 such that the number x on section1 aligns with the number y on section2. section1 and section2 must name a section, while x and y can either be a number or the other instruction. If both sections are linear, this is equivalent to the assignment section1 = section2 + x - y.
An expression (the x or y above) can either be a numerical constant or section1:x::section2, which represents the number on section2 that aligns with x on section1. With two linear sections this is equivalent to section2 - section1 + x.
Attempting to slide a fixed segment will break the slide rule, causing all future assignments to fail and future expressions to return completely random numbers. While segments are unbounded and expressions can return infinity (e.g. LogFixed:0::LinFixed), if a segment is slid off to infinity, it will fly off the slide rule and can no longer be used. If this happens to the instruction pointer, the program halts immediately.
== Sections ==
The slide rule is split into several sections which may or may not be slid by the program.
Slide 	Slideable?	Description
LogFixed	No 	A fixed, base-e logarithmic scale.
LinFixed	No 	A fixed linear scale.
AbsFixed	No 	A fixed absolute value scale.
Log 	Yes 	A slideable, base-e logarithmic scale.
Output 	Yes 	An output scale. When slid, the value at LinFixed:0::Output modulo 256 is rounded to the nearest ASCII code and printed.
IP 	Yes 	Slides left to the next integer after the execution of each instruction. LinFixed:0::IP is the index of the current statement.
Referencing a non-existent slide names creates a new linear slide rule.
== Computational class ==
The language describes a machine with unbounded memory, but limited to absolute addressing. The program can freely add, subtract, multiply, divide and get absolute values, as well as perform a computed GOTO by sliding the IP rule. This can be used to emulate a Minsky machine, which is sufficient for Turing completeness.
You can perform a conditional jump with the following steps:
# Stick to odd integers for all your register values to avoid breaking the slide rule. Represent 0 with -1 and all higher values with odd positives like 1, 3, 5, etc.
# Select a number and divide it by its absolute value. This returns -1 if the register is at "zero" and 1 otherwise. Add 1 and divide by 2 to get 0 or 1 depending on the register's value.
# Multiply the condition by one destination IP and multiply 1 minus the condition with the other destination. Finally, add them together and slide the IP to complete the conditional jump.
Category:Unimplemented Category:Turing_complete Category:2017 Category:Languages Category:Thematic
RunR

RunR is an esoteric programming language by User:David.werecat that works in a two dimensional space known as "The Grid".
==Instructions==
Instruction 	Description
S 	The start of the program
I 	An input generator, when hit it reads a value from the input and stores in the current number
O 	An output device, when hit it writes the current number to the output
F 	The end of the program
^ 	A stack action, pushes the current number into the stack
v 	A stack action, pops a value from the stack and stores it in the current number
A 	A valutory operator, adds the current number and the next value in the stack and stores it in the current number
U 	A valutory operator, subtracts the current number and the next value in the stack and stores it in the current number
M 	A valutory operator, multiplies the current number and the next value in the stack and stores it in the current number
D 	A valutory operator, divides the current number and the next value in the stack and stores it in the current number
0 to 9 	Predefinitions, sets the current number to the given value
% 	A modular selector, if the current number is zero, sets the current value to true, otherwise sets the current value to false
$ 	A matrix retriever, it pops a value from the matrix stack and stores it in the current number
& 	A matrix signaler, it pushes the current number into the matrix stack
( and ) 	Focusers, the unconditionally redirect moment to the direction that they are pointing
/ and \ 	Reflectors
- and |	Walls, when hit from the side no reflection occurs
+ 	A multidirectional wall, causes a reflection from any direction
# 	A conditional gate, when the current value is false, reflection occurs
! 	A negatory operator, performs not on the current value
T 	A value field, sets the current value to true
@ 	A conditional jump, when the current value is true, the next instruction is skipped
< 	A left turntable, it rotates movement left by 90 degrees
> 	A right turntable, it rotates movement right by 90 degrees
~ 	A rest zone, it causes a brief pause in the program
* 	A audial trap, it causes a beep to sound
When the current number goes below 0 or above 255, it simply stops at the high value. Spaces are NOPs. Any other characters results in an error.
==Examples==
===Hello, World!===
 S9^A^A^&AO^\
/OAAv^M3^9^2^/
\^7AOO^\>$UOF
/ OA3/^
\$^&8AO\3
/OU&$^4/O
\7^8AAO\A
/&AA^6^/1
\^6^AAO\^
/&$OA3^/$
\^9AO <
== External resources ==
* Visual Basic .NET interpreter and sample programs
* NodeJS interpreter
Category:Languages
Category:2011
Category:Unknown computational class
Category:Implemented
Category:Two-dimensional languages
Run On Off

Run On Off is an meta-language and matrioshka language designed so it can be interpreted with just an interruptor that turn on/off a light, the human brain and a paper sheet for IO functions.
==Syntax==
A Run On Off program consists of many statements with the syntax:
 statement: value
Or, if it has substatements:
 statement:
 substatement1: value1
 substatement2: value2
 substatement3: value3
 ...
 substatementN: valueN
There are three main statements: on, off and any. Each has substatements with the sintax:
 numberOfRepetitions: instruction
Or, also:
 any: instruction
Finally, there is an optional input statement, which transforms Run On Off into a matrioshka language, being the value of this statement the secuence of "ons" and "offs" to exec. The input statement syntax is:
 input: on/off secuence
===Instructions===
==Implementation==
Category:Languages
Runespells

Runespells is an esoteric programming language made by TehZ.
== Language type ==
The language is a functional language, as each rune is a function which can be passed around with the stack and which can be put in variables. However, data can be edited, so some people might not consider it functional.
== Overview ==
In runespells, there is a concept of runes, which are basically functions. Each rune can have six variables, acting as arguments:
Variable	Pronunciation
Fa 	FAH
Rin 	rin
Gora 	gõ-ra
Jyiku 	schiKU
Nahy 	na-HY
Zeha 	zeHA
There is also a global stack of runes. You start out by defining all the runes existing like this:
 Rune <rune id>[<id of variable Fa>, <id of variable Rin>, etc]: 
Note that you don't need to define every variable, but you do need the []'s. I will tell you about the code a little later.
However, you do need some way of defining the code that needs to be ran. To choose the main rune, called the "Spell", you write:
 Spell [<variables>]: 
As you see, there are two differences: There is no id, and it's "Spell", not "Rune". Now I will tell you about how the code works.
The code consists of a list of commands, most don't have arguments (Actually, only Giyah has arguments). The commands are:
Command 	Pronunciation 	Effect
Zi 	si 	Enhance the top rune with the code in second top rune and pop both.
Yah 	jaar (or better, Yah as in Yahweh)	Pop and execute top rune.
Ni 	n-IH 	Pop and disenhance top rune.
Giyah <rune>	gi-AH 	Replace the rune <rune> with the rune with the id that equals the number of commands in the top rune and pop the top rune.
Ne 	neh 	No-op.
Mizo 	mi-SO 	Output ascii character corresponding to the number of commands in the top rune and pop the top rune.
Mizi 	mi-SI 	Push a rune with no-ops corresponding to an ascii character read.
<rune> 	  	Push <rune>.
Lafi 	LA-fi 	Duplicate top of stack.
Chizo 	CHI-so-o 	Go to start of rune.
Chixo 	CHIK-so 	Go to start of rune if the stack is empty.
Chiyo 	CHI-yo 	Go to start of rune if the stack is not empty.
Nahweh 	NAH-WEHY 	If the number of commands in the third top rune equals the number of commands in the top rune, execute the second top rune after popping both.
Tazi 	TAH-ZI 	Pop.
Gorpdne 	GORP-NEH 	End program. (Fun fact: If you reverse "endproG" you get "Gorpdne")
== Computational Class ==
Well, I don't know.
== Examples ==
===Counter===
Keep printing numbers, reading a character each time, and if the character read is 0, end the program.
 Rune 1[2, 3]: Rin Fa Zi
 Rune 2[]:
 Rune 3[]: Ne
 Rune 4[]:
 Rune 5[]: Gorpdne
 Spell [1, 2, 4, 5]: Rin Mizo Fa Yah Mizi Jyiku Gora Nahweh Chizo
===Cat program===
An infinitely repeating cat program follows:
 Rune 1[]: Mizi Mizo Chizo
 Spell [1]: Fa Yah
===Truth-machine===
This program implements a truth-machine:
 Rune 1[]: Ne
 Rune 2[1]: Fa Mizo Chizo
 Spell [1, 2]: Fa Rin Mizi Lafi Mizo Nahweh Gorpdne
==Interpreter==
* Common Lisp implementation of the Runespells programming language.
Category: Implemented Category:Languages
Rеlаng

(or is it?)
Rеlаng is the simplest regular expression based language. Programs consists of two strings, each cycle, both strings replaces the first match using the other string as a regular еxpression with the other string, or remain unchanged if there are no matches. Execution terminates when both strings do not change after one cycle. This may not happen: many expressions tend to grow quadraticаlly. When displaying a program, it is recommended to display it as a single string with the two strings separated by easily recognizable separators such as [][][] or █████.
== Examples ==
Nоte: nо gооd examples yet!
Side note: This language use . as a wildcard.
The typical execution sequence:
 a{3} [][][] (aaa)?a\{3\}
The typical quadratic growth:
 abc|a?b?c? [][][] a?b?c?|abc
Demonstration of . (creates a "slow growth"):
 . [][][] a?.
== Computational class ==
 Insert Turing-completeness proof here
== Implementation ==
With the help of the rе module, Python interpreters of Rеlаng can be amazingly short:
 import re
 str1 = input("First expression: ")
 str2 = input("Second expression: ")
 while True:
 temp1 = str1
 temp2 = str2
 match1 = re.search(str2, str1, re.DOTALL)
 match2 = re.search(str1, str2, re.DOTALL)
 if match1:
 span = match1.span()
 str1 = str1[:span[0]] + temp2 + str1[span[1]:]
 if match2:
 span = match2.span()
 str2 = str2[:span[0]] + temp1 + str2[span[1]:]
 print(str1 + ' █████ ' + str2)
 if (str1, str2) == (temp1, temp2):
 break
Category:2024
Category:Implemented
Category:No IO
Category:Unknown computational class
Category:String-rewriting paradigm
Category:Self-modifying
S*bleq

S*bleq is a derivative of Subleq by User:ChuckEsoteric08
==Differences==
Now the command
 a b c
Would subtract memory address b from memory address a, storing result in later, and then if the result is less or equal to zero go to the memory address mem[c]
===Special addresses, none of which could be in c===
 -1 IP
 -2 returns next byte of user input
 -3 outputs value of another address
===Variations===
====S*bl*q====
In this version the result of subtraction is stored in both a and b
====Subl*q====
In this version result of subtraction is stored in b
====S**bleq, Subl**q, S**bl**q====
In this version arguments a and b are replaced by mem[a] and mem[b] respectively
==Computational class==
As they are simply derivatives of Subleq, all of them are Turing-complete
==Subl*q interpreter by accident==
It's 100% by mistake! The interpreter exists before this language is created!
Category:Languages Category:Turing complete Category:OISC Category:Self-modifying Category:Implemented