nyuuzyou/wikis huggingface dataset:
RAND

RAND is an esoteric programming language created by User:Smallhacker, partially based on non-determinism. It's believed to be Turing complete, but this hasn't been proven.
== Memory ==
RAND's memory consists of an unspecified amount of bytes (where "unspecified" should be interpreted as "as much as neccesary"). When the program starts, all memory locations are set to random values. The memory is accessed using variables.
The memory isn't global; every call to a subroutine backs up the real memory by pushing it onto the stack and sets all bytes in the real memory to random values. When the program leaves the subroutine, the backed up data is popped into the real memory.
There's only one completely global byte and one "one way" global byte: the variable "Com" which isn't affected by the stack pushing/popping (which allows it to be used as input/output for subroutines) and the variable "Arg" which is affected by the stack popping, but not pushing (meaning that it can be used to send data into the subroutine, but not back from it).
== Commands ==
* RAND var - Sets 'var' to a random value
* AND var1 var2 - Sets 'var1' to 'var1' AND 'var2' (bitwise)
* OR var1 var2 - Sets 'var1' to 'var1' OR 'var2' (bitwise)
* ANDB var1 var2 - Same as AND, but only affects the lowest bit
* ORB var1 var2 - Same as OR, but only affects the lowest bit
* ROTR var1 - Shifts 'var1' to the right. The value wraps around (meaning that 1 becomes 128).
* LABEL name - A label used to jump around in the code
* IFEQ var1 var2 name - Jumps to label 'name' if 'var1' == 'var2'
* CALL name - Jumps to 'name' as a subroutine (pushing/clearing the memory)
* END - Leaves the subroutine (popping the memory) or exits the program if it's not in a subroutine.
C++-like comments (// and /* ... */) are allowed in the language.
== Variables/Labels ==
Variable/label names can contain a-z, A-Z, 0-9 and underscore. Names don't have to start with a letter.
Unlike variables, labels are global.
== Examples ==
=== Get0 ===
Description: A subroutine that sets Com to 0
 LABEL	Get0
 RAND	Com
 LABEL	Get0_Loop
 RAND	Tmp
 IFEQ	Com Tmp Get0_Loop
 AND	Com Tmp
 ROTR	Com
 AND	Com Tmp
 ROTR	Com
 AND	Com Tmp
 ROTR	Com
 AND	Com Tmp
 ROTR	Com
 AND	Com Tmp
 ROTR	Com
 AND	Com Tmp
 ROTR	Com
 AND	Com Tmp
 ROTR	Com
 AND	Com Tmp
 END
=== Get1 ===
Description: A subroutine that sets Com to 1
 LABEL	Get1
 CALL	Get0
 LABEL	Get1_Loop
 RAND	Tmp
 IFEQ	Com Tmp Get1_Loop
 ORB	Com Tmp
 ROTR	Tmp
 ORB	Com Tmp
 ROTR	Tmp
 ORB	Com Tmp
 ROTR	Tmp
 ORB	Com Tmp
 ROTR	Tmp
 ORB	Com Tmp
 ROTR	Tmp
 ORB	Com Tmp
 ROTR	Tmp
 ORB	Com Tmp
 ROTR	Tmp
 ORB	Com Tmp
 END
=== Get2 ===
Description: A subroutine that sets Com to 2
 LABEL	Get2
 CALL	Get1
 ROTR
 ROTR
 ROTR
 ROTR
 ROTR
 ROTR
 ROTR
 END
=== Get4 ===
Description: A subroutine that sets Com to 4
 LABEL	Get4
 CALL	Get1
 ROTR
 ROTR
 ROTR
 ROTR
 ROTR
 ROTR
 END
=== Get8 ===
Description: A subroutine that sets Com to 8
 LABEL	Get8
 CALL	Get1
 ROTR
 ROTR
 ROTR
 ROTR
 ROTR
 END
...etc.
Category:Languages
Category:Nondeterministic
RANDo

Language RANDo was created User:Kamish.
== Commands ==
Consists of 5 commands:
Command	Value
r 	adds random values to the variable(0 to 4)
a 	subtracts the value from the variable(0 to 2)
n 	prints the value of the variable(number)
d 	prints a character based on the value of variables(ASCII-table)
o 	zeroes the variable
If the value of the variable is greater than 9999, the program ends.
== Hello World ==
In this case, the code is:
rrrrrrrrrrnrrrrrrrrrrnrrrrrrrrrrnrrrrrrrrrrndo
rrrrrrrrrrnrrrrrrrrrrnrrrrrrrrrrnrrrnrnanananrnando
rrrrrrrrrrnrrrrrrrrrrnrrrrrrrrrrrrrrrnaaaaaanaaaaaando
rrrrrrrrrrrrrrrrrrrrnrrrrrrrrrrnrrrrrnrrnrndo
rrrrrrrrrrrrrrrrrrrrnrrrrrrrrrrnrrrrrnrrnrndo
ond
rrrrrrrrrrrrrrrrrrrrrrrrrnrrrrrrrrrrnrrrrrnrrrrnrnaananando
rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrnrrrrrnrnrnaanananrnaanananando
rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrnrrrrrrrrrrnrnananrnrnando
rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrnaaaaanaaaaanrnrnando
rrrrrrrrrrrrrrrrrrrrnrrrrrrrnrnrnanananando
== Interpreter in Python 3 ==
 import random
 def RANDo(code):
 v = 0
 for c in code:
 if c == "r":
 v += random.randint(0, 4)
 if v > 9999:
 return
 elif c == "a":
 v -= random.randint(0, 2)
 elif c == "n":
 print(v)
 elif c == "d":
 print(chr(v), end="")
 elif c == "o":
 v = 0
Category:Languages Category:Total Category:Unusable for programming Category:Implemented Category:Nondeterministic Category:Probabilistic
RC4 Mapfuck

This is a WIP. None of the stuff here is valid, I'm just too lazy to delete it. Purah126 (talk) 01:31, 22 March 2024 (UTC)
RC4 Mapfuck is an esoteric programming language created by User:Purah126. It is kind of like normal Mapfuck, but instead uses RC4 to change the map.
Each instruction has an ID:
* + = 0
* - = 1
* > = 2
* < = 3
* [ = 4
* ] = 5
* . = 6
* , = 7
First initialize RC4 with the key "RIZZLER GYATT SKIBIDI RIZZ FANUM TAX OHIO " (periodically update this with new memes) concatenated with each set 3 characters of the program, replaced by their ID, and then binary, and then concatenated together, discarding the last bit, and doing this to 256 bytes. Subsequent 3-character sets are XORed with previous ones.
Then, repeat for each character in the program:
Encrypt the whole text with RC4
Evaluate the first 3 bits
RDF-fuck

This is experiment to make a programming language with RDF graphs like XMLfuck is using XML documents. It is like brainfuck because it is a simple way to do and because XMLfuck does it; later on other extensions can be added to in order to make a different kind of programming language instead.
There is one instruction pointer which points to a node, and a call stack of list of pointer to nodes. There is also the tape which is the standard tape of brainfuck.
The instruction pointer initially points to the node with an edge of type gopher://zzo38computer.org/1ns/meta:primary leading out of it.
In order to execute a node:
* Look for an edge of type http://www.w3.org/1999/02/22-rdf-syntax-ns#first; that tells it what to do.
* Normally, the next node to execute is whatever the http://www.w3.org/1999/02/22-rdf-syntax-ns#rest of that node leads to.
The possible commands are:
* http://esolangs.org/wiki/RDF-fuck#inc increments the value on the tape.
* http://esolangs.org/wiki/RDF-fuck#dec decrements the value on the tape.
* http://esolangs.org/wiki/RDF-fuck#ptrinc increments the tape pointer.
* http://esolangs.org/wiki/RDF-fuck#ptrdec decrements the tape pointer.
* http://esolangs.org/wiki/RDF-fuck#read inputs a byte.
* http://esolangs.org/wiki/RDF-fuck#print outputs a byte.
* A node that has a http://www.w3.org/1999/02/22-rdf-syntax-ns#first from it is a loop: If the value at the tape pointer is nonzero, instead of going to next, push current instruction pointer to stack, go to this node and execute from here.
* http://esolangs.org/wiki/RDF-fuck#exit is used to exit a loop or the program, by popping from the call stack to determine what to execute next, instead of going to the next node normally. (This will be the node for the loop, in case of a loop; therefore it will try to execute it again.)
There is one built-in triple <http://www.w3.org/1999/02/22-rdf-syntax-ns#nil> <http://www.w3.org/1999/02/22-rdf-syntax-ns#first> <http://esolangs.org/wiki/RDF-fuck#exit>. Adding it explicitly to your program is redundant.
==Example==
 @prefix : <http://esolangs.org/wiki/RDF-fuck#>.
 (:read (:print :read)) <gopher://zzo38computer.org/1ns/meta:primary> [].
REALScript

REALScript is modified version of FakeScript by User:ChuckEsoteric08. Any argument that start with "#" is variable
==Commands==
Command 	Meaning
print [arg1] 	same as in FakeScript
input [arg1] 	input variable [arg1](arg need to start with "#")
goto [arg1] 	same as in FakeScript
if [arg1] [arg2] [label]	same
!label [label] 	same(again)
stop 	stops the program(same, again)
new [arg1] 	declare variable [arg1] with value 0
set [arg1] [arg2] 	set variable [arg1] value [arg2]
letter [arg1] [arg2] 	set variable [arg1] to first letter of [arg2]. If [arg2] was variable, then delete that letter
==Examples==
===Cat===
 !label 1 
 new a 
 input #a 
 print #a 
 goto 1
===Hello, World!===
 print Hello_World!
===Truth machine===
 new a 
 input #a 
 if #a 1 1 
 if #a 0 0 
 stop 
 !label 1 
 print 1 
 goto 1 
 !label 0 
 print 0 
 stop
===Infinity loop===
 !label 1 
 print Hello_World! 
 goto 1
===First letter of input===
It will ask for input, output first letter of it in first line, and anything else in other
 new inp new char input #inp letter char #inp print #char print #inp
===Addition===
 new a 
 new b 
 new c 
 input #a 
 input #b 
 !label 1 
 letter c #a 
 if #c ; 2 
 print * 
 goto 1 
 !label 2 
 letter c #b 
 if #c ; end 
 print * 
 goto 2 
 !label end 
 stop
It adds length of two inputs(they need to end with ;, but it not counting) and print * that many times. So if inputs are:
 ***;
 ***;
It will print 6 *s
==REALScript++==
REALScript++ is a REALScript, but with two new commands:
if! [arg1] [arg2] [label]	if [arg1] and [arg2] are NOT equal goto label [label]
join [arg1] [arg2] 	join variable [arg1] and [arg2]([arg2] can be both string and variable)
==Interpreters in REALSCript++==
+-=
 print +-=Interpreter 
 print YourCode: 
 new code 
 new acc 
 new t 
 new cmd 
 input #code 
 join code ; 
 letter t #acc 
 !label run 
 letter cmd #code 
 if #cmd ; end 
 if #cmd + inc 
 if #cmd - dec 
 if #cmd = out 
 goto run 
 !label inc 
 join acc * 
 goto run 
 !label dec 
 letter t #acc 
 goto run 
 !label out 
 print #acc 
 goto run 
 !label end 
 print CodeExecuted. 
==Computational class==
Both are Turing complete because you can translate 1-bit BF into that languages, but in REALScript++ you can also make BF with 2 or more bits wide . In REALScript++ you can (maybe) complile Bitwise Cyclic Tag and if you can, it would also make it Turing-complete
==External resourses==
Scratch interpreter
REALScript++ interpreter
Category:Languages Category:2022 Category:Turing complete
REBEL

REBEL stands for Regular Expression Based Esoteric Language. REBEL is a declarative programming language that works by iteratively replacing substrings.
A program in REBEL consists of an initial state and a list of regular expression substitutions, separated by slash characters:
: initial state/RE/RHS/RE/RHS/...
where RE is a regular expression and RHS is the right hand side that is substituted if that RE matches. 
Special constructs $< and $> in the RHS allow for input and output respectively.
The program execution is deterministic: at each step the first possible substitution is performed on the string, until no substitution is possible.
==Computational class==
The trivial possibility of translation from any deterministic Thue program into REBEL gives a proof that REBEL is Turing-complete.
==External resources==
Specification
Category:Languages
Category:2013
Category:Implemented
Category:String-rewriting paradigm
Category:Turing complete
REDGREEN

REDGREEN is an update to RUBE, written in ALPACA. Unlike RUBE, it is a proper cellular automaton, not a bully automaton. As such, its description is much cleaner and its behavior is easier to predict, while it retains most of the "feel" of RUBE.
==Computational class==
REDGREEN contains John Conway's Game of Life cellular automaton as a subset within it, and Life has been shown to be Turing-complete; thus, REDGREEN should also be Turing-complete.
==External resources==
* 
Category: Languages
Category: Implemented
Category: Cellular automata
Category: Two-dimensional languages
Category: 1999
REG.TYPE = STR TRUE

REG.TYPE = STR TRUE is a esolang (made by User:yayimhere) with a register. but the register is a string. it can be modified copied printed ect. REG.TYPE = STR TRUE or R.T=ST's goal is to see if using only a single unbounded string can there be made a turing complete esolang.
== overview ==
the string starts with the following string inside at the start:
 fgr45fevre4er5>1<2u31i<y7<3698yugtkhjsdfbjkgdbøfsopgt50r8y69re8988)()UYHJFCŸŸÂ˜{\ÜÁ»Ü‡\}\}\\}≈{}≈\\˜$¢¢‰‰{\}}≈¿
there is no explicit reason for this. REG.TYPE = STR TRUE & "" will start with a empty string
the register is circular so it wraps around. If a parameter has "" its a full string else its a single char
=== syntax ===
the syntax of REG.TYPE=STR TRUE:
 Caption text
R.T=ST 	description 	pseudocode
+"A" 	will concatenate A with the register 	REG concatenate A
[i]"A" 	replace what's at index i with A 	REG[i] = A
[i]! 	replace what's at index i with EOF input 	REG[i] = input
\(e) 	start at index 0 and do the operation(s) e on the whole string repeat operation until i has been found at index 0 twice	while i < length(REG) do e and i+1
A/(e) 	start at index 0 and do the operation(s) e on the string until A is met in the string 	while REG[i] != A do e and i+1
# 	clear the string 	REG = ""
"A"->"B"	replace all instances of A with B 	if REG[i] == A do REG[i] = B
o 	output the register 	print(REG)
[i]o 	output whats at index i 	print(REG[i])
[i]:A 	save the index i with label A. any i used in any instruction can be replaced with a label 	A = i
A+= 	increment index of label A 	A+1
A-= 	decrement index of label A 	A-1
[i]:+ 	increment the ascii value of the ascii char at index i 	REG[i]+1
[i]:- 	decrement the ascii value of the char at index i 	REG[i]-1
[i]+"A">	add A after index i 	REG[i] concatenate A
[i]+"A"<	add A before index i 	reverse(REG[i] concatenate A)
; 	line initial ; will make it comment 	?
== examples ==
hello, world!:
 #+"Hello, world!"o
truth-machine:
 #[0]!0/(o)o
looping counter:
 #+"*"A/(o[0]+"*"<+"/n")
quine:
 +"+#"[1]-o[1]+o#+"#\2^.p\2^,p $,#Z#\1^;J!)\J^pJ,>*![0)\1^*!\1^!)\J^.J,>*!"[0]:I\([I]oI+=)Z/([0]"")[0]""\([I]-I+=)o
=== turing completeness ===
this program emulates the 2-tag system that calculates the Collatz sequence:
 ; alphabet: {a, b, c}
 ; reserved: {E, B, D, I}
 ; a -> bc
 ; b -> a
 ; c -> aaa
 ; initial word: aaa
 
 #+"aaaD" 
 ;setup
 
 I/(
 ; separate head
 [1]+"B"<
 ; halt if only one char left
 "aBD"->"I"
 "bBD"->"I"
 "cBD"->"I"
 ; apply rules
 "aB"->"bcE"
 "bB"->"aE"
 "cB"->"aaaE"
 ; perform second deletion
 "Ea"->""
 "Eb"->""
 "Ec"->""
 "E"->""
 )
with no comments and such:
 #+"aaaD"I/([1]+"B"<"aBD"->"I"bBD"->"I""cBD"->"I""aB"->"bcE""bB"->"aE""cB"->"aaaE""Ea"->"""Eb"->"""Ec"->"""E"->"")
Category:Languages
Category:String-rewriting paradigm
Category:2024
Category:Turing complete
Category:Low-level
REGXY

REGXY is an esoteric programming language by User:Zzo38 based on regular expressions. It has two kinds of command, test and change. The program operates on an input string starting at the top of the program and running each command. On reaching the end it outputs the string. The command syntax and meaning is:
* test: label/regex/target_label (jumps to the target label if the regex matches)
* change: label/regex/substitute/ (does a regex substitution and supports backrefs like $1,$2,..)
== Examples ==
Reverse a string:
<nowiki>
a/$/_/
b/(.)(.*)_/$2_$1/
c/(.)(.*)_/b
d/_// 
</nowiki>
99-bottles of beer (modified slightly to suit modern implementation):
<nowiki>
0/^.*$//
a//z9az8az7az6az5az4az3az2az1aza/
b/z([0-9]?)a/x${1}9x${1}8x${1}7x${1}6x${1}5x${1}4x${1}3x${1}2x${1}1x${1}0/
bq/z([0-9]?)a/b
rc/x([0-9][0-9]?)/$1 botles uv beer. $1 botles uv beer on the wall, $1 botles uv beer, Take 1 down and pass it around, /
rcq/x([0-9][0-9]?)/rc
d/^99 botles uv beer. //
e/, 0 botles uv beer.*$/, No more botles uv beer on the wall./
</nowiki>
Self hosting RegXY to perl implementation:
<nowiki>
sanitize/(^|\n)([^\/]*)\+([^\/]*)\/(([^\/]|\\.)*)\/(([^\/]|\\.)*)\/(\n|$)/$1$2_plus$3\/$4\/$6\/$8/
sanitizf/(^|\n)([^\/]*)\+/sanitize
sanitizg/(^|\n)([^\/]*)\/(([^\/]|\\.)*)\/([^\/]*)\+([^\/]*)(\n|$)/$1$2\/$3\/$5_plus$6$7/
sanitizh/\+([^\/]*)($|\n)/sanitizg
loop/(^|\n)([^\n\/ ]*)\/(([^\/]|\\.)*)\/([^\n\/]*)(\n|$)/$1 l$2: if(\$i =~ m\/$3\/s) { goto l$5; }$6/
looq/(^|\n)([^\n\/ ]*)\/(([^\/]|\\.)*)\/(([^\/]|\\.)*)\/(\n|$)/$1 l$2: \$i =~ s\/$3\/$5\/s;$7/
loor/(^|\n)[^ ]/loop
start/^/local \$\/; \$i =<>;\n/
finish/$/\nprint(\$i);/
</nowiki>
== Implementation ==
In Perl:
<nowiki>
local $/; $i =<>;
 lsanitize: $i =~ s/(^|\n)([^\/]*)\+([^\/]*)\/(([^\/]|\\.)*)\/(([^\/]|\\.)*)\/(\n|$)/$1$2_plus$3\/$4\/$6\/$8/s;
 lsanitizf: if($i =~ m/(^|\n)([^\/]*)\+/s) { goto lsanitize; }
 lsanitizg: $i =~ s/(^|\n)([^\/]*)\/(([^\/]|\\.)*)\/([^\/]*)\+([^\/]*)(\n|$)/$1$2\/$3\/$5_plus$6$7/s;
 lsanitizh: if($i =~ m/\+([^\/]*)($|\n)/s) { goto lsanitizg; }
 lloop: $i =~ s/(^|\n)([^\n\/ ]*)\/(([^\/]|\\.)*)\/([^\n\/]*)(\n|$)/$1 l$2: if(\$i =~ m\/$3\/s) { goto l$5; }$6/s;
 llooq: $i =~ s/(^|\n)([^\n\/ ]*)\/(([^\/]|\\.)*)\/(([^\/]|\\.)*)\/(\n|$)/$1 l$2: \$i =~ s\/$3\/$5\/s;$7/s;
 lloor: if($i =~ m/(^|\n)[^ ]/s) { goto lloop; }
 lstart: $i =~ s/^/local \$\/; \$i =<>;\n/s;
 lfinish: $i =~ s/$/\nprint(\$i);/s;
print($i);
</nowiki>
== External resources ==
* Zzo38's directory of REGXY implementation and programs
* REGXY entry on C2 Wiki
* 
Category:Languages
Category:Turing tarpits
Category:String-rewriting paradigm
Category:Implemented
Category:Unknown year
RELATIONS

RELATIONS is an esoteric programming language created by User:Kamish.
This language is absolutely useless and has 8 commands:
Command 	Description
youre beautiful 	auxiliary command for text output
whether only my 	auxiliary command for text output
i love you 	writing text (on the next line) to a variable
do not leave me 	the construction of the square
want to be with you 	square root of a number
lets start all over again	reset a variable
go away. 	the output from the interpreter
lets meet 	program start
==Hello World!==
youre beautiful
whether only my
i love you
Hello World!
lets meet
Category:Languages
Category:Total
Category:Unusable for programming
Category:Unimplemented
Category:2019
RENE

RENE is a language that sometimes shows up on lists of Lesser known programming languages.
Named after the famous French philosopher and mathematician Rene Descartes, RENE is a language used for artificial intelligence. The language is being developed at the Chicago Center of Machine Politics and Programming under a grant from the Jane Byrne Victory Fund. A spokesman described the language as "Just as great as dis [sic] city of ours."
The center is very pleased with progress to date. They say they have almost succeeded in getting a VAX to think. However, sources inside the organization say that each time the machine fails to think it ceases to exist.
Category:Joke languagesCategory:Languages
RESOI

RESOI is a Rust based application designed to be shipped in a single binary and be able to run a variety of Esolangs.
== Usage ==
Usage:
 resoi [OPTIONS] --file <file> --lang <lang>
Flags:
 -h, --help Prints help information
 -V, --version Prints version information
Options:
 -f, --file <file> Input file
 -l, --lang <lang> Esolang to run against
 -o, --outfile <outfile> Output file
 -t, --transpile <transpile> Whether to transpile or interpret the file
== Supported Languages ==
Language 	Interpreter Status	Transpiler Status
Brainfuck	✅ 	✅
AmBored--	✅ 	❌
4DChess 	✅ 	❌
Boolfuck 	✅ 	❌
Category:Implementations
REverge

REverge (a deliberate typo for "revenge") is an esoteric programming language by ihope127 based on the concept of "data replacements". The syntax:
 <program> ::= {<declaration> (<newline> | <comma>)}
 <declaration> ::= <lowercase-letter> {<uppercase-letter> <letter> <letter>}
In this language, every value is a function. Functions represented by lowercase letters are defined in the program's source code, and functions represented by uppercase letters are special "constructor" functions. Applying a constructor to a value simply holds the value along with the constructor, not doing anything with it.
To be continued. It seems that `ki can only be defined recursively... oops.
Category:Works-in-Progress
RISBF

RISBF is a brainfuck equivalent with only 4 characters. RISBF stands for Reduced Instruction Set Brain Fuck and was created by Michael Gianfreda, Aug. 14, 2013. A RISBF variant is tinyBF.
== Commands ==
Command	Description
* 	Switch destination (pointer <-> memory cell)
+ 	Increment selected destination
- 	Decrement selected destination
/ 	Start of the following two-character sequence commands:
// 	Output the character signified by the cell at the pointer. BF equivalent: .
/* 	Input a character and store it in the cell at the pointer. BF equivalent: ,
/+ 	Jump past the matching /- if the cell under the pointer is 0. BF equivalent: [
/- 	Jump back to the matching /+ if the cell under the pointer is nonzero. BF equivalent: ]
== Examples ==
=== Hello World ===
 ++++++++++/+*+*+++++++*+*++++++++++*+*+++*+*+*----*-/-*+*++//*+*+//+++++
 ++////+++//*+*++//*--*+++++++++++++++//*+//*+++//------//--------//*+*+/
 /*+//----
== External resources ==
* A Haskell implementation
Category:Languages
Category:Cell-based
Category:Brainfuck equivalents
Category:2013
Category:Turing complete
Category:Low-level
Category:Implemented
RLEflakes

Work In Progress.
RLEflakes is RLE-compressed version of branflakes
== Compression method ==
1. Convert branflakes according to this table:
branflakes|RLEflakes
+ |000
- |001
> |010
< |011
. |100
, |101
[ |110
] |111
2. Put the run length to make one run of 1-32 commands fit into a byte.
== Examples ==
Hello World:
Original:
 +[-->-[>>+>-----<<]<--<---]>-.>>>+.>>..+++[.>]<<<<.+++.------.<<-.>>>>+.
Binary dump of RLE-compressed version:
00000000
00000110
00001001
00000010
00000001
00000110
00001010
00000000
00000010
00100001
00001011
00000111
00000011
00001001
00000011
00010001
00000111
00000010
00000001
00000100
00010010
00000000
00000100
00001010
Category:Languages Category:Brainfuck equivalents Category:Brainfuck derivatives Category:Turing complete Category:Turing tarpits Category:Cell-based Category:Low-level Category:Unimplemented Category:Works-in-Progress
RLS

rLS (revised/reduced Lambdastack) is a stack programming language based on Lambdastack. It removes most of the ugliness and several features from the old one, but also adds support for new ones.
==Commands==
[vars:code]	Push a limiting lambda with variables in vars as input
[code] 	Push a limiting lambda with no input
{vars:code}	Push a non-limiting lambda with variables in vars as input
{code} 	Push a non-limiting lambda with no input
' 	Run the lambda on top of stack
" 	Convert lambda with input to one without input by popping the needed arguments from stack and applying them, without running the lambda
variable 	Push the contents of a variable
==Variables==
Variables are either one character long, in which case they can be written as is (e.g. x), or longer, in which case they need to be enclosed in parentheses (e.g. (foo)). Variables are visible only inside the lambda they were bound from, and this does not include other lambdas lexically inside it.
==Limiting / Non-limiting Lambdas==
Limiting lambdas function like lambdas in original Lambdastack, in that they prevent any stack access into the stack outside what was pushed by the lambda itself. Non-limiting lambdas on the other hand allow this. They are effectively equivalent to Lambdastack's [%vars:code], except when converted into inputless they don't take the whole stack with them.
==Computational class==
All Underload commands except for S can easily be transformed into rLS. Therefore, rLS is Turing-complete.
Underload	rLS
~ 	[xy:yx]'
: 	[x:xx]'
! 	[x:]'
* 	{xy:x'y'}"
(code) 	{code}
a 	[x:x]"
^ 	'
Category:Languages Category:Stack-based Category:Turing complete Category:Unimplemented Category:2015