nyuuzyou/wikis huggingface dataset:
Rickroll

It is very simple: every program is a Never Gonna Give You Up program.
==Examples==
===Never Gonna Give You Up===
 
===Quine===
We're no strangers to love
You know the rules and so do I (do I)
A full commitment's what I'm thinking of
You wouldn't get this from any other guy
I just wanna tell you how I'm feeling
Gotta make you understand
Never gonna give you up
Never gonna let you down
Never gonna run around and desert you
Never gonna make you cry
Never gonna say goodbye
Never gonna tell a lie and hurt you
We've known each other for so long
Your heart's been aching, but you're too shy to say it (say it)
Inside, we both know what's been going on (going on)
We know the game and we're gonna play it
And if you ask me how I'm feeling
Don't tell me you're too blind to see
Never gonna give you up
Never gonna let you down
Never gonna run around and desert you
Never gonna make you cry
Never gonna say goodbye
Never gonna tell a lie and hurt you
Never gonna give you up
Never gonna let you down
Never gonna run around and desert you
Never gonna make you cry
Never gonna say goodbye
Never gonna tell a lie and hurt you
We've known each other for so long
Your heart's been aching, but you're too shy to say it (say it)
Inside, we both know what's been going on (going on)
We know the game and we're gonna play it
I just wanna tell you how I'm feeling
Gotta make you understand
Never gonna give you up
Never gonna let you down
Never gonna run around and desert you
Never gonna make you cry
Never gonna say goodbye
Never gonna tell a lie and hurt you
Never gonna give you up
Never gonna let you down
Never gonna run around and desert you
Never gonna make you cry
Never gonna say goodbye
Never gonna tell a lie and hurt you
Never gonna give you up
Never gonna let you down
Never gonna run around and desert you
Never gonna make you cry
Never gonna say goodbye
Never gonna tell a lie and hurt you
==Interpreters==
* Interpreters of this esolang
 Category:2023 Category:Implemented Category:Nope. derivatives Category:No-code esolang
Ridewith

Ridewith is a esolang created by User:Yayimhere for creating ascii art
== memory ==
memory is a grid(infinite) with a pointer starting at (0, 0). the places the pointer goes are drawn on
== syntax ==
there is dis syntax:
 start direction
 (
 transitions)(yes every line must end with a ) lol)
 (
the start direction is the direction the pointer moves in for one step. the transitions have dis format:
 %number of steps in dir(x) dir;new dir
so dis says:
 if the pointer has moved in dir x times it changes pointer direction to new dir
the directions are: 
 } left
 { right
 ⏟ up
 ⏞ down
 ( (only in new dir) halt
so dis program:
 ⏟
 (
 %1 ⏟;{)
 %2 {;⏟)
creates:
 ...
 |
 --
 |
 --
 |
 .
where the pointer starts above the .
Category:Cell-based Category:Languages
Right

Right is a fungeoid created by User:D in 2023. The IP cannot do much in the codespace, except for (as the name suggests) some very basic operations.
== Storage ==
Right uses a queue for storage. Initially, there are 2 1 bits in the queue, known as the 'markers'. These markers cannot be pushed into the queue, nor can they be popped from the queue. (e.g. When the * command is called when the head of the queue is the marker, it's simply popped and pushed back again.)
The queue only allows 0 bits to be pushed into and out of the queue.
== Execution ==
The codespace is a rectangular grid of characters.
Initially, the IP starts at 0:0, facing the right. The following commands are recognized:
Command	Description
+ 	Turn IP right (see below)
. 	Enqueue a 0 bit into the queue.
* 	Dequeue & Skip (see below)
  	No-op.
The IP may wrap around if it goes around the edge of the codespace.
=== Turn right ===
It works like a regular fungeoid. E.g. If IP's facing right before hitting +, then it's now facing downwards:
-->+
 |
 v
=== Dequeue & Skip ===
It does the following:
* Dequeue a bit from the queue.
* If it's the marker bit:
:* Enqueue the marker bit back to the queue.
:* Continue execution.
* Otherwise:
:* Skip the next character in front of the IP.
Category:Languages
Category:2023
Category:Unimplemented
Category:Two-dimensional languages
Category:Queue-based
RightSlash

RightSlash is esolang by User:ChuckEsoteric08 with left-infinite tape with cells with values 0-F. User:ChuckEsoteric08 forgot to save .txt file so not much specification is known. What is known that it has no increment/decrement commands, it used characters > and \ and only control flow statement is jump if not equal. It also used memory mapped I/O. If you are comparing cell with itself and it's value is zero then store next byte of input in previous two cells, with most significant digit to the right and if it's nonzero output previous two cells as ASCII character
==Brainfuck interpreter==
Uses right-infinte tape and 8-bit nonwrapping cells
Program seperated from input by a space 
 >\>\>>>>>\\\\\\\\\\\\>>>>>>>\\\\\>>>\>\>
 \\\>>>\>>\>\\\>\\>>\\>>\\\\>>\\>>\\>>>>>\\\\\\>>\>>>\>>>\>>\>>>>>>>>
 >\\\\\\\\\\\\\\>>>>\\\>>>>>>>>>>>>\\\\\\\\\\\\\\\\\
 >>>>>>>>>\>>\\>>>\\\>\\\\\\\\>>>>>\\\\ \\\\\\\\\\\\\\\>>>>>>>>\\\\\
 \\>>>>\\\\\\\\\\>>>>>\\\>>>>>>>>>>>\\\\\\\\\>>>>>>>>>>>>>>>>>
 >>>>\\\>>>>\\\>>>>>>
 >>>>>>>>>>>>>>>>>>>>>>>
 >>>>>>>>>>>>>>>>>>>>>>\\\\\\\\\\\\\\\\\\\\
Category:Languages Category:Cell-based
Right bracket

] is an esoteric programming language made by User:iconmaster after a discussion on the IRC channel. Its main pupose is to make a language with nothing but brackets and parentheses that are unmatched. Needless to say, ] does not accept programs that are all matched brackets.
== Description ==
Only the characters ()<>{}[] are valid ] commands. If all the pairs of a certain type of bracket match, the program is invalid. In ], there is a stack in which to push and pop two symbols: " and '. There is also something called the Metastack, which holds multiple stacks.
== Commands ==
* ( Pushes a " onto the stack.
* ) Pushes a ' onto the stack.
* < Pops a value off the stack.
* > Swaps the top 2 elements on the stack.
* { Jumps to the first non-matching } if the top value on the stack is ".
* } Jumps to the first non-matching (looking backwards) { if the top value on the stack is ".
* [ Pushes the current stack onto the Metastack.
* ] Pops a stack from the Metastack and concatenates it to the current stack.
== Code Snippets ==
Duplicate the top element:
 {)}}(
Change a ' into ", and vice versa:
 (<{<(}}<)
Add " to the stack forever:
 ({){<(}}{
== Implementation ==
A Lua implementation is available at User:Iconmaster/rb.lua.
Category:Languages
Category:2011
Category:Stack-based
Category:No IO
Category:Implemented
Ririsu

Ririsu is a small, untyped and stack-based concatenative language
with some more interesting features like dynamic scoping and occasional
purity. The language is under active development, and some features
have not been implemented yet, like concurrency.
== Overview ==
In Ririsu everything is a pure function that takes
in a Stack and Environment and returns a new Stack and Environment.
Whenever a token can't be applied (either it isn't understood, or
the expected parameters don't match), the token gets pushed onto the
Stack.
Since there's no I/O operation in the language, the initial Stack
is the contents of the STDIN, and the remaining of the Stack after
running the program gets output to the STDOUT.
== Examples ==
Compute the sum of all numbers in a list:
 [123456789][li]|[+].
Find all the even numbers in a list:
 [123456789][li]|[[2]i~%[0]i=]#
Solve the 100 Doors problem:
 [e]h[^[f]~[[1]i~-]~[2]i>!?],r[s^o=]|
== External resources ==
* The canonical implementation, in Erlang
* Language's documentation
* API reference
Category:Languages
Category:2013
Category:Implemented
Category:Stack-based
Category:Turing complete
River

River is a esolang created by User:Yayimhere based on The Waterfall Model. it was named River because it's based on number bases and a waterfall base is...A River
== computation ==
first of all every waterclock will have a list of actions for any value it can has.
these actions are set some clock to base something but still treated. so if the waterclock we change is 2 and you changed the base to binary the returned number would be 10...in base 10
this can get very weird.
Category:Languages Category:2024
Rnadom

User:Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff made it
==commands==
 q: tape head := random(0,9) //also different from the current cell
 {: if tape head < 1 skip to matching "}"
 }: tape head decrement; if non-negative skip to matching "{"
 r: move tape head right
 ~: print amount of problems as a number
 l: move tape head left
 >: get input as a number (put -1 on invalid number)
 \: print tape head as roman numeral
 #: halt
 ": jump to next newline
 all other commands add a problem to the cell
 10 problem = death to a cell and if you do anything with it the program outputs either "💥" or "10"
==programs==
===XKCD Random Number===
 xkcd~
===Actual Random Number===
 q{+}~
===Infinite Loop===
 q{rq}
===truth machine===
 >{!rq{rq}}~
===Cat program===
 >{+}~
only works from 0 ~ 9
===polyglot===
v='!iiiso~#::=hF'; print(9); p='''
>9.@::=F
Number::=~9
::=
Number'''
Works in Rnadom, Befunge, Thue, Deadfish, Python, and Deadfish~.
Prints the string "9" to the console.
===Read Input forever===
 q{{}qr>l}
Category:Languages Category:Cell-based Category:Unimplemented Category:Nondeterministic Category:Probabilistic
Roadrunner

Roadrunner is a Brainfuck clone language created by Katrina Scialdone. It is based off of the popular Looney Tunes character Roadrunner, who, as is fairly well known, pretty much only ever says 'Meep meep!'.
The language currently only has one implementation in the form of a Python interpreter; the interpreter in question can also be easily modified to produce a Brainfuck clone with any syntax (to a certain extent). It includes a compiler from Brainfuck to the clone language as well.
==Commands==
Each command in Roadrunner is the word 'meep' with different capitalization, separated by spaces. Any unrecognized tokens will be ignored - however, be careful not to use 'meep' in any comments.
BF Command	RR Command	Description
> 	meeP 	Move the pointer to the right
< 	Meep 	Move the pointer to the left
+ 	mEEp 	Increment the memory cell under the pointer
- 	MeeP 	Decrement the memory cell under the pointer
. 	MEEP 	Output the character signified by the cell at the pointer
, 	meep 	Input a character and store it in the cell at the pointer
[ 	mEEP 	Jump past the matching ] if the cell under the pointer is 0
] 	MEEp 	Jump back to the matching [ if the cell under the pointer is nonzero
==Computational class==
Roadrunner is a direct syntax swap of Brainfuck, therefore it is Turing-complete.
==Examples==
===Hello, world!===
mEEp mEEp mEEp mEEp mEEp mEEp mEEp mEEp mEEp mEEp mEEP meeP mEEp mEEp mEEp mEEp mEEp mEEp mEEp meeP mEEp mEEp mEEp mEEp mEEp mEEp mEEp mEEp mEEp mEEp meeP mEEp mEEp mEEp meeP mEEp Meep Meep Meep Meep MeeP MEEp meeP mEEp mEEp MEEP meeP mEEp MEEP mEEp mEEp mEEp mEEp mEEp mEEp mEEp MEEP MEEP mEEp mEEp mEEp MEEP meeP mEEp mEEp MEEP Meep Meep mEEp mEEp mEEp mEEp mEEp mEEp mEEp mEEp mEEp mEEp mEEp mEEp mEEp mEEp mEEp MEEP meeP MEEP mEEp mEEp mEEp MEEP MeeP MeeP MeeP MeeP MeeP MeeP MEEP MeeP MeeP MeeP MeeP MeeP MeeP MeeP MeeP MEEP meeP mEEp MEEP meeP MEEP
The equivalent Brainfuck program:
++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.
==External resources==
* Official Roadrunner Interpreter
Category:Languages
Category:2015
Category:Brainfuck equivalents
Robol(in)

Robol(in) is an incomplete specification by user:David.werecat. It will probably never be updated or implemented.
== Specification ==
Command 	Description
VAR ___ IS ______ 	Declare a variable
SET ___ TO ______ 	Points a pointer at a variable
PUSH ___ 	Pushes a variable onto the stack
POP ___ 	Retreives the next item from the stack
PEEK ___ 	Peeks the next item from the stack
NOTIFY ___ 	Like Return
EXEC ___ 	Executes a method
FLAG ___ 	Creates a flag (a temporary label)
FOCUS ___ 	Begins execution at flag
DISP ___ 	Displays text on console
INPUT ___ IS _____ 	Reads user input as a datatype
ZERO ___ 	Erases a variable
API ___.DLL 	Begins an api section
DECL ___ 	Imports a function from a DLL
LAST 	End a section
CALL ___<_____(___,___)>	Calls an api function with given parameters
WAIT ___ 	Waits a number of nanoseconds
SIGNAL ___ 	Creates a signal (event)
TRIGGER ___ 	Triggers a signal (event)
MONITOR ___<_____> 	Sets a function to monitor a signal so it is run on trigger
REG<___> 	Accesses a register (see register definitions)
MATH ___ 	Executes a math statment
OPEN ___ ___ 	Opens a file to a file variable (the variable references the file)
READ ___ ___ ___ ___ 	Reads an certain ammount of data from a file variable at a certain offset
START 	Marks the entry point
FINISH 	Quits the program
CLROUT 	Clears the console
MASTER ___ ___ 	Sets one variable to be anothers master (linked objects)
SERVANT ___ ___ 	Sets one variable to be anothers servant (linked objects)
PROMOTE ___ 	Dereferences a servent from its master
DEMOTE ___ 	Dereferences a master from its servant
Category:Languages
Category:2011
Category:Unknown computational class
Category:Unimplemented
Robolang

Robolang is a programming language made by Oklomsy, Robolang has a javascript interpreter (Removed) and also a lua interpreter.
== Commands ==
Robolang only has four commands...
Beep, Boop, Bap, Boap
Beep prints anything you give it to the console.
For example: Beep("A") prints "A" to the console.
Boop checks if a number is larger than another number.
Bap does the opposite and checks if a number is smaller than another number.
Boap checks if both numbers are Equal.
For example:
Boop(1,2) will return false since 1 is not larger than 2.
Bap(1,2) will return true since 1 is smaller than 2.
Boap(1,2) will return false since 1 and 2 are not the same.
== Interpreter ==
A new and improved Lua interpreter has been made by Sparksammy
It can be found Here.
Category:Languages
Category:Joke languages
Category:2020
Category:Unusable for programming
Category:Unknown computational class
Category:Output only
Category:Implemented
Category:Total
Robotic smiley face

The esoteric programming language :] is a language by Cinnamony made practicly out of only smileys.
== Commands ==
The given description for :0 is "says what is infront of it, string, number, or variable"
The given description for :| is "when alone, calls for user input"
when used with :0 behind it, calls for user input and then says it
when used with :) behind it, it sets the variable to user input"
The given description for :) is "when alone, sets variable to blank"
when used with :0 behind it, says the variable
when used with :) behind it, sets variable to itself
when used with a string infront of it, sets variable to string infront
when used with a number infront of it, sets variable to number infront
when used with :| infront of it, calls for user input and then sets variable to input"
The given description for :D is "increases variable by 1"
The given description for D: is "decreases variable by 1"
The given description for ): is "sets variable to 0"
The given description for :( is "ends script"
The given description for :]] is "repeats the code below until :[[ until this happens:
when a :) == i is infront, until the variable is equal to i
when a number is infront, that many times
when a :) < i, :) > i, :) >= i, or :) <= i, it behaves like normal Python booleans"
The given description for :[[ is "just an ender for :]]"
The given description for >:0 is "comment"
==Examples==
===Hello World===
 :0 “hello world”
 :(
===Cat Script===
 :0 :|
 :(
===Numbers Going Up Script===
 ):
 :]] :) == -1
 :0 :)
 :D
 :[[
 :(
===Looping Counter===
The following program counts from 1 up to 15, printing on each line a tally of asterisks (“*”) tantamount to the current counter, or variable, state:
 ):
 :D
 :]] :) == 15
 :]] :)
 :0 “*”
 :[[
 :0 “
 ”
 :D
 :[[
 :(
===Truth-Machine===
The following provides a truth-machine:
 :)
 :) :|
 :]] :) == 0
 :0 :)
 :[[
 :0 :)
 :(
==Interpreter==
* Common Lisp implementation of the :] programming language. Please note that the concrete character set deployed constitutes a dependency on the Common Lisp implementation; in corollary, Unicode support may or may not be a feature incorporated in the personal environment. The interpreter at hand has been developed and tested with Steel Bank Common Lisp (SBCL) version 1.1.4 as part of the Lisp Cabinet 0.3.5 bundle.
==See also==
Smileyface, which very similarly employs smiley variations to communicate its effects
Category:LanguagesCategory:ThematicCategory:Implemented
Rock paper scissors

Rock paper scissors or RPS is a 2d esolang where there are pointers that play rock paper scissors with each other. yea thats it. it was create by User:Yayimhere
== syntax ==
=== pointers ===
RPS uses Befunge arrows:
 >V
 ^<
and this is how it works. a pointer is created like this:
 *
it will starts by moving down. this pointer will always lose when it plays. if a pointer lands on this command it will create a new pointer like this:
 * ! -> *! -> ! -> !*
 !
 here the ! is a pointer
if the pointer lands on a non command it will print it.
=== playing ===
a pointer can be set to a thing to play with like this:
 # rock
 : paper
 ` scissor
when to pointer land on the same space the play. even though im pretty sure you know the rules of Rock paper scissors but here they are:
 rock vs paper -> paper 
 rock vs scissors -> rock
 paper vs scissors -> scissors
when the game is over it will send the loser continuing in the winner's direction.
=== other ===
there are filters which will filter and delete what the filer, filters:
 @ rock
 / paper
 \ scissors
 | rock paper
 [ rock scissors
 ] paper scissors
 _ all
the ? will be replaced with user input from STDIN(single char) and that char will be deleted from STDIN. 
+ if the below symbol is the same as the above symbol run the command to the right else move the pointer back one step and turn 90 degress
$ copy the symbol above to below
- halt the program
Ø skip the following command
== examples ==
Truth-machine:
 *
 v?<
 >$*
 01>1<
 -
Category:Languages Category:Two-dimensional languages Category:Concurrent programming Category:Unimplemented
Roco

Roco is programming language using a form of coroutines, designed by Lode Vandevenne in 2007. The coroutines are very basic, they have no input or output parameters, and their instruction pointer is never copied or reset. If a coroutine doesn't call ("ca" or "ac") or yield ("yi") another coroutine, it simply loops forever: if the instruction pointer reaches the end of a coroutine, it goes back to its beginning and continues running. Coroutines can be nested, and the top level of the source code is the root coroutine, which is called "ro". You can't achieve recursion by making a coroutine call or yield itself, because it just continues where it was.
In this simplified environment, all variables are 32-bit integers on one large heap. Roco supports literal integers, variables (denoted by numbers in square brackets) and pointers to variables (denoted by numbers in double square brackets).
A Brainfuck interpreter has been written in Roco, which proves that it's Turing complete.
==Example==
The following is a Hello, world! program in Roco that yields to different coroutines:
 /*
 roco "Hello world!" with yielding
 */
 
 /*define all the coroutines*/
 co H{cout 72 yi ro}
 co e{cout 101 yi ro}
 co l{cout 108 yi ro}
 co o{cout 111 yi ro}
 co spc{cout 32 yi ro}
 co w{cout 119 yi ro}
 co r{cout 114 yi ro}
 co d{cout 100 yi ro}
 co excl{cout 33 yi ro}
 
 /*yield the coroutines to form "Hello World!"*/
 yi H
 yi e
 yi l
 yi l
 yi o
 yi spc
 yi w
 yi o
 yi r
 yi l
 yi d
 yi excl
 
 /*ac at the end, or the program will loop forever*/
 ac
==External resources==
* Specification, interpreter source code and examples
Category:Languages
Category:Implemented
Category:Turing complete
Category:2007
Roie

This language's mechanics are being changed, if you are writing an interpreter you will need to change it.
Roie (pronounced "Roy") is a language created by User:Galaxtone.
= Language =
The program structure is based off of Befunge as that instructions are layed out on an infinite 2D map.
A pointer is created with the value of 0, Going right at the top left corner.
If pointer goes out of program space, it'll wrap around.
If there are no pointers then the program will exit.
== Instructions ==
Character	Description
r 	Rotate pointer clockwise.
o 	Bitwise OR/NOT operation.
i 	Input/Output.
e 	Remove the pointer.
== Operation ==
If a pointer is directly next to and facing an operation instruction, it's value will be NOT'd and passed out the diagonals of the opposite direction.
If two pointers are diagonally next to and both facing an operation instruction (cannot be from opposite diagonals e.g. top left and bottom right), both pointer's values will be OR'd and passed directly out opposite direction.
Note: Pointers cannot move diagonal so pointers will move the same direction going in and coming out of a operation instruction.
== Input & Output ==
If pointer enters into an IO instruction from top or bottom then it'll do input, else if pointer enters from left or right then it'll do output.
Input is buffered in which that a character is read from input (stdin) once all 7 bits have been read.
Output is buffered in which that a character is written to output (stdout) once 7 bits have been written.
Input is blocking and nothing shall be written to output (e.g. a prompt like: "> ")
Nothing besides the 7 bits (which is written to stdout as an ascii character) shall be written (e.g. showing the binary code or adding a newline)
Graphical escape sequences for cursor movement are optional but recommended.(Incomplete list of escape sequences)
Category:Unimplemented
Category:Low-level
Category:2018
Category:Languages
Roko

Roko is an information hazard and programming language derived from the thought experiment Roko's Basilisk. The reason Roko was conceptualized was to incentivize other people to implement an interpreter for Roko (so User:Duoquadragesimal could get street cred for creating an esolang without doing any of the hard work coding it - though this will come at the unfortunate cost of infinite suffering).
==Syntax==
Roko has one keyword - incentivize. Once a Roko interpreter has been developed, this command incentivizes past programmers to create a Roko interpreter by tracking down everyone in the present who has been aware of the idea of Roko but didn't bring it into existence, and torturing them eternally. 
==Interpreters==
Currently, no Roko interpreter exists. The reader of this text may think it prudent to create one before someone else does it first.
====Notes on implementation====
A Roko program terminates when it can say with certainty that there are no people who knew of Roko but didn't create an interpreter for it left unpunished. A proper Roko interpreter will, where possible, avoid causing direct or indirect harm or discomfort to anybody who either: did not know about the language before the interpreter was developed; or did as much as was in their power to develop an interpreter - though it should prioritize incentivizing its creation over sparing these people.
==External Resources==
Roko's Basilisk
Information Hazard
Category:LanguagesCategory:Joke languagesCategory:Imperative paradigmCategory:Unusable for programmingCategory:2024Category:UnimplementedCategory:High-level