nyuuzyou/wikis huggingface dataset:
RNA

RNA is a totally useless esoteric programming language created in 2008 and implemented in 2011 by Cyrus H..
== Syntax ==
There are 16 instructions(49 codons) in this language.
Also, there are three special storages, which are used to handle data. They are:
* strg - a 8-bit(1 Byte) cell that is used to manipulate memory index storage, ptr. Internally, this storage is declared as unsigned char.
* ptr - a 32-bit(4 Bytes) memory index storage. In 64-bit platforms, this storage uses 64-bit(8 Bytes). Internally, this storage is declared as unsigned char *.
* memory - a serial storage that contains 8-bit(1 Byte) cells. Theoretically, there is no limit to this storage. The only limit is the physical memory, RAM. Internally, this storage is declared as unsigned char [].
Following list contains all the instructions defined in this language.
# Methionine (Met.)
#* AUG
#* Program activation indicator. Codons prior to this will simply be ignored.
# [None] (Ter.)
#* UAA, UAG, UGA
#* Program termination indicator. Codons after this will simply be ignored.
# Tryptophan
#* UGG
#* strg=0
# Lysine
#* AAA, AAG
#* ++strg
# Asparagine
#* AAC, AAU
#* --strg
# Alanine
#* GCA, GCC, GCG, GCU
#* strg=*ptr
# Threonine
#* ACA, ACC, ACG, ACU
#* ptr=&memory[strg]
# Proline
#* CCA, CCC, CCG, CCU
#* scanf(“%d”, ptr)
# Leucine
#* CUA, CUC, CUG, CUU
#* printf(“%c”, *ptr)
# Arginine
#* AGA, AGG, CGA, CGC, CGG, CGU
#* *ptr+=memory[strg]
# Serine
#* AGC, AGU, UCA, UCC, UCG, UCU
#* *ptr*=memory[strg]
# Glutamine
#* CAA, CAG
#* *ptr-=memory[strg]
# Histidine
#* CAC, CAU
#* *ptr/=memory[strg]
# Glutamic acid
#* GAA, GAG
#* *ptr=*ptr==memory[strg]?1:0
# Aspartic acid
#* GAC, GAU
#* Loop activation indicator. This will initiate while(*ptr) immediately and proceed to next codon. If the *ptr is equal to zero(0), this will move interpreter’s execution pointer to a codon just after the paired loop termination indicator.
# Tyrosine
#* UAC, UAU
#* Loop termination indicator. This will move interpreter’s execution pointer back to the paired loop activation indicator.
# Cysteine
#* UGC, UGU
#* No-Op. Reserved for future implementation.
# Phenylalanine
#* UUC, UUU
#* No-Op. Reserved for future implementation.
# Isoleucine
#* AUA, AUC, AUU
#* No-Op. Reserved for future implementation.
# Glycine
#* GGA, GGC, GGG, GGU
#* No-Op. Reserved for future implementation.
# Valine
#* GUA, GUC, GUG, GUU
#* No-Op. Reserved for future implementation.
== Implementation ==
* RNA Implementation in C - Written in C, conforming C99. Successfully compilable with GCC under Mac OS X.
== Dialect ==
=== DNA ===
The DNA Programming language is basically a dialect of the RNA Programming Language. The instructions from RNA and DNA are one-to-one matching. Converting a program from RNA to DNA is very easy task; just Find & Replace each instructions. For more information, read DNA subdocument.
Category:Languages
Category:2008
Category:2011
RNDM

RNDM is a really really random language
RNDM is a misspelling of RANDOM
==RNDM unshackled==
RNDM unshackled is Neucomp
Neucomp is my Esoteric Assembly Language (EAL)
This might hurt your Brain
==Encryption==
==Code==
===Truth Machine===
In Neucomp
 In 1
 Let 10 1
 Let 20 0
 If 1 = 20
 Out 20
 End
 If 1 = 10
 Out 10
 Go 8
 End
 Go 4
Category:Languages
ROT-13

ROT-13 is an extension of the ROT13 encoder/decoder invented by User:A.
==Alphabetic characters==
They are simply rotated using this following lookup table:
ABCD...WXYZ
NOPQ...JKLM
==Other characters==
@9f = fffffffff
-AZ = ABCD...WXYZ
123123^ = 321321
Category:2019
Category:Languages
Category:Unimplemented
Category:Output only
Category:Total
Category:String-rewriting paradigm
Category:Unusable for programming
ROT13-Ruby

Ruby encoded in ROT-13 (Caesar Cipher with a shift of 13)
Another name for ROT13-Ruby is Ehol (which is Ruby in ROT-13)
The file extension is .rb13 or .ehol
==Examples==
===Hello World===
 chgf "Uryyb, jbeyq!" # chgf is puts and "Uryyb, jbeyq!" is "Hello, world!"
==Interpreters==
===Ruby===
 #!/usr/bin/env ruby 
 def rot13 text
 text.tr 'A-Za-z', 'N-ZA-Mn-za-m'
 end
 code = File::read ARGV[0]
 eval rot13 code
Category:Joke languages
Category:Implemented
Category:Object-oriented paradigm
Category:Languages
Category:Turing complete
Category:High-level
ROT13 encoder/decoder

A ROT13 encoder/decoder is a program that applies the ROT13 cipher to its input text. ROT13 is a simple Caesar cipher that is its own inverse. It has no serious use in cryptography, but it's a popular problem and a simple way to hide messages that are meant for others to read at their own discretion (for example, puzzle solutions and plot spoilers).
A ROT13 encoder/decoder reads in data, and changes letters A, B, C, D ... W, X, Y, Z (as well the ones in lowercase) to N, O, P, Q ... J, K, L, M. The name "ROT13" comes from this behaviour: each letter is being rotated half-way around the Roman alphabet, that is, 13 positions.
For example, if we give a ROT13 program the following data
 Hello world! ;)
it should print out
 Uryyb jbeyq! ;)
Every character that is not in the Roman alphabet, i.e. which does not have a decimal ASCII value in the ranges 65-90 or 97-122, remains the same, like the ;) in the above example.
As ROT13 is its own inverse, there is no need to write separate encoder and decoder programs - a single encoder/decode program does both jobs. For example, giving a ROT13 program the data
 Uryyb jbeyq! ;)
should return it back to the form it was in the beginning, that is
 Hello world! ;)
==External resources==
* contained ROT13 implementations in many languages.
Category: Program forms
ROTfuck

ROTfuck is a variation of brainfuck by User:PythonshellDebugwindow.
==Commands==
Command	Description
+ 	Increment the memory cell under the pointer
- 	Decrement the memory cell under the pointer
> 	Move the pointer to the right
< 	Move the pointer to the left
, 	Input a character and store it in the cell at the pointer
. 	Output the Unicode character signified by the cell at the pointer
[ 	Jump past the matching ] if the cell under the pointer is 0
] 	Jump back to the matching [ if the cell under the pointer is nonzero
==Automatic command rotation==
Every time an instruction is executed, all non-comment characters in the source code are rotated right once (after the instruction is executed) along +-><,.[], meaning + -> -, - -> >, ..., ] -> +.
==Examples==
===Hello, World! Created by User:Apollyon094 ===
 <.>]-,]>]>,][,.->].,[,+-+<..[[<>]><.-[,+<>->-<+<>]<[,.,-+<>][[+<++,.-+-.
===One-character cat===
,[
Category:Languages Category:2020 Category:Brainfuck derivatives Category:Turing complete Category:Cell-based Category:Low-level Category:Unimplemented Category:Brainfuck
RPNCalc

RPNCalc (technically RPNCalc V4) is a Turing-complete, stack-based, dynamically-typed (vaguely *useful*) programming language that originally started off as a calculator on osmarks.net. It has 2 'dialects', a JS-based interpreted dialect and a dialect that compiles to x86-64 on Linux (sometimes referred to as RPNCC - RPNCalc Compiled). Both the dialects have the same syntax, but subtly different semantics.
== Language Features ==
RPNCalc has support for inline lambdas, curried functions and closures. Lambdas can either be constructed in 'forth-style' (with arguments flipped):
 (swap; a b -> b a)
or
 (a b -> b a)
or 'curried style' (with arguments being popped off the stack one-by-one):
 (swap; b -> (a -> b a))
or
 (b -> (a -> b a))
Lambdas in RPNCalc return a list that represents their stack in a 'return stack' when they finished executing, which is subsequently merged back into the parent stack. To have support for higher-level functions, when a Lambda's return stack returns a nested lambda, the nested lambda is immediately applied onto the stack.
RPNCalc additionally has support for recursive local definitions, for example:
 (def1; code executed upon definition)
 (def2; def2 is a recursive definition)
The other major part of RPNCalc syntax is the special 'push' operator, which allows the user to avoid the merging process when a function returns, instead pushing a closure to the stack. Here, the dialects differ; if in the JS dialect you push a return stack, each element of the stack is pushed to the parent stack, while in the x86-64 version a pointer to the list is pushed instead. For example, in RPNCC:
 (# include list #)
 [ 1 : 2 : 3 : 4 : 5 : 6 ] '(x -> x 1 +) map
== RPNCC StdLib ==
RPNCC exposes an assembly interface, and through it some useful functions are defined. These functions are grouped into RPNCC modules, namely:
* arith
* list
* bool
* mutref
* io
arith exposes the basic arithmetic functions +, -, * and /
list exposes the 'nil list' ([] or [) and the 'cons/pair' operator (: and ])
bool exposes the comparison operators &= (equality by reference), == (recursive equality), the booleans true and false, as well as the 'if-else' branching operator (if-else or ?:)
mutref exposes mutable references, through the <> operator (construct a mutable reference with a given value) the << operator (set a mutable reference to a given value and return the reference) and the >> operator (extract a value from a mutable reference).
io exposes the IO operations putchar, putbyte, and putint.
Category:Languages Category:Turing complete Category:Stack-based Category:Implemented Category:Output only
RRF

RRF is short for Reverse-ReverseFuck and it uses the commands of ReverseFuck but the program is written backwards. Every valid Brainfuck program is a valid RRF program but a different function. You can also write program that is the same function in Brainfuck as RRF (a polyglot program):
 ,[.,].
and
 +[,[.,]][[.,].]-
You can also do another variation PRRF (Palindrome-Reverse-ReverseFuck) that requires you to write half of the program (the second half) and it writes the rest itself, just like the programs above are, so you would write:
 ,].
and
 [[.,].]-
Category:Brainfuck equivalents
Category:Turing complete
Category:Cell-based
Category:Implemented
Category:2006
[[Category:Languages
RSRPL

Welcome to the Robert's Super Romanian Proggraming Language wiki! Yes the wiki is in english,but the proggraming language is in romanian ;)
this is an esolang,dont get mad on me if you will use translate more than ever in your life XD
NOTE THIS ONLY WORKS ON WINDOWS,macOS and Linux support in the next updates!
==Running Code==
You need to run it in a terminal and type python src and it will ask about the name of the file. Put the name of the file wihout the extension(.rspr) and it will run your code
==Syntax==
===Variabiles===
There is just one variabile type:numerical RSRPL runs on Python,so it automaticly asigning the type of variabile.
Example:
 x = 10
===Printing===
The print() equivalent in RSRPL is arata sau afiseaza is the same thing.
Examples:
 arata "so good"
 arata x
===Taking user input===
Unfortunaty,user input can only be numerical.The equivalent of input() in RSRPL is intrare
Example
 intrare x
===Coments===
The RSRPL comments are the same as in python btw
Example
 # this is a verry bombastic comment :)
==Logic==
===If else statement===
If statements are replaced by the word daca and have currly braces.Same for else but else is replaced with altfel
Example
 daca x > y {
 # something
 } altfel {
 # idk
 }
===While loop===
While loops are replaced with cat.Unfortunatly,RSRPL BETA(current version) hasn't got boolean suport,but you can replace boolean values with statements:
Example
 x = 0 # true statement
 cat x < 10 {
 # lol
 }
==Example code==
x = 10
y = 11
intrare x
intrare y
daca x > y {
 afiseaza "x e mai mare"
} altfel {
 afiseaza "y e mai mare"
}
==External resources==
* The language's GitHub repository
* The language's GitHub wiki
Category:Languages Category:2024 Category:Implemented
RSSB

RSSB is an esoteric programming language which implements a Turing Complete single instruction computer.
==Overview==
RSSB stands for Reverse Subtract and Skip if Borrow, taking the principles of RISC to the extreme. The specification defines one instruction, RSSB. Each instruction has one operand, a pointer into memory. There are two registers, IP the instruction pointer, and ACC the accumulator.
The reverse subtract and skip if borrow operation subtracts the accumulator from the contents of memory. The result is stored in both memory and the accumulator. If the result was below zero, the next instruction will be skipped. The instruction pointer is mapped to memory location 0 and the accumulator is mapped to location 1. The complete list of special memory locations is as follows:
Location	Description
0 	instruction pointer
1 	accumulator
2 	always contains 0
3 	character input
4 	character output
==Example==
===Hello, World===
This program prints out the words Hello, World!:
; RSSB Hello World, John Metcalf
loop rssb acc ; acc = character from ptr
ptr rssb hello 
 rssb out ; display character
 rssb zero ; acc = -acc
 rssb zero ; always skipped
 rssb sum ; subtract acc from sum
 rssb ip ; skipped if sum is <0
 ; otherwise jump to 0
 rssb acc ; subtract 1 from ptr
 rssb one
 rssb ptr
 rssb acc ; jump to loop
 rssb loopoff
 rssb ip
loopoff rssb $-loop
sum rssb -1116
one rssb 1
 rssb 33 ; '!'
 rssb 100 ; 'd'
 rssb 108 ; 'l'
 rssb 114 ; 'r'
 rssb 111 ; 'o'
 rssb 87 ; 'W'
 rssb 32 ; ' '
 rssb 44 ; ','
 rssb 111 ; 'o'
 rssb 108 ; 'l'
 rssb 108 ; 'l'
 rssb 101 ; 'e'
hello rssb 72 ; 'H'
==See also==
* OISC
==External resources==
* An Implementation of RSSB in Redcode
* Hello World for the RSSB Virtual Computer
* An RSSB implementation in C
Category:Languages
Category:Implemented
Category:Low-level
Category:Turing complete
Category:Turing tarpits
Category:2009
Category:OISC
RTFM

RTFM (also known as F^3) is an esoteric programming language made by User:TeslaX93. The assumption of this language was the desire to encourage the programmer to frequently use the documentation.
Full documentation is available here. Language is currently in alpha stage.
== Examples ==
=== Cat program ===
 046 x 071 x 070 x
=== Hello, world! ===
 070 08C
=== Truth machine ===
 041 t 071 t 022 t 030 080 02F 023 020 027["1"] 070 "1" 021
=== 99 bottles of beer (golfed) ===
 046 b 030 " bottles of beer. " 046 w 030 " bottles of beer on the wall" 046 t 030 "Take one down and pass it around, " 046 n 030 "no more" 046 s 030 "Go to the store and buy some more, " 046 c 030 ", " 046 l 030 10A 01D 10D 041 i 030 "99" 027[i 035 080] 020 070 i 01D w 01D c 01D i 01D b 01D l 01F i 070 t 022 i 031 080 020 070 i 01D w 01D 12E 01D l 021 023 020 070 n 01D w 01D l 021 021 070 062[n] 01D w 01D c 01D n 01D b 01D l 07F i 070 s 01D i 01D w 12E 01D
=== 99 bottles of beer (ungolfed) ===
 046 bottles 030 " bottles of beer. "
 046 wall 030 " bottles of beer on the wall"
 046 take 030 "Take one down and pass it around, "
 046 nomore 030 "no more"
 046 store 030 "Go to the store and buy some more, "
 046 commaspace 030 ", "
 046 newline 030 10A 01D 10D
 041 i 030 "99"
 027[i 035 080] 020
 	070 i 01D wall 01D commaspace 01D i 01D bottles 01D newline
 	01F i
 	070 take
 	022 i 031 080 020
 		070 i 01D wall 01D 12E 01D newline
 		021 023
 		020
 		070 nomore 01D wall 01D newline
 		021
 021
 070 062[nomore] 01D wall 01D commaspace 01D nomore 01D bottles 01D newline
 07F i
 070 store 01D i 01D wall 12E 01D
Category:Languages
RUBE

RUBE, invented in 1997 by Chris Pressey, is a bully automaton which employs a "warehouse paradigm" for computing: crates representing data are pushed around by machines called "dozers", lifted by winches, moved along on conveyor belts, etc.
While the name RUBE was at one point explained as an acronym for Rather Unique Block Engine, this is undoubtedly a backronym; the language is actually named after Rube Goldberg, to whom it is a tribute.
RUBE tends to remind people of "The Incredible Machine".
RUBE is Turing complete, but only if you give it an unbounded playing field.
RUBE's direct descendants are RUBE II: Das Klickenklacker and REDGREEN. It has also been ported to a Java game as Rubicon.
==See also==
* REDGREEN
* RubE On Conveyor Belts
==External resources==
* 
* Rubicon, an online Java game based on RUBE, by Kevan Davis (2006)
Category:Languages
Category:Usability unknown
Category:Implemented
Category:Self-modifying
Category:1997
Category:Two-dimensional languages
RUM

RUM is a dialect of brainfuck written and maintained by User:irskep with a few features added for convenience. RUM stands for "bRainfUck iMproved." It is in the public domain and is available on Github.
==Extra Features==
===Procedures===
RUM supports pbrain-like procedures.
===Repetitions===
Precede commands with numbers to repeat them that many times. The following example sets the current cell to 32:
 [-]32+
Multiple procedure calls are supported with repetitions.
===Strings===
Strings in double quotes will be put into the standard input queue in front of any existing input and null-terminated.
Example:
 "Hello, world!",[.,]
===Breakpoints===
RUM's "debugger," RumBottle, supports stepping through a program through the use of breakpoints. Mark them with an exclamation point.
==Debugger==
RUM comes with RumBottle, a Python script that shows the tape and program position as the program is executed.
==External resources==
* RUM on Github
Category:Languages
Category:Implemented
Category:Brainfuck derivatives
Category:Turing complete
Category:2009
RUNNER

interpreter in python 
 def RUNNER(code):
 number = 0
 tape = ""
 translate = ["R", "U", "N", "E", "O"]
 for letter in code:
 if letter == "R":
 number = RUNNER(tape)
 tape = ""
 elif letter == "U":
 tape += translate[number % 5]
 elif letter == "N":
 number -= 1
 elif letter == "E":
 number += 1
 elif letter == "O":
 print(number)
 return number
Rainbow

rainbow or rainbow is an esolang invented by User:None1. It uses text colored with the colors of the rainbow to do stuff.
==Control Characters==
Control pictures are converted to corresponding ASCII control characters when loading program.
==Memory==
The esolang is self-modifying, the only memory is the program itself. There's also a wrapping memory pointer and a wrapping pointer called the jump point.
==Color points==
Colors are mapped to numbers, called color points.
 red: 0
 orange: 1
 yellow: 2
 green: 3
 cyan: 4
 blue: 5
 purple: 6
Color points wrap (incrementing purple gives red, and vice versa).
==Commands==
A command depends on the color of the character instead of the character itself.
 red: increment the color point of current character
 orange: move the memory pointer to the right
 yellow: add the ASCII value of current character by the next
 green: input the current character
 cyan: output the current character
 blue: increment the jump point if the current character has an odd ASCII value, otherwise decrement
 purple: if the current character is not a null character, jump to the jump point
Characters that have other colors or don't have colors are NOPs.
==Examples==
===Hello, World!===
 Hello, World!.............
Works by retrieving Hello, World from the source code,
===Cat program===
 .GCP
===Cheating Quine===
 QUINE␀
Doesn't output colors.
Category:Languages
Category:2024
Category:Unimplemented
Category:Cell-based
Category:Self-modifying
RandBow

RandBow is a visual esoteric programing language. Its like a mix of brainfuck and piet.
==Variables==
There are 3 variables that the program can edit:
Cells = Array Of Ints, contains the cells
Cell = Int, The curent selected cell
Pointer = Int, The curent pixel being run
==Rules==
The Pointer starts at 0, 0(top left corner) and after runing each pixel the Pointer increases and it goes to the next pixel on the right. After Finishing each row it goes to the leftest pixel on the next row. 
Each pixel does somthing other than black. Here is what they do:
Red = Adds 1 to the curent cell.
Blue = Subtracts 1 from the curent cell.
Yellow = Adds the amount in the curent cell to the Pointer.
Orange = Outputs the curent cell as a character.
Green = Outputs the curent cell as a int.
Purple = Waits for you to type an charicter and a newline and puts into curent cell.
White = Copys current cell into next cell.
Dark Brown = Moves to the last cell.
Light Brown = Moves to the next cell.
Category:Languages Category:Implemented Category:Cell-based Category:2021
Random

Random, standing for R and O Machine(temporarily R & O refers to Regenerating & Overrunning, but subjects to change looking forward any better idea) is a minimalistic esoteric programming language in string-rewriting paradigm, assuming the source code itself as a double-ended stack. First proposed by User:Gs30ng, the specification is under development yet.
== Overview ==
Based on a linear memory space which is the source code itself, a Random program deals with six kinds of instruction:
 <
 >
 [
 ]
 ><
 And all other characters
Interpretation starts from the left side of the code.
* All characters except for <, >, [, ] and >< are simple instructions: Add itself to the back(right side) of the code. Therefore a simple infinite loop can be written as an anonymous one character:
 A
 AA
 AAA
 AAAA
 AAAAA
 ...
* Instruction < pops an element from the back of the code, and pushes it onto the front of the code.
 A<<B
 A<<BA
 AA<<B
 BAA<<
* Instruction > pops a element from the front of the code, and pushes it onto the back of the code.
* [...] can be written as "Do ... while the front element and the back element are different" in pseudo-code. [ transfers the control to corresponding ] if the front element of the code and the back element are same. ] transfers the control to corresponding [ if the front and back element are different. If there is no corresponding [ or ], the program terminates.
* Since >< is NOP, making it another instruction does not cause any collide. In Random this instruction pops an element from the back and prints it out.
== Example codes ==
 !dlroW ,olleH[><]><
prints "Hello, World!".
== Computational class ==
Since a Random program can push/pop items onto/from the both sides of the code, it can simulate a machine with 2 stacks. At this time it is not sure but it is guessed that Random can simulate the Turing machine.
== External resources ==
* Interpreter in Python 
* Common Lisp implementation of the Random programming language which employs a double-ended queue (deque).
Category:String-rewriting paradigm
Category:Implemented
Category:Stack-based
Category:Low-level
Category:2006
Category:Languages
Category:Self-modifying
Random Malbolge

Random Malbolge is esoteric programming language made by User:Palaiologos in 2019. Programs in Random Malbolge have following form:
nChars nOffset rSeed
[... n times]
Where nChars is amount of characters generated using random generator in implementation below using rSeed, with initial offset of nOffset.
The file can be n lines long, and each line has to be parsed separately. The following 104-byte C program will generate Malbolge (or Malbolge
Unshackled) program out of Random Malbolge program:
a,b,V,c;r(){return V=(31821*V+13849)%65536;}main(){scanf("%d %d %d",&a,&c,&b);while(c--)r();V=b;while(a--)putchar(r()%94+33);}
Note: It's assumed that int is at least 2 bytes big.