nyuuzyou/wikis huggingface dataset:
Real Brainfuck

Real Brainfuck is a brainfuck variant that operates on the real-valued range {0, 1}. The tape starts with all cells set to 0.5. It also has a stack. This is a more usable version of an esolang i designed in the past.
==Instructions==
It has the following instructions:
Instruction	Explanation
< 	Move data pointer left on tape
> 	Move data pointer right on tape
0 	Set current cell c to (c + 0) / 2
1 	Set current cell c to (c + 1) / 2
N 	Set current cell c to 1 - c
[ 	Randomly choose between 0 and 1 with probability c. if zero jump past matching ]
] 	Randomly choose between 0 and 1 with probability c. if not zero jump back to matching [
^ 	Push cell data to stack
V 	Pop item from stack to current cell
& 	Pops top two items on the stack, multiplies them together, and pushes the result back
X 	Pops top two items on the stack, averages them together, and pushes the result back
, 	Obtains real-valued or binary input from an implementation-dependent source and sets the cell to that value
. 	Outputs current real value
q 	Outputs either 0 or 1 with probability c
Real Brainfuck 2 Variant: operates on all complex real numbers. It has support for abnormal probabilities and the following additional Instructions:
Instruction	Explanation
+ 	c = c + 1
- 	c = c - 1
; 	c = c-th root of c
\ 	pop two items from stack, a & b, and push c: c = loga(b)
/ 	c = sin(c)
z 	c = c ^ pi
: 	pop two items from stack, a & b, and push c: c = a ^ b
f 	c = c ^^ 2 (c tetrate 2)
e 	set cell to transcendental number e
p 	set cell to transcendental number pi
! 	c = c! (multiplication factorial)
? 	c = c? (addition factorial)
$ 	c = c$ (exponential factorial)
{ 	begin ()infinite loop (finishes in finite time, hyperloop)
} 	end ()infinite loop (finishes in finite time, hyperloop)
==Examples==
===Cat program===
The following numeric cat may randomly terminate for an input less than one (1.0):
 ,.[,.]
===Truth-machine===
A truth-machine is implemented in this program:
 ,.[.]
===Multiples of π (pi)===
This program prints the first five multiples of constant π (pi):
 +++++
 >+z
 <[>.+<-]
==Interpreter==
* Common Lisp implementation of a subset of the Real Brainfuck programming language. While both real- and complex-valued tape cells are supported, certain more complex operations, in particular the factorial functions, retain the more common integer behavior.
Category:Probabilistic Category:Cell-based Category:Stack-based
Category:Languages Category:Brainfuck derivatives Category:Turing complete Category:UncomputableCategory:Implemented
Rebellent Brainfuck

Rebellent Brainfuck is an esolang created by User:None1, it is the same as brainfuck, the only difference is that the program doesn't always obey what you want it to do.
==Execution==
Rebellent Brainfuck is very rebellent, every time it reaches a character, there is uniform probabillity that it interprets that character into one of the 8 commands in brainfuck, causing the result to be indeterminate.
Also, that sometimes makes [ and ] unbalanced, when that occured, Rebellent Brainfuck will go crazy:
# First, it rewrites the tape with random bytes.
# Second, it starts running the commands using the rewritten tape.
# Last, it accesses the 0x00000000 memory address, which causes the program to crash horribly.
These things make Rebellent Brainfuck chaotic! So the execution result is indeterminate, that means there is no example programs.
==See also==
* Brainfuck
Category:Languages
Category:Joke languages
Category:Unusable for programming
Category:Unknown computational class
Category:Cell-based
Category:Low-level
Category:Nondeterministic
Rebmu

Rebmu is an esoterical code-golf dialect of Rebol, made by HostileFork.
==Overview==
The underlying language is case-insensitive, so it uses CAPSalternationTOseparateTOKENS. It doesn't use JustCapitalLetterBreaks because it ascribes special meaning to INITIALcapitals—this means the first token will be the target of an assignment. This is in contrast with nonINITIALcapitals, where none of the tokens are assumed to be assignment targets.
==Examples==
====Roman number to int converter====
Here's an example program (fairly straightforward implementation, just a test) that reads a Roman Numeral string from the input and calculates the integer value:
 rSfeCs[Nse[x10i1v5l50c100d500m1000]twCi~j[JnCN]Kk+elJn[alN-j N0]'jJn]k+j
Without going into too much detail, the first 6 characters are equivalent to if you had written the nine-character sequence r s fe c s. The meaning is "read string s" then "for each character c in s execute the following block of code". Every function knows its arity—so the fe knows it needs exactly three parameters (a variable, a quantity to iterate, and the block of code to execute) while r knows it needs only one. This minimizes need for parentheses and delimiters.
Use of the caps alternation (a concept I call "mushing") is purely optional. But this shows what has empirically borne out—about a 40% savings in character count. It's relatively transparent once you've absorbed the rule, a little bit like reading pig latin. :)
====Merging two sorted lists====
 u[iG^aNXa[rvA]apGtkFaM?fA]apGscA
Un-mushed:
 u [ ; until
 i g^ a nx a [ ; if greater? args next args
 rv a ; reverse args
 ] ; (we want the block containing the next value first)
 
 ap g tk f a ; append output take first args
 m? f a ; empty? first args
 ] ; (first block is now empty)
 
 ap g sc a ; append output second args
 ; (add the remainder of the second)
Usage:
 >> rebmu/args [u[iG^aNXa[rvA]apGtkFaM?fA]apGscA] [[1 5 10 17 19] [2 5 9 11 13 20]] 
 == [1 2 5 5 9 10 11 13 17 19 20]
 
 >> rebmu/args [u[iG^aNXa[rvA]apGtkFaM?fA]apGscA] [[2 5 9 11 13 20] [1 5 10 17 19]] 
 == [1 2 5 5 9 10 11 13 17 19 20]
== Hello World ==
p"Hello World"
==External links==
* http://rebmu.hostilefork.com/
* Wikipedia:Rebol
Category:Languages
Category:Golfing language
Category:Graphical Output
Rec+

Rec+ is a derivative of Rec that tries to make Rec easier to program in.
== Commands ==
Command	Behavior
123 	Push number.
+ 	Addition.
* 	Multiplication.
_ 	Negate; Pops x, pushes -x.
= 	Pops x, pushes x == 0.
: 	Pops x, pushes xth-to-top stack item.
; 	Pops v and x. Assigns xth-to-top stack item to v.
[ ... ]	Infinite loop; executes ... forever.
^ 	Pops x. If x != 0, break out of innermost [ ... ] loop.
== Stack operations ==
=== Pop nonzeros until a zero value ===
[0:=^[^]]
== Examples ==
== Computational Class ==
todo
== External Links ==
* Rec+ interpreter in C
== See also ==
* Rec
* Recur
Category:2023
Category:Languages
Category:Low-level
Category:Implemented
Category:Stack-based
Recipescript

== RecipeScript ==
Recipescript is a Python-based joke esolang created by dreamVoyager that can't actually be run by any program. Instead, the compiler is the brain of whoever's reading the code, and its output is a physical (and edible, if everything went well) object.
=== How does it work? ===
The program is read as any other program, and must be compiled by the reader. Generally, RecipeScript programs start by listing the ingredients, then defines a cooking function, and runs this function. Finally, the .eat() function is called, and the program ends.
== Some examples ==
==== Mashed Potatoes ====
Mashed potatoes. Simple.
 potato = {"Potato": 2}
 ingredients = {"Milk": 1 cup, "Butter": 1 tablespoon}
 def mashed_potatoes(ingredients, potato)
 peeler.peel(potato)
 board.add(potato)
 board.cut(potato, cubes)
 stove.add(pot)
 pan.add(water)
 stove.heat(pot)
 if water.temp == 100ºC:
 board.transfer(pot)
 pot.boil(15 min)
 pot.transfer(bowl)
 bowl.mash
 for i in ingredients:
 bowl.add(i)
 bowl.mix
 bowl.transfer(plate)
 plate.season("Salt", "Pepper")
 cook(mashed_potatoes)
 plate.eat(mashed_potatoes)
= D Variant =
This is a slight variant of Recipescript by Digin (made with permission from the creator) with slightly different syntax.
== Example ==
A very simple recipe for peanut butter cookies.
 def pb_cookies(plate):
 m = mixer()
 o = oven()
 s = sheet()
 ingredients = [ingredient("egg",2),ingredient("peanut butter",2 cup), ingredient("sugar",1 cup)}
 for i in ingredients:
 m.add(i)
 m.mix()
 s.addParts(m.contents, 2 cup)
 for i in s.contents:
 i.flatten()
 i.sprinkle(ingredient("sugar",5 g))
 o.add(s)
 o.bake(30 s)
 o.transfer(plate)
 p = plate()
 pb_cookies(p)
 p.eat()
Category: Languages
Category: 2021
Category: Unusable for programming
Reciprocal Lenguage

Reciprocal Lenguage is similar to Lenguage, but use reciprocal of code length instead of code length.
== Syntax ==
Length of code is the only thing that matters.
It works like Lenguage but use reciprocal of code length instead of code length.
== Examples ==
=== Hello world ===
A program of 1/17498005810995570277424757300680353162371620393379153004301136096632219477184361459647073663110750484 bytes
== Code Golf ==
According to discussion on codegolf stackexchange, 
Fractional byte counts are always allowed. This enables storing information in code length.
This converts code-golf into code-bowling: If the source brainfuck code is longer, the resulting program would take less bytes.
Category:Languages Category:Golfing language Category:Brainfuck derivatives Category:Brainfuck equivalents Category:Cell-based Category:Low-level
Recorder

Recorder is a programming language i made that uses extraction
== Basic Functions ==
=== Comment ===
 #hello im a comment
 #see
 #its cool
=== Text ===
 textisdefinedwithoutquotes
 "or with quotes to stop variables to get refered"
=== Box ===
 a = text
 a #text
=== Recorder ===
 te(xt) : () = a
 a #xt
 an(ychars] : (] = b
 b #ychars
=== Tape ===
 te(xt) : () = a #a is a box btw
 a #xt, a contains the tape from recording the brackets
=== Functions ===
 same a:
 return a
 same "text" #"text"
== Logic gates ==
You can define logic gates in it
 true = "!false.&b."
 false = "!true.&false."
 get a b:
 b : a = o
 return o
 not a:
 return get !. a
 and a b:
 return get &. a
 not true #false
 and true true #true
== Insert Code Below ==
Write code below here to make a turing machine in Recorder (because im to lazy to)
Category:Languages
Recur

Recur is an esoteric programming language created by User:D, inspired by Iteration can replace Recursion?. Instead of using an implicit call stack, the language requires users to handle the call stack manually.
== Inspiration ==
The inspiration was rather mixed. The design was mainly based on the following OISC:
s1: if x = b, x := c; goto s2
Also, there was an answer saying the following:
You do not need recursion, and as you suggest, and as confirmed by Dave Clarke's answer, you only need conditionals, loops and memory allocation and assignment.
After reading most of the answers in Iteration can replace Recursion?, I added infinite loops, conditional breaks, "register" pushing/popping and built all of that onto the call stack typically used to implement recursion. Resulting in this language.
== Commands ==
If there aren't enough stack items to perform the operation, then the operation is a NOP. (An exception is the , command, as specified below.)
* 123: Push the natural number (includes 0) onto the stack. (There is an infinite number of natural numbers.)
* s: Successor function: Pops a, pushes a+1.
* ,: Pops a and v. Store a to the variable numbered v. (If there is no a on the stack, break out of the [ ... ] loop.)
* !: Pops v. Push the value of the variable numbered v onto the stack.
* [ ... ]: Infinite loop: Executes ... forever.
* =: Pops a and b. If a and b are equal, break out of the [ ... ] loop.
== Examples ==
=== Predecessor function ===
Expects a value on the top of the stack. Wouldn't work for input = 0 (which will loop forever).
0,
0 1,
1 2,
[ 2! 0! =
 1! s 1,
 2! s 2,
] 1!
Minified & golfed:
0,0 1 2,[2!0!=s2!s2,]
=== Double the number ===
1,0 0 2,[2!1!=ss2!s2,]
=== Ackermann function ===
I've used m, n and r in place of the actual numbers to avoid confusing myself.
[ n,m,
 [ n! s
 m! 0=
 r,
 0 1 r,
 [ r! m! =
 s
 r! s r,]
 1
 n! 0=
 r, m!
 0 1 r,
 [ r! n! =
 s
 r! s r,]
 0 0 =
 ]
]
== Computational Class ==
Recur is Turing-complete. To demonstrate this, here is a translation from brainfuck with unbounded cells.
0 represents the tape head, 1 is a scratchpad used for the - operation.
Program setup:
2 0,
>:
0! s 0,
<:
1 1,
0 [1! 0! = s 1! s 1,]
0,
+:
0!! s 0! ,
-:
1 1,
0 [1! 0!! = s 1! s 1,]
0! ,
[:
[ 0!! 0 =
]:
]
== External Resources ==
* Interpreter/Debugger written in Python
== See also ==
* Rec
Category:Languages
Category:Turing complete
Category:Low-level
Category:Stack-based
Category:2023
Category:Implemented
Recurl

:You might be looking for Set, this language's former name.
Recurl is an esoteric programming language designed by User:Madk.
It is characterized by its data handling. Numbers and lists can be stored in lists, including the list itself, which can result in a list's contents being infinitely long.
==Instructions==
 example list:
 
 A:<4,4,3,5,8>
 
 A:<4,4,3,5,A>
 is a valid list. the 4,4,3,5 pattern of data would repeat infinitely.
 
 A:<4,A,3,5,8>
 would look like 4,4,4,4,4,4,4,4,4,4,4,...
 from the opposite end, ...3,5,8,3,5,8,3,5,8
 commands:
 
 define a list
 A:<...>
 
 append to the end of a list
 A]<...>
 
 append to the beginning of a list
 A[<...>
 
 define a set as the sum of two lists
 A:<B>+<C>
 A:<5,5,6,8>+<4,4,2,3,7> would become A:<9,9,8,11,7> - numbers that don't exist in one list are treated as 0
 this can be carried on,
 A:<B>+<C>+<D>
 and parenthesis can be used to modify the order of operations, which is pure left-to-right normally
 A:<B>+<<C>+<D>>
 
 other operations
 A:<B>-<C> subtract
 A:<B>*<C> multiply
 A:<B>/<C> divide
 A:<B>%<C> modulo
 
 output a list's contents, the first 3 numbers of the sequence
 A#3
 the last 3 numbers
 A#-3
 output all of them, this would cause a crash if used on an infinitely long set
 A#0
 alternative to #, $ outputs the ASCII equivalents of the numbers to allow outputting of a string
 A$0
 
 conditional statement, only do the code in the brackets if the first number in A is >0
 A?1<...>
 inverted conditional, do the code if the sum of all numbers in A is <1
 A!0<...>
 
 loop the code in the brackets as long as the first number of A is >0
 A@1<...>
 as long as the last number of A is <1
 A&-1<...>
 
 exit loop, terminate program if not in a loop
 ~
 
 add the constant 4 to the second number of A
 A+2<4>
 
 terminate program
 =
 
 line separator: ;
 A#3;A:<4,4>;B:<A>+<B>
 
 comment: \
 A#3; \ this is a comment.
==Examples==
===Hello, world!===
 A:<72,101,108,108,111,44,32,87,111,114,108,100,33>;A$0;
===99 bottles of beer===
 bottle:<98,111,116,116,108,101>;s:<115>;
 beer:<32,111,102,32,98,101,101,114>;wall:<32,111,110,32,116,104,101,32,119,97,108,108>
 take:<116,97,107,101,32>;one:<111,110,101>;it:<105,116>
 down:<100,111,119,110,44,32,112,97,115,115,32,105,116,32,97,114,111,117,110,100>
 no:<110,111,32,109,111,114,101>;newl:<255>;num:<98>;
 num@1<
 num+1<1>;num$1;bottle$0;s$0;beer$0;wall$0;num$1;bottle$0;s$0;beer$0;newl$0;
 take$0;one$0;down$0;newl$0;
 num+1<-1>;num$1;bottle$0;s$0;beer$0;wall$0;newl$0;num+1<-1>
 >
 num+1<1>;num$1;bottle$0;beer$0;wall$0;num$1;bottle$0;beer$0;newl$0;
 take$0;it$0;down$0;newl$0;
 no$0;bottle$0;s$0;beer$0;wall$0;newl$0;=;
Category:Languages
Category:Unimplemented
Category: 2011
RecurseMe

RecurseMe is a esoteric programming language invented by User:Zzo38 that the program code can call itself recursively.
==Commands==
* + - < > = Same as Brainfuck
* [ ] = Mark beginning and end of entire program, anything after ] is comments
* # = Call itself recursively
* Lowercase letters = Swap value at pointer with value of a register (all registers start at zero)
* Uppercase letters = If value of register is zero, then exit subroutine, if non-zero, then go back to beginning of subroutine
* ; : = Input to/output from last register swapped (if none, then error)
* Numbers 0 to 9 = Skip a number of commands if value at pointer is zero (so 0=NOP, 1=skips next command if value is zero, etc.)
* & = Skip next 2 commands
* / = Switch between main memory and auxilliary memory (only affects + - < > and numbers commands)
==SimulRecurseMe==
This variant of RecurseMe is one where you can have multiple programs running simultaneously (well, not really, because it has to wait for input/output, so it is more like coroutines), doing input and output between each other. You can also have macros.
Each subprogram is defined with name in {} before [ and each macro is defined with name in () before [ and macros are called with name in ()
Subprograms each have their own memory and registers, they run separately from main program and other subprograms. To select a subprogram to input/output with, use {} with name in between, in the program code. Use {} with nothing in between for I/O with the caller (with the program's main input/output if the main program).
Macros are included by writing their name within () within the program code. Macros do not accept parameters.
==Examples==
Cat program:
 [z;:Z]
Simple variable storage in SimulRecurseMe: (Make a variable with something like: {name}[(var)])
 (var)[zz:;1&++yY]
 (store)[z;zy:y]
 (recall)[z;:z]
Category:Languages
Category:2006
Recursion

Recursion is the concept of a process (usually a function or procedure) invoking itself as part of its evaluation or execution.
Some functions replace traditional loops like for-loops and while-loops with recursion. The idiom has a "base case" and a "recursive case" which is two options for when to stop calling oneself, and when to call oneself to find an answer. For example, here is the factorial function in pseudocode:
 function FACTORIAL( n : Unsigned Integer) {
 if n = 0 { return (1) }
 else { return (n * FACTORIAL(n - 1)) }
 }
(Factorial is a function that takes and integer, and multiplies it by all the numbers that come before it, e.g. FACTORIAL(4) = 1 * 2 * 3 * 4.) Here, the function picks: has it reached zero? If so, then factorial of zero is 1. Otherwise, it will be above zero. Noticing that FACTORIAL(4) = 1 * 2 * 3 * 4 = FACTORIAL(3) * 4, the non-zero case can be defined in terms of the FACTORIAL of previous numbers. Some favour recursive definitions because they are concise and match the common mathematical proof by induction.
==Induction==
Induction needs to prove that a condition holds for a certain value, then proves that if you change a certain thing about the value, it can't make the condition false. For example, starting from the assumption that 0 is a law-abiding number, and that n+1 is law-abiding if n is law-abiding, then the proof by induction says that every natural number is law-abiding. 0 is, so 1 is, so 2 is law-abiding, and so on. This can map to recursion easily. One might prove that 0 is even, that n+1 is odd if n is even, and that n+1 is even if n is odd. Then one can define two functions, odd(n) and even(n), that first check if n is zero, and if not, then they return the inverse of the result of their partner function called on n-1. One can prove that these functions will always give the right answer using that proof by induction.
==See also==
*Recursion
Category:Concepts
Recursion limit gone

Recursion limit gone is a regular language with essentially simple but hella-hard-to-read syntax, but...
The catch is, recursion limits can't exist, but theres no actual way to do any while/for loops except recursion. So it forces you to abuse the thing you once couldn't use fully before.
==Syntax==
See this language does not have a documentation for this, but it has been assumed it uses some really stupid other stuff, I do however know that this program was made, it looks somewhat reverse-engineerable, but theres apparently importing so that might be trouble.
 c[
 Output string forever in selected color. Sets color on: line 10 and uses t:: to try a line. And go to the except line
 e]
 v i: <<
 <l in * cons: al=cons
 v hk: <<
 I: e <<,:
 -[>>:p("Oops an error occur")
 t:: v res = m,conv[hx,hk]
 v s: cons:<<:o < cal:h[>hx,res]
 cons:<<:s[
 f: >(c):
 -[>>:p(c)
 -[:f, v = {c}
 :f, v = {i}
Category:Stubs Category:Languages Category:Joke languages
Recursive

Recursive is an esolang that is recursive.
== Commands ==
Each program must contain exactly one command, and there is only one possible command.
Command 	Action
The program's existence	Run the current program as a program in Recursive.
Non-existent programs are undefined behavior, although the most convenient action to take is to run the program in Recursive.
== Example programs ==
=== Infinite loop ===
 // This program is an infinite loop.
=== Self-interpreter ===
 // This program is a self-interpreter.
 // It first compiles any input into a more convenient representation.
 // Each command in the input is represented with a copy of this program.
 // Then, the compiled program is interpreted as Recursive.
=== Use an infinite amount of memory (for some interpreters) ===
 // This program uses an infinite amount of memory in this FALSE interpreter:
 // [$1_=~][^]#[r;!]r:r;!
 // The program causes the interpreter to call itself infinitely, thus using an infinite amount of the call stack.
=== Crash the interpreter (for some interpreters) ===
 // This program crashes in this Python interpreter:
 // def run_recursive(program):
 // if program is program: # if program exists, run program in Recursive
 // run_recursive(program)
== See also ==
* InterpretMe, a similar language that interprets the input instead of the program
* 0 Bits, 0 Bytes, which iterates instead of recurses
* ™ (types 36, 37, 38, and 39)
Category:Languages Category:Joke languages Category:2024 Category:Implemented Category:No IO Category:Thematic Category:Unusable for programming
Recursive sleeping

Recursive sleeping is a programming language that uses sleeping and recursive sleeping to do stuff
== Instructions ==
 Instructions
Thing 	Desc 	Ex
Sleep (while knowing (somethings))?:(code)Wake up	sleep maybe while knowing something 	Sleep:Wake up
Sleep layer 	returns the sleep layer 	Sleep layer (note: sleep layer is 0)
Remember (something) at this layer 	remember something and can go out of sleeping 	Remember Sleep:Wake up at this layer
Remember the thing remembered in (a sleep) 	returns the thing remembered in the sleep there	Remember the thing remembered in Sleep: 
 Remember Sleep: Wake upWake up
Use the (n)th thing you knew before 	returns the nth thing you knew when you slept 	Use the 1st thing you knew before
Use the (n)th thing you knew right now 	returns the nth thing you knew now 	Use the 1st thing you knew right now
== Examples ==
=== Cat ===
 Remember "hi" at this layer
 Remember the thing remembered in sleep while knowing (use the 1st thing you knew right now):
 Remember (use the 1st thing you knew before)
 Wake up
Recursoin

Recursoin is an esoteric programming language by User:A.
Variables are defined like:
var = bar
+- 	do math. For example:
 x=4
 Jerome=x - 2
sets x as value 4 and Jerome as value 2 (4-2). Also:
 fruit=fly
 printer=paper
 sticky=fruit + printer
sets fruit as value fly, printer as value paper, and sticky as value flypaper (word math only works with plus).
function x(parameters) 	starts a while loop named x with the given parameters.
end 	signifies the end of function.
if condition 	
starts an if(ends with end)	
Conditions have three parts, two compared values referenced by their names and a comparison which can be:
!= 	is not equal to
== 	is equal to
sendvalue x	
return x 	
==Example==
Ackermann Function:
 function Ackermann(m, n)
 if m==0
 sendvalue n+1
 end
 if m !=0
 if n==0
 sendvalue Ackermann(m-1,1)
 end
 if n!=0
 sendvalue Ackermann(m-1,Ackermann(m,n-1))
 end
 end
Category:Languages