nyuuzyou/wikis huggingface dataset:
Rev

Rev is a small, stack-based language based on Mouse.
==Sample code==
The Sieve of Eratosthenes in Rev can be written as follows:
<nowiki>
~ Sieve of Eratosthenes
520 a: ~ How many primes to find
a._x: ~ Allocate a bunch of memory
2 n: ~ Number to start at
0 y: ~ Initialize
( 0 x.y.+: ~ set to 0
 y.1+y: ~ Increment
 y. a. = ^ ~ Exit if initialized
)
( 
 x.n.+. 0 = 
 [
 n.! " " 
 n.y: ~ Set y to n
 (
 y. n. + y: ~ y = y + n
 y. a. > ^ ~ If y > a, exit
 1 x.y.+: ~ Set value to 1
 )
 ]
 n.1+n: ~ Increment n
 n. a. > ^ ~ Exit if n > a
)
"!"
</nowiki>
==External resources==
* This page has a full description of the language, currently under development.
Category:Languages Category:2017 Category:Stack-based
Revaver16

This is a work in progress. It is not yet complete.
In this programming language, every command is a reverse of itself, so entering a command twice in a row is like a NOP. If you reverse the order of all the lines in the file and give the output of the first program as this program's input, you will get back the original input.
Commands are in a file, one in each line. First, give the input list. The output list is returned. A list entry is 2 bytes, no immediate duplicates like (1,2)(1,2). Main List, Intermediate List, all others Memory Lists (and a infinitely-long number for each).
These symbols can be used in place of numbers:
* ! = First by
Commands:
* (TR) TERMINATE: If Inter.List and all Mem.Lists are empty, end program.
* (PP) PUSHPOP a b: Pushes (a,b) onto Main.List. If (a,b) is already on top, pops instead.
* (MP) MEMPOINTER a b: If intdiv(p+a,b) (rounding down) is even, increase pointer by 'b', otherwise decrease. (If b=0, assume b=256)
* (SI) SWAPING: Swaps Main.List with Inter.List.
* (SM) SWAPMEM a: Swaps Main.List with Mem.List(p+a).
Revcompgeek

Revcompgeek is the username of a programmer who has been interested in esoteric programming languages for a few years. He has invented the esoteric programming languages SIG, TMCB, Karma, and Ans. Recently he posted an interpreter for Ans written in D, which is his favorite non-esoteric programming language. He has also written a Karma interpreter in D.
==See also==
* User:revcompgeek - his user page on this wiki.
==External resources==
* Ans interpreter 
Category: People
ReverseFuck

ReverseFuck is a Brainfuck modification created by Juraj Borza in 2006, which uses "reversed" brainfuck operators. 
This means that operator + acts as -, < acts as > and vice versa. The reason for this is that brainfuck may be too easy to understand for people, as + increments the current cell and > increments the pointer. But when this is reversed, it is harder to make sense of it.
 Instructions:
 -	Increments the current cell (under the pointer).
 +	Decrements the current cell (under the pointer).
 >	Move pointer back 1 cell.
 <	Move pointer forward 1 cell.
 .	Inputs a character to current cell.
 ,	Outputs a character from current cell.
 ]	While the current cell value is not zero, do stuff inside ] and [ braces
 [	End while.
To compile ReverseFuck programs into Brainfuck and vice versa, you can use the converter or BrainSoup. With a Unix-like shell, you can also use:
 tr "\-+><.,][" "+\-<>,.[]" <foo.revb >foo.b
==Examples==
===Hello World===
 --------]<----]<--<---<---<->>>>+[<-<-<+<<-]>[>+[<<,<+++,-------,,---,<<,>+,>,---,++++++,++++++++,<<-,<--,
===Cat Program===
 .],.[
===Nope. interpreter===
 ------]<------------->+[<,<-----------]<---------->+[<-,-,+++++++++++,<-----]<--------->+[<-,
==External resources==
* Project web page
* Online interpreter in JavaScript.
==See also==
* 操脑
Category:Brainfuck derivatives
Category:Brainfuck equivalents
Category:Turing complete
Category:Cell-based
Category:Implemented
Category:2006
Category:Languages
Reversed

Reversed is an esolang invented by User:None1. It doesn't have jumps, but its control flow can be reversed.
==Commands==
It has these commands:
 R: reverse control flow direction
 other characters: print the character
If the instruction pointer goes to the left of the first character, it moves to the last character, but not vice versa.
==Examples==
===Hello, World!===
 Hello, World!
===Quine===
 quine
===Print 123321===
 123R
===Interpreter in Python===
a,p,d=input(),0,1
while 1:
 if p<0:
 p=len(a)-1
 if p>=len(a):
 break
 if a[p]=='R':
 d*=-1
 else:
 print(a[p],end=)
 p+=d
Category:Languages
Category:Joke languages
Category:2024
Category:Output only
Reverser

my own reversible language
== commands ==
 out: output
 tuo: remove this from the output
 inp: input
 pni: undetermined so noop
 loop N c E: loop the following
 E c N pool: still loop
 stop: stop
 pots: start
 start: start
 trats: stop
 inc: increment
 cni: decrement
 dec: decrement
 ced: increment
 reverse: reverse the code
 esrever: do same thing
== rules ==
 my programming language reads from left to right (reverse would be right to left)
 so thats why it works
Category:Languages Category:2024 Category:Unimplemented Category:Unusable for programming
Reversible-2D

Reversible-2D is a 2D programming language which can be reversed. It is unique because it still has variables. The short for Reversible-2D is R2D. For version 1, it is R2D1. When version 2 comes, some ppl will lol. It is made by User:TehZ.
== Commands ==
The current commands:
 \ and / Mirrors.
 P Swaps the value of the current thread and the next cell in the source code.
 O Outputs the value of the current thread.
 I If the value to the right of this command is not space, throws an error. If it is space, this will read a byte from stdin and put it to the cell to the right.
 + Adds 1 to the value of the current thread.
 - Opposite of +.
 ¤ Ends the current thread. After a thread is terminated, it counts how many steps it has been terminated.
 N Prints a newline character to stdout.
 Other Nothing.
Commands are reversed by:
 \ and / Moving the other way through.
 P Repeating the process.
 O Removing last printed character from console/file.
 I Taking the value of the cell to the right of the command and putting it into the threads value.
 + Doing - instead.
 - Doing + instead.
 ¤ Starting the thread and turning it around (after the amount of steps it has been terminated :D).
 N Same as O.
 Other Nothing.
Commands are CaSe-SeNsItIvE!
== Threads ==
A thread in R2D is not a normal thread, because all threads execute in the same process. They are placed in the source with the following commands:
 V Down
 > Right
 ^ Up
 < Left
A thread holds a 16 bit value (because java char's is 16 bit) which can be changed through the commands.
=== Priority's ===
Threads will execute in a fixed and well defined order:
 Y is first priority The lower Y coordinate at start, the sooner a thread will run.
 X is second priority The lower X coordinate at start, the sooner a thread will run.
=== Note on Threads ===
If a thread collides with a thread starting point in the same direction as the thread, there will come undefined behavior. If it was allowed, Reversible-2D would not be reversible.
== Variables ==
There is two places that variables can be:
 Source Each cell is a variable.
 Threads Each thread is a variable.
== Examples ==
Hello World:
 >PHOPeOPlOPlOPoOP,OP OPWOPoOPrOPlOPdOP!ON¤
The above program will write "Hello, World!" followed by a newline.
Cat (ignoring eof):
 / > \
 
 \O I/
The above program will copy all input to output. *NOTE* It will actually produce undefined behavior, but it works in the standard interpreter.
Multithreaded:
 >PHOPeOPlOPlOPoOP,OP OPWOPoOPrOPlOPdOP!ON¤
 >PHOPiOP!ON¤
The above program will write "HHeil!" followed by a newline, followed by "lo, World!" followed by a newline.
== Turing Completeness ==
Reversible-2D is not Turing-Complete, because any program can either always terminate or always loop forever (but a forever loop gives undefined behavior).
== Implementations ==
The official implementation.
Category:2010
Category:Two-dimensional_languages
Category:Implemented
Category:Self-modifying
Category:Languages
Category:Low-level
Category:Reversible computing
Category:Unknown computational class
Category:Concurrent programming
Reversible Bitfuck

Reversible Bitfuck (RBF) is yet another Brainfuck variant discovered by User:Orby in 2017.
=Definition=
RBF is defined on a tape machine with 1-bit cells. The tape machine is unbounded on the right. It uses 5 commands.
Command	Description
* 	Toggle the current bit
> 	Shift the tape head right
< 	Shift the tape head left
( 	If the current bit is zero, jump past matching )
) 	If the current bit is zero, jump to just after matching (
RBF is Turing complete by reduction to 1-bit Reversible Brainfuck which is known to be Turing complete. The simple translations to and from 1-bit Reversible Brainfuck are
Reversible Bitfuck	 	1-bit Reversible Brainfuck
* 	↔	+ or -
< 	↔	<
> 	↔	>
( 	→	+[+
) 	→	+]+
*(* 	←	[
*)* 	←	]
=Properties=
RBF enjoys a number of interesting properties.
==Reversibility==
Take an arbitrary RBF program A consisting of the string of symbols a1a2...an where ai denote RBF commands. Take any initial tape state and head position denoted by t0.
If A halts on t0 and leaves the machine in state t1, then A' := an'an-1'...a1' halts on t1 and leaves the machine in state t0. Here ai' denotes the inverse of ai which translates thusly
Command	Inverse
* 	*
> 	<
< 	>
( 	)
) 	(
=Minimization=
RBF was constructed as a target for minimization. It is known that 3 command simple translations exist (see Nanofuck). Picofuck is the community project to discover 2 command variants which is thus far inconclusive. Notice that if { A, B, C } is a simple translation of RBF where A := a1a2...ax, B := b1b2...by, C := c1c2...cz, then { A', B', C' } is also a simple translation of RBF (see reversibility). We will call { A', B', C' } the dual of { A, B, C }.
=See also=
* Reversible Brainfuck
* Boolfuck
* Nanofuck
* Picofuck
* Simple translation
== External resources ==
* rbf-lang - Reversible Bitfuck interpreter on GitHub. Implemented in Python.
Category: Languages
Category: Brainfuck derivatives
Category: Turing complete
Category: Reversible computing
Category: 2017
Category: Implemented
Revolution 9

Revolution 9 is a Brainfuck equivalent whose instructions are:
Instruction 	Brainfuck equivalent
It's alright 	<
turn me on, dead man	>
Number 9 	+
if you become naked 	-
The Beatles 	.
Paul is dead 	,
Revolution 1 	[
Revolution 9 	]
Category:Joke languagesCategory:2013Category:Brainfuck equivalentsCategory:LanguagesCategory:UnimplementedCategory:ThematicCategory:Turing completeCategory:Turing tarpitsCategory:Cell-basedCategory:Low-level
Rewriting

Rewriting denotes a form of computation where a data structure is replaced by a modified form of itself, sometimes repeatedly. Prominent forms of rewriting include:
*String rewriting, where the data structure is a string of symbols. Examples are the languages Thue and :///, Post canonical systems, and regular expression substitution as found in several mainstream languages.
*Graph rewriting, where the data structure is a (usually labeled) graph of vertices with edges between them. This is frequently used as an implementation or formal semantics of languages, especially functional ones. Undirected graph rewriting is addressed in Eodermdrome.
*Tree rewriting, the frequent special case of graph rewriting where the graph is a tree, at least conceptually. In implementations, identical sub-trees may be identified for efficiency, so that the underlying structure is nevertheless a more general graph (directed, without cycles). Examples: Combinatory logic or Clean.
Category:Computational models
Rfghjy

Rfghjy is a simple esolang based around the idea of self-modifying code. There are two registers: ! and @. Each "cycle" of the Rfghy interpreter, ! is executed, then @ is executed, and then the interpreter may optionally print the stack. All data is simply stored as code, with one number corresponding to each instruction. The code from the user is stored in a queue. When that queue is empty, the program exits. That queue may be modified by the program. The instructions are:
* p: pop from the queue into @.
* n: push p onto the queue.
* i: increment the last item on the queue, resetting at 6. See the section on numbers below.
* e: exits the program.
* d: pops the first and last items on the queue into @ and !, then pushes @ ! times.
* x: pops from the queue into !.
Each instruction is represented numerically as its index in the above list. Thus, p = 0, n = 1, i = 2, e = 3, d = 4, and x = 5. As stated above, all numbers all modded by 6, the number of instructions.
An example interpreter may be found here.
== Examples ==
None yet, sorry!
Category:2020 Category:Self-modifying Category:Implemented Category:Languages
Rflct

rflct or reflect, invented by Joey Haas, is an esoteric language based on Argh!. Like Argh!, it is laid out in two dimensions. But unlike Argh, rflct has no code boundaries. If you've ever tried coding in Argh!, this language is a piece of cake for you.
The name is because the code can reflect off 'surfaces', this essentially makes a command differ in function when the instruction pointer comes from a different direction. This is a valid program:
 
 vHey! 
 >PPPP--:
 | :)
 /---/-PPPo
 :---/
And it will ouput 'Hey! :)'.
'|' and '-' are simple 'NOP' commands and don't do anything except move the instruction pointer.
':' and '/' function as mirrors for the pointer.
The program for "Hello, world!" is easy to write and is written in this way:
 v
 >mHo
 H
 e
 l
 l
 o
 ,
 
 W
 o
 r
 l
 d
 !
 /
 ;
The parser starts reading at 0,0. There MUST be a directional pointer here, and it can not point up or left: #, > and v. The # is for the people whose system supports executables by doing #!path. Thusly, the only way the # is accepted is if there's a ! behind it. If this is the case, it will point downward.
It then notices another directional pointer, this time to the right. The direction is changed. Here it comes to command 'm', also called 'mass save'. It'll add every value under it to the stack until it strikes /;. It can't save more than 64 values per run. 'H' will output the whole stack as one string. This will NOT clear the stack. At last, 'o' will stop the program.
The parser is written in PHP. Eventually, when the parser is 100% done, the source will be free to download and to host on your own server.
===External resources===
* The parser 
* Specifications 
Category:Languages
Category:Two-dimensional languages
Category:2009
Category:Cell-based
Category:Stack-based
Category:Self-modifying
Rhoam

Rhoam is an esoteric programming language created by User:EvilMuffinHa in 2019 in which there are only 3 characters.
== Syntax ==
Rhoam has a list of instructions and it consists of three characters, [, ], and :. 
* [ moves the instruction pointer to the left. 
* ] moves the instruction pointer to the right. 
* : executes the instruction at that point. 
An error occurs if the pointer goes below zero or past the final instruction. 
More information on the instructions can be found at this site. 
== Examples ==
This is a Hello World program. 
 Get to the 5th instruction
 ]]]]]
 Add enough to ticket to reach "e"
 :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
 On memory slot 0
 Adding it to memory slot
 ]]]]]]]]:
 Adding enough to the memory slot to get to h
 [[
 :::
 Printing h out
 [[[[:
 Printing "e" by printing out the ticket
 ]]]]]]]]:
 Adding enough to get to "l" in memory slot
 [[[[::::
 Printing L twice
 [[[[::
 Adding enough to get to "o" in memory slot
 ]]]]:::
 Printing O
 [[[[:
 Getting to instruction 18 (print space) and printing
 ]]:[:
 Go back and add more to memory to reach "w"
 ]]:]
 ::::::::
 Printing W
 [[[[:
 Subtract and print O
 ]]]]]::::::::[[[[[:
 Add and print R
 ]]]]:::[[[[:
 Subtract and print L
 ]]]]]::::::[[[[[:
 Subtract and print d
 ]]]]]::::::::[[[[[:
 Subtract and print !
 ]]]]]:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::[[[[[:
 Print newline
 ]]:[[:
Alternatively, we can remove all comments. 
 ]]]]]:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::]]]]]]]]:[[:::[[:]]]]]]:[[[[::::[[::]]:::[[::[:]]:]::::::::[[:]]]::::::::[[[[[:]]]]:::[[:]]]::::::[[[[[:]]]]]::::::::[[[[[:]]]]]:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::[[[[[:]]:[[:
== Computational Class ==
Rhoam can be proved to be Turing complete because it can perform all instructions of Brainfuck, and Brainfuck is proven to be Turing complete.
== See also ==
* Wrapping Rhoam
* Rhoam Ultimate
Category:Turing complete
Category:Languages
Category:Implemented
Category:Turing tarpits
Category:Turning tarpits
Rhoam Ultimate

Rhoam Ultimate is an esoteric programming language created by User:EvilMuffinHa in 2019 in which there is only 1 character. It is an extension of Wrapping Rhoam.
== Syntax ==
Rhoam Ultimate has a list of instructions and it consists of one character, :. 
Rhoam Ultimate first counts the number of colons in the code and converts it into a binary number. The binary number must start with 1, or the interpreter will throw an error. The first 1 farthest to the left is then removed, and the number left is stored. The 1's in the number are converted to ] and the 0's are converted to :. The string is then executed as a Wrapping Rhoam program.
More information on the instructions can be found at this site. 
== Computational Class ==
Rhoam Ultimate can be proved to be Turing complete because it can perform all instructions of Wrapping Rhoam, and Wrapping Rhoam is proven to be Turing complete.
== See also ==
* Wrapping Rhoam
* Rhoam
Category:Turing complete
Category:Languages
Category:Implemented
Category:Turing tarpits
Rhotor

Rhotor is an esoteric programming language developed by Jannis Harder in 2006.
Rhotor is a lazy evaluating functional programming language that utilizes pattern matching. 
== Data types ==
Rhotor has 3 data types:
; Functions : Functions have a matching pattern (the function head), the function code (the function body) and an optional failure function (the function footer)
; Nil : Nil is the only constant in Rhotor.
; Cons : A cons concatenates two other items. It can be used to build lists or tree structures. As there are no numbers or strings in Rhotor you have to use Cons and Nil to represent them.
== Language syntax ==
Operators with the highest precedence are listed first.
; < > : Those signs act as parentheses. Empty parentheses evaluate to Nil.
; head/body or head/body\footer : This syntax is used for functions. Functions are right associative. (a/b/c is the same as a/<b/c>). Wrap functions that use the Footer in parentheses.
; car,cdr : This is the syntax for concatenation (Cons). Concatenation is right associative.
; function argument or function.argument : This is the syntax for application. It applies function to argument. Application is left associative.
; lowercase word : A lowercase word acts as a symbol. Symbols can be defined in a function head and are valid in the body. If you want to redefine a symbol you have to use the :symbol notation.
; :lowercase word : This redefines a symbol and can only be used in a function head.
Spaces, uppercase letters and periods are equivalent and can be used to separate symbols and comment the code.
== Pattern matching ==
A pattern is build using Nil, cons and symbols. A pattern matches a function if all elements, except symbols, are equal. Symbols act as a wildcard and match anything.
== Application rules ==
* Nil argument always evaluates to Nil.
* a,b argument evaluates to <a argument>,<b argument>.
* function matching-argument evaluates to the body of the function where every symbol in the body is replaced with the value the same symbol in the pattern matched. Symbols that doesn't occur in the pattern aren't replaced.
* footerless-function non-matching-argument evaluates to Nil.
* function non-matching-argument evaluates to function-footer argument.
== Data representation ==
Rhotor specifies data representations for natural numbers and strings. They are not part of the language but of the IO system.
=== Numbers ===
Numbers are written as <> followed by N times ,<>. There is a short cut notation %N.
=== Strings ===
Strings are written as <byte1>,<byte2>...<byteN>. Again, there is a short cut notation %"String". You may use \n for a newline and \" for a quote character.
== IO system ==
The program is applied to the user input and the evaluated string is printed to the screen.
== Turing completeness proof ==
Using the following rules, it is possible to transform any lambda calculus expression into an equivalent Rhotor expression. 
# Replace every ( and ) with < and >.
# Replace every λ a . b with :a/b
==External resources==
* 
* Alternative link from the Esoteric File Archive.
Category:Languages
Category:Functional paradigm
Category:Turing complete
Category:Implemented
Category:2006
Rhymolang

Rhymolang is a joke esoteric programming language. You have to Rhyme in Rhymolang.
==Print==
For 1 syllable prints, it is:
 (text) print
 have mints
For 2 syllable prints, it is:
 (text) print
 have a mint
For 3 syllable prints, it is:
 (text) print
 come have a mint
For 4 syllable prints, it is:
 (text) print
 come on, have a mint
For 5 syllable prints, it is:
 (text) print
 well, come on! have a mint
For 6 or more syllable prints, you just repeat "well".
An example for Hello World would be:
 hello world print
 come have a mint
==Input==
It would be this:
 player input
 (variable) put
Note that all variables have to be 2 syllables in the name.
==Print Variables==
It would be this:
 (variable) print
 dollar mint
==Hello world==
 hello world print
 come have a mint
==Cat==
 player input
 yellow put
 yellow print
 dollar mint
Category:Languages Category:Joke languages Category:Thematic Category:Pseudonatural
Ribosome

Ribosome is a low-level concurrent esoteric programming language created by User:.yazic
= Overwiew =
Every thread has two pointers. Pointer *o points to a location in memory where the current operation is. Pointer *i points to a location of the data thats being operated on. Pointer *i in the beginning starts in a temporary location where it cant interfere with the code.
TODO: needs a way to halt
OPcode	Name 	0x	Operation
G 	No op	00	Broadcast o and Move i Backward.
A 	Act 	01	
From 	To 	 	
00 	11 	 	
01 	10 	 	
10 	00 	 	
11 	01 	 	
TODO: clean this up
Category:Self-modifying Category:Languages Category:Concurrent programming Category:Cell-based Category:Low-level