nyuuzyou/wikis huggingface dataset:
Control Character

Control Character is a stack-based esoteric language by enilKoder that is inspired by Whitespace, which was created by Edwin Brady and Chris Morris.
==Syntax==
Usually, characters that would make the Java function isISOControl() == false are ignored.
This table explains what each control character does:
Name (ABR) 	U+#### 	What it does 	Example*
Null (NUL) 	0000 	Null value, of course! This is the default value for nops and functions that don't return other values 	
Start of Heading (SOH) 	0001 	Open expression grouping 	
Start of Text (STX) 	0002 	Begin mini-quine; the interpreter will start recording whatever code it will be evaluating 	
End of Text (ETX) 	0003 	End mini-quine; the interpreter will push, as a text string, the code that it recorded since STX 	
End of Transmission (EOT) 	0004 	Terminate the program; the interpreter may return the stack 	
Enquiry (ENQ) 	0005 	Ask the user for a Boolean input, then push it onto the stack 	
Acknowlege (ACK) 	0006 	True Boolean 	
Bell (BEL) 	0007 	Print the following value to the output log 	
Backspace (BS) 	0008 	Pop and return the first value in the stack 	
Horizontal Tabulation (HT) 	0009 	Push the following value onto the stack 	
Line Feed (LF) 	000A 	Separate lines of code 	
Vertical Tabulation (VT) 	000B 	Jump to the line specified by the following value (nop if invalid value, e.g. negative, decimal, >= number of lines, not a number)	
Form Feed (FF) 	000C 	Return true (ACK) if the first two values in the stack are equivelent, else false (NAK) 	
Carriage Return (CR) 	000D 	 	
Shift Out (SO) 	000E 	 	
Type of first value of stack	Do 	Then 	
Number 	Get second value as a number 	Push their difference (first minus second) onto the stack 	
Text string 	Get second value as a text string 	Push the result of removing all instances of the second string from the first string onto the stack 	
Boolean 	True: Push null 	False: Push the second value 	
Null 	Do the same process with the next two values in the stack	If the bottom is reached, push null 	
*Abbreviations are used because some of the control characters get replaced with the replacement character (U+FFFD) and the characters in the examples can very easily be determined.
Category:Languages Category:Stack-based
Convalescent

Convalescent is a two-instruction esolang utilizing prime factors of integers. It was designed by User:Keymaker in 2024.
==Program and execution==
The program consists of two types of instructions ; and +. Instructions are executed deterministically from the first to the last, and after executing the last the program pointer moves back to the first. The memory is an unordered list of non-negative integers. Initially the list has one instance of the the smallest prime, 2. There is also the accumulator, a non-negative integer, initially 0. The program halts if the memory becomes empty (which can only happen after executing the + instruction), or if the + instruction is executed when the accumulator is 0 or 1.
The instructions are:
* ; increases the accumulator by one.
* + causes the following effect (although an interpreter may arrive at the same end result differently):
:1. Get the prime factorization of the accumulator's value. If the accumulator is 0 or 1 the program halts instead.
:2. For every different value in the prime factorization, see if that type exists in the memory. If at least one instance is found in the memory, the instruction is considered successful.
:3. If even one instance was found, this (step 3) is executed, otherwise not. For each different type of value in the prime factorization, it is seen if there are instances of that type in the memory. If there are no existing instances, then all the instances in the prime factorization are added to the memory. In case one or more instances exist, one instance is removed from the memory, and n-1 (where n is the number of instances in the prime factorization) are added to the memory.
:4. If instruction was deemed successful in step 2 (even one instance of the prime factors was found to exist in the memory), the accumulator is set to 1, otherwise it is set to 0.
Because the programs can become immensely large and unstorable, there is an alternative format that in addition to understanding ; and + normally treats integers (positive, non-zero) written inside parentheses as that number of ; instructions.
==Translation example==
Here is a simple Minsky machine program:
 1 inc A 2
 2 inc A 3
 3 inc B 4
 4 inc B 5
 5 dec A 4 6
 6 halt
Run through the translator, this is the Convalescent translation in the alternative format:
 (4)+(2277)+;;+
 (697)+(205378)+(1926)+(1681)+(113692)+;;+
 (1927)+(205378)+(2910)+(1681)+(171748)+;;+
 (2911)+(2196)+(2172)+(1681)+(28248)+;;+
 (2173)+(2196)+(1270)+(1681)+(16522)+;;+
 (1271)+(58)+(2172)+(1681)+(1516)+;;+
 (37)+(66)+;;+(4489)+;+
==Computational class==
The language is Turing-complete, which is shown via Minsky Machine translation. See external resources.
==External resources==
* Convalescent information (detailed explanations of the language and the MM translation, translator program, interpreter in Python)
Category:2024
Category:Low-level
Category:Languages
Category:Turing complete
Category:Turing tarpits
Category:Implemented
Category:No IO
Convert

Category:Self-modifyingCategory:Unimplemented
-> is an esolang by the user AdjectiveNounNumber (me!). It was created in Jan, 8, 1:31 ET. Every variable, function, and/or value can be converted, or redirected to another value using a convert arrow (->). All values start undefined except the components. May or may not be turing complete.
== Componets ==
 Component Summarys.
Symbol	Syntax
-> 	Converts / Redirects the value to the left to the value to the right.
$input	Displays the input.
?input	Converts the input into the user input.
[ ] 	Does not allow any values to be proccessed or converted inside.
( ) 	Stops conversion arrows.
===-> (Conversion Arrow)===
The conversion arrow is one of the most crucial parts of this programming language. This converts or redirects the value to the left to the value to the right. The arrow will search for values on the left and right and keep searching until it hits blockers or the end of its line. The value on the left and right also ignore spaces and deactivators. The conversion arrow is formatted as name -> redirect or (name -> redirect). The conversion arrow does not convert anything in its own line, but it can convert other conversion lines.
===[ ] (Deactivators)===
The deactivators do not allow any values to be proccessed or converted inside. The deactivators are formatted as [ input ].
===( ) (Blockers)===
The blockers stop conversion values from expanding too much. It can also be used to stop converters from converting the value inside. The blockers are formatted as ( input ).
===? (Inputter)===
The inputter gets user input and converts the value inside into the user input. The inputter searches to the value right of them until it reaches blockers or the end of the line. Ignores spaces and deactivaters.
===$ (Outputter)
The outputter displays the characters. It searches for characters until it hits blockers or the end of its line. Ignores deactivators but not spaces.
==Examples==
===Truth Machine ===
 ?( [input] )
 input -> $inputinput
 $00 -> $0
 input
===cat=== 
 ?input
 $input
===incrementing by 4 thing===
 ?input
 x -> 99
 (9ic -> ic0)(8ic -> 9)(7ic -> 8)(6ic -> 7)(5ic -> 6)(4ic -> 5)(3in -> 4)(2in -> 3)(1in -> 2)(0in -> 1)
 $inputicicicic
==Interpreter==
This language does not have an interpreter yet, meaning the results are made by hand. If any of this code is wrong, please tell me :)
Cool

Cool (Character Object Oriented Language) is esoteric programming language made by User:IQBigBang on 3rd January 2017. 
Almost every character in this language represents some action.
== String mode ==
Used for entering text to code. Always in quotation marks.
== Expression mode ==
Used for entering variable names. Always in tildes.
== Command list ==
Command 	Meaning
o"name"(..) 	Makes new object with "name". Its definition is in brackets.
v~name~"value" 	Makes new variable with name and value or changes variable value. Value is optional.
f~name~[arguments](..)	Makes new function with name and arguments. Its definition is in brackets. Arguments are optional.
i~name~ 	Saves input line to variable.
a[arguments](..) 	Arithmetic function.
Category:Languages
Category:2017
Cool And Rad

Cool And Rad is an esolang created by PoptartPlungerBoi in 2024.
== History ==
The esolang was originally named A Totally Sick And Twistingly Busting Cool And Rad Esoteric Programming Language With The Uncommonly Long Title In Your Entire Freaking Life You Have Ever Seen During At The Time When You Need To Make A Program In It Right Now Yes You Yes You. It was shortened to ATSATBCAREPLWTULTIYEFLYHESDATTWYNTMAPIIRNYYYY. It was decided that title would be too long despite its 4th wall breaking part of the title.
Category:2024 Category:Languages
Cool Cell

Cool Cell(CoCe) is cell-based language by User:ChuckEsoteric08. It was created because author wanted to create version of Turing-machine which compiles to Quests, but later it become BF with limited memory which can implement BF easily
==Descrtiption==
Number of cells in implementation should be any number between 29999 and 30001(meaning there should be always only 30000 cells). Every cell is 8-bit and it will set to 0 if after incrementing value will be more than 255 and to 255 if number will be less than zero. Commands always seperated with ;. [X] and [Y] should be any number. In the start of the program you need to input number which will be used in p[X] command. Comment start with # and it needs to be after a[X] command. Counting of cell starts from 1( first cell number is 1, second cell numember is 2 and so on).
Command 	Meaning
s[X] 	point to cell [X]
r[X] 	Dereference cell [X] and point to N-th cell, where N is value of that cell
i[X] 	increment pointed cell [X] times
d[X] 	same as previous command, but decrement
p[X] 	put every digit in inputed number in tape starting from cell [X]
a[X] 	declare label [X]
g[X] 	goto label [X]
z[X] 	if pointed cell is zero goto label [X]
o[X] 	same as previous command, but if not zero
f[X]t[Y]	if pointed cell is [X](It can be any digit from 0 to 9), then goto [Y]
t[X] 	output number [X]
h[X] 	print [X] and halt
==Examples==
===Hello World===
 tHello, World!;
===Truth Machine===
 p1;s1;oloop;h0;aloop;#a;t1;gloop;
If first digit in input is not 1 or 0 then it is 1
 p1;s1;f1tloop;z0;hError!;a0;#a;h0;aloop;#a;t1;gloop;
It will print "Error!" if first digit in input is not 1 or 0
===Cell overflow===
 i288;
Set cell to zero
 d123;
Set cell to 255
==External resources==
*Scratch interpreter
==Computational class==
It is Bounded-storage machine, because it has limited memory
Category:Languages Category:Implemented Category:Cell-based
Coolbeans

Coolbeans is an esoteric programming language created by User:Tommyaweosme and User:Unname4798
== Stuff ==
 - path
 | path
 \ turn
 / turn
 + intersection (they keep going the same way)
 > signal going right
 < signal going left
 ^ signal going up
 v signal going down
Signals can hold values.
When a signal runs into a hashtag sign, it replaces its value with the number until the next hashtag.
 v
 |
 |
 #
 1
 2
 #
 \---$
This collects 12 and outputs it.
 $ output
 % input
To duplicate, make a split in the path
 v
 |
 |
 -----
Both signals have the same value.
 @ trash
Any signal running into trash gets trashed.
 & stringify
Stringifying a pointer means that when it runs into *, it treats it like a hashtag but for strings.
Two spaces in a row means newline, by the way.
 Y add
A Y adds values that go on sides of it and releases it on a new track.
 L conditional turn
Turns from up to right if the value is 0. Turns right to up if value is non 0 or string. Otherwise, it deletes.
=== v1.1 ===
 X - multiplies two numbers and deletes if there is a string.
 R - random turn.
 T - typeof turn - turns the signal right if it is a number; turns the signal left if it is a string.
 Y - It now concatenates two strings together. It also concatenates a number and a string.
 L - It now turns the string right if it is empty.
 F - Takes the trailing digit.
 M - Outputs fovever.
 U - Diode, deletes signals moving rightwards and upwards.
 D - Diode, deletes signals moving leftwards and downwards.
== Examples ==
=== Original ===
==== Hello World ====
 >&#Hello, world!#$
==== A+B problem ====
 v v
 %Y%
 $
==== Truth Machine ====
 %
 /--\
 L--+-$
 /\|
 #L/
 1
 #/\
 \$|
 \/
==== Multiply by 2 ====
 %
 |
 /---\
 | |
 \-Y-/
 |
 $
==== 7 bottles of tommyaweosme ====
Program is too large to view.
==== XKCD Random Number ====
 >#4#$
=== v1.1 ===
==== Actual random number generator (0-2) ====
 $ $ $
 # # #
 0 1 2
 # # #
 | | |
 \-R-/
 D
 ^
==== tommyaweosme function ====
 v
 |
 #
 2
 # /-M56#$
 | |
 %-----X-F-L
 |
 \-#87#$
==== BBTOS ====
 >&#BRING BACK THE OLD SANDBOX#$
== Computational class ==
Coolbeans is not aweosme-complete.
That's because it doesn't have third quality.
==See also==
* Wireless Coolbeans
Category:Languages Category:Two-dimensional languages Category:Concurrent programming
Coolfudge

Coolfudge is a Befunge-93 derivative made by User:Tommyaweosme.
== Commands ==
 + add
 - subtract
 * multiply
 / divide
 % mod
 ! not
 ` greater than
 > right
 ^ up
 < left
 v down
 ? random direction
 _ horizontal if
 | vertical if
 / mirror
 \ mirror
 ) swap
 . pop integer
 , pop ascii
 ' pop tanstore
 g get
 p put
 # bridge
 & push integer
 ~ push ascii
 ( push tanstore (same effect on string mode)
 " string mode
 $ pop and delete
 : duplicate top
 @ ends program
 0-9 pushes integer
 * integer multi (like *87 would push 87)
 s starting place, starts off going right
 i increment top
 d decrement top
 q square top (no 256 behaviour like in Deadfish)
 r pushes the value in position n (where n is the top)
 ; repeats previous command until stack is empty, then continues
 [ goes to previous stack
 ] goes to next stack
Uppercase letters are warps like in Asciidots. Like this:
 s A
 A v
 *
 1
 2
Would push 12.
*? pushes a random number between 0 and the top of stack. If nothing is in stack, then ten is used.
== Hello world ==
 s"Hello, world!"~;
== Cat ==
 s,~v
 ^ <
== Truth machine ==
 s,v
 v&1_@
 > ^
Category:Languages Category:Two-dimensional languages
CopyPasta Language

CopyPasta Language is an esoteric programming language created by User:Rerednaw in 2018. This programming language refers to the CopyPasta meme. The purpose of this programming language is to facilitate the practice of CopyPasta.
== Commands ==
There's multiple versions of CopyPasta Language.
=== Ctrl+C version ===
Copy : Copy the text of the following line to the clipboard
CopyFile : Copy the text of the file cited in the following line to the clipboard or in the case where the next line is TheFuckingCode copys the code to the clipboard
Duplicate : Duplicate the text in the clipboard as many times as the following line specifies
Pasta! : Display the clipboard and stop the program
Copying doesn't reset the clipboard.
=== Ctrl+V version ===
All of the commands from the Ctrl+C version works also on this version.
CoolStoryBro : Takes two numbers of the following line separated by a space. Deletes the characters between the two numbers.
Creepy : Takes three numbers of the following line separated by a space. Adds to the ASCII of a character the value of the third number, then calcules this result modulo 256, and retransforms it as an ASCII character. Does that for every character in the range of the first two numbers.
IfAndOnlyIfAndOnlyIfAndOnlyIf : Takes two numbers of the following line separated by a space. If the two characters exist and if the two characters selected are equal, go to the next command, or else ignore the next command.
BUTI'MNOTDONEYET : Go to the line specified in the next line.
==== Notes ====
For all of these commands, the first character or the first line is represented by the number 1.
Ranges are always inclusive.
== Examples ==
=== Hello, World! ===
Copy
Hello, World!
Pasta!
=== Display 1000 times a sentence ===
Copy
Hi !
Duplicate
999
Pasta!
=== View a text file ===
CopyFile
loremipsum.txt
Pasta!
=== Cheating Quine ===
CopyFile
TheFuckingCode
Pasta!
=== Mini Fibonacci sequence ===
Copy
---- 0 1 1 0 0 0 0 0
IfAndOnlyIfAndOnlyIfAndOnlyIf
1 5
BUTI'MNOTDONEYET
29
IfAndOnlyIfAndOnlyIfAndOnlyIf
10 12
BUTI'MNOTDONEYET
15
Creepy
12 12 1
BUTI'MNOTDONEYET
7
IfAndOnlyIfAndOnlyIfAndOnlyIf
6 8
BUTI'MNOTDONEYET
25
Creepy
12 12 1
Creepy
8 8 255
BUTI'MNOTDONEYET
15
CoolStoryBro
1 2
BUTI'MNOTDONEYET
3
CoolStoryBro
1 7
CoolStoryBro
4 9
Pasta!
Prints the next two numbers in the sequence (2 and 3). Some variables must be changed to print the next numbers.
== Interpreter ==
Ruby interpreter by User:Conor O'Brien (Ctrl+C version)
== Other information ==
Files containing CopyPasta language code must end with .copypasta
Category:2018Category:ImplementedCategory:LanguagesCategory:ThematicCategory:Turing complete
CopyPasta Language/implementation.rb

An implementation of CopyPasta Language written in Ruby by User:Conor O'Brien.
== Implementation (copypasta.rb) ==
 def fatal_error(error, code=1)
 STDERR.puts "CopyPasta Language: #{error}"
 exit! code
 end
 
 def copy_pasta(program, split_semi_colons=false)
 lines = split_semi_colons ? program.split(";") : program.lines
 clipboard = ""
 until lines.empty?
 line = lines.shift
 case line.chomp
 when "Copy"
 arg = lines.shift
 fatal_error "No lines to Copy" if arg.nil?
 clipboard = arg
 when "CopyFile"
 arg = lines.shift
 fatal_error "No file name to CopyFile" if arg.nil?
 clipboard = if arg.chomp == "TheFuckingCode"
 program
 else
 fatal_error "No such file `#{arg}`" unless File.exists? arg
 File.read arg
 end
 when "Duplicate"
 arg = lines.shift
 fatal_error "Invalid number to Duplicate by: #{arg}" unless /^\d+\s*$/ === arg
 clipboard = clipboard * (1 + arg.to_i)
 when "Pasta!"
 return clipboard
 else
 fatal_error "Invalid instruction: #{line}"
 end
 end
 return ""
 end
 
 program = ARGV[0]
 split_semi_colons = false
 
 if program == "-e" || program.downcase == "/e"
 program = ARGV[1]
 split_semi_colons = true
 else
 fatal_error "Files must have the .copypasta extension" unless program.end_with? ".copypasta"
 begin
 program = File.read program
 rescue Errno::ENOENT
 fatal_error "No such file #{program}"
 end
 end
 
 print copy_pasta program, split_semi_colons
Category:Implementations
Copyright makes no sense

In this article we prove that copyright does not make any sense. Not only that we prove it, but we also verify the proof using Lean theorem prover. The proof is 100% correct!
=== Definitions ===
A book is a finite list of symbols (a symbol is a natural number, for simplicity). There exists a set of all copyrighted books. Also, there exists a set of all free books (in this context, by "free" we mean "public domain").
=== Axioms ===
All lawyers that I asked told me there are three axioms:
# At least one book is copyrighted (choose any book you can't download for free from the internet).
# At least one book is free (this article, for example).
# If you have some book and there is a reliable way that you can reconstruct a copyrighted book from it, then that book is copyrighted too.
=== Theorem ===
If those axioms are consistent, zero is equal to one.
=== Proof ===
 -- Lean: v3.42.0
 -- Mathlib: b6d246a6
 
 import tactic
 
 -- A book is a sequence of symbols
 def book : Type := list ℕ
 
 -- There is a set of all copyrighted books
 constant copyrighted : set book
 
 -- And the set of all free books (public domain)
 def free : set book := set.univ \ copyrighted
 
 -- At least one book is copyrighted
 axiom exi_cop : ∃ (b : book), b ∈ copyrighted
 
 -- At least one book is free
 axiom exi_free : ∃ (b : book), b ∈ free
 
 -- If you can reconstruct a copyrighted book from some other book,
 -- then that book is copyrighted too 
 axiom copy_tran : ∀ (b₁ b₂ : book), (∃ (f : book → book), f b₁ = b₂) →
 b₂ ∈ copyrighted → b₁ ∈ copyrighted
 
 -- Copyright makes no sense! (CONFIRMED)
 lemma copyright_makes_no_sense : 0 = 1 :=
 begin
 obtain ⟨b₁, h₁⟩ := exi_cop,
 obtain ⟨b₂, h₂⟩ := exi_free,
 have h₃ : b₂ ∉ copyrighted,
 { simp [free] at h₂, exact h₂ },
 have h₄ : b₂ ∈ copyrighted,
 { exact copy_tran b₂ b₁ ⟨λ _, b₁, rfl⟩ h₁ },
 contradiction,
 end
=== See Also ===
* wikipedia:illegal prime
Category:2022
Category:Proofs
Cork

Cork is a programming language written by User:Imaginer1 drawing inspiration from Brainfuck and the Wang B-machine.
Example programs include the adder ,>,<->>+<<!4>->+<!12>. and the multiplier ,>,<->->+>+<<!6>>-<<+>>!16<<<!4>>.
==Characters==
Character	Command
> 	Move pointer right
< 	Move pointer left
+ 	Increment tape
- 	Decrement tape
![n] 	If the current cell is nonzero, jump to the nth instruction
. 	Output the current cell as a number
a 	Output the current cell as an ASCII character
, 	Prompt the user for numerical input and set tape under pointer to this value.
i 	Prompt the user for an ASCII character and set tape under pointer to this value.
Commands are numbered 0, 1, 2... etc. For example, the program
 ,!0>+<
has its commands numbered as , being the zeroth command, !0 being the first command, > being the second command, and so on. The !0 indicates a jump to the zeroth command, the initial one in the program. 
Furthermore, the final ! in the program
 ,>,<->>+<<!4>->+<!12>
does not indicate a jump to command 1, but a jump to command 12.
==External resources==
*Christian Manahl's original Python interpreter
Category:Languages
Category:Brainfuck_derivatives
Category:Cell-based
Category:Turing complete
Category:Turing tarpits
Category:Implemented
Category:Low-level
Category:2014
Cornflower (PCD)

Cornflower machine is an esoteric P-code format (EISC) invented by Jan "Manna5" Mleczko in December 2021. It has memory consisting of 256 registers, each one byte long. Every instruction consists of exatcty three bytes, instructions are taken from a binary file (usually width PCD filename extension) and executed one by one. First byte of instruction is the operation code: there are 8 different operations. What operation is performed depends of the 3 least significant bits of that byte. Operation table is shown below:
 Operation table
Code	Mnemonic	Description
000 	MOV 	Move single data byte from one register to another.
001 	ADD 	Unsigned addition in memory.
010 	SUB 	Unsigned subtraction in memory.
011 	CMP 	Compare two values in memory, skip next instruction if not equal.
100 	JMP 	Jump to the instruction number ... in program file.
101 	DAT 	Initialize specified register with an immediate value.
110 	BUS 	Communicate using the bus.
111 	NOP 	Do nothing.
Last two instruction bytes are operation parameters. In instructions MOV, ADD and SUB first parameter byte (second instruction byte) is the destination register, and second parameter byte is the source register. Instructions CMP and DAT also use the same parameter format. In the BUS instruction, first parameter is port number and second parameter is source/destination register (depending on the port is input or output). JMP instruction has a single 16 bit little-endian parameter. In NOP instructions parameter bytes must occur, but parameter values are ignored. I have implemented an assembler and an emulator linked below. Sorry for my English.
Assembler: https://rextester.com/VXDW49540
Emulator: https://rextester.com/CTT84813
Category:Implemented
Category:Languages
Category:2021
Category:Low-level