nyuuzyou/wikis huggingface dataset:
Burlesque

Burlesque is a concatenative, dynamic typed, lazy programming language by User:Feuermonster, and the successor
of Stlang but less feature bloated. The name means what it means.
The main design goals of Stlang still
apply. Burlesque evolved to be a programming language used for both serious applications and golfing too. For a complete description of the language please refer to the Moonpage. 
== I/O ==
The language specification suggests to push STDIN at program start and display remaining elements on the stack in the order they can be removed
from the stack on program termination. This is - however - not a requirement but recommended.
== Example programs ==
These require STDIN.
See anarchy golf for tons of example programs.
Calculate Fibanocci numbers 1..10:
1J{.+}10!C
Analyze frequencies of letters:
"hello world"F:sp
=== Quines ===
Quines are trivial in Burlesque. It however might depend on your interpreter. 
 {qu in e.}
A more non-cheating quine is:
 ,#Q2 SH ~- ",#Q" \/ .+ sh
=== Brainfuck Interpreter ===
 ".""X"r~"-""\/^^{vvvv}c!!!-.256.%{vvvv}c!sa\/"r~"+""\/^^{vvvv}c!!!+.256.%{vvvv}c!
 sa\/"r~"[""{"r~"]""}{\/^^{vvvv}c!!!}w!"r~">""+."r~"<""-."r~"X""\/^^{vvvv}c!!!L[+]
 \/+]\/+]^^3\/.+1RAp^\/+]\/0RA1RA^^-]\/0RA\/"r~"\'\'1 128r@{vv0}m[0"\/.+pse!vvvv<-sh
128 is the amount of cells. However, this implementation does not provide the ","-Instruction.
== Computational class ==
Burlesque is turing-complete as you can translate Underload's instructions :()^ to Burlesque.
Given below is a translation table:
 : → ^^
 ( → {
 ) → }
 ^ → e!
 ! → vv
 * → .+
 a → {}\/[+
 ~ → \/
 S → ? - Burlesque has no I/O.
The translation of the following Underload program (factorial):
 (:::::::):(:((^:()~((:)*~^)a~*^!!()~^))~*()~^^)~(^a(*~^)*a~*()~^!()~^)a~**^!!^
is:
 {^^^^^^^^^^^^^^}^^{^^{{e!^^{}\/{{^^}.+\/e!}{}\/[+\/.+e!vvvv{}\/e!}}\/.+{}\/e!e!}\/{e!{}\/[+{.+\/e!}.+{}\/[+\/.+{}\/e!vv{}\/e!}{}\/[+\/.+.+e!vvvve!
Using HELP it is possible to automate this conversion process. The following directives must then be inserted:
 # \( := {
 # \) := }
 # \! := vv
 # \^ := e!
 # \: := ^^
 # \* := .+
 # a := {}\\/[+
 # \~ := \\/
== External resources ==
* Home page
* GitHub page
* Moonpage
Category:Languages
Category:2012
Category:Implemented
Category:Stack-based
Category:Turing complete
Category:Golfing language
Burro/TM2Burro.hs

:
Note: this is broken.
If it were not broken, this would be a compiler which, given the description of a n-symbol m-state Turing machine, would produce a corresponding Burro program, thus showing that Burro is Turing complete. But it's broken. So it doesn't show that.
It is basically a mechanized version of the construction described in "Implementing a Turing Machine in Burro" in the Burro.lhs file in the Burro 2.0 distribution, with some gaps cleaned up.
Both tape cells and TM state indexes are encoded as odd positive integers, starting at 1, then 3, 5, etc. The start state is considered to be state 1. Blank tape cells are considered to be 1.
The TM should be supplied as a list of pairs: (state-index, choices). The choices is a list of quadruples: (if-read-this-symbol, write-this-symbol, move-this-direction, go-to-this-state-next).
The TM state list must begin with state 1, then state 3, state 5, etc with no gaps. Similarly, each choices list must begin with if-read 1, then if-read 3, 5, etc with no gaps and no omissions (every choices list must name every possible tape symbol.)
Transitioning to any state beyond the last defined state halts the machine.
Each TM tape cell is encoded as 4 Burro data tape cells like so: (state-index, junk, tm-tape-cell-contents, junk)
module TM2Burro where
type StateID = Integer
type Choices = [(Integer, Integer, Integer, Integer)]
-- BROKEN
testFor :: [(Integer, String)] -> String -> String
testFor branches else_ = testFor' 1 branches
 where
 testFor' n [] = else_
 testFor' n ((val, code):rest) =
 if n == val
 then "--(" ++ (testFor' (n+2) rest) ++ ">/" ++ code ++ ">)<"
 else error "Mismatch, should be " ++ (show n) ++ " not " ++ (show val)
write 0 = ""
write n = "+" ++ write (n-1)
move (-1) = "<<<<"
move 1 = ">>>>"
move 0 = ""
next n = "<<" ++ (write n)
compileState :: Choices -> String
compileState choices =
 ">>" ++ (testFor (map (\(i, w, m, n) -> (i, (write w) ++ (move m) ++ (next n))) choices) "")
compileStates :: [(StateID, Choices)] -> String
compileStates states =
 testFor (map (\(index, choices) -> (index, compileState choices)) states) "!"
compileTM :: [(StateID, Choices)] -> String
compileTM states =
 -- if the current state index isn't one of the possible states, set it to 1
 (testFor (map (\(index, choices) -> (index, write index)) states) "+") ++
 -- if the current tape cell isn't one of the possible tape symbols, set it to 1
 (testFor (map (\(n, _, _, _) -> (n, write n)) (snd (head states))) "+") ++
 -- turn off the halt flag
 "!" ++
 compileStates states
Category:Proofs
Category:Implementations
Bus 581

Bus 581 is an esolang invented by User:Hakerh400 in 2023.
== Overview ==
This programming language is a derivative of the SKI combinator calculus. There are three combinators K, S, T, and the following rewriting rules:
 K a b ---> a
 S a b c ---> a c (b c)
 T a ---> b
In the last reduction, for any combinator a, if there exists some combinator b such that a b reduces to K, then T a reduces to one such b (implementation-dependent which one, but it must be done consistently). If there is no such b, then T a reduces to any combinator b (this also must be done consistently).
"Must be done consistently" means that for any fixed a, the expression T a always gives the same result.
Category:Languages
Category:Turing complete
Category:2023
ButWhy

ButWhy is an esoteric language created by User:Rehydratedmango, designed to cause programmers to repeat the language's name as many times as possible while using it.
Commands in ButWhy are represented in binary, encoded in base-64. Each base-64 character is placed on a grid, and the program starts reading characters from the top left. The / and \ characters divert program execution like mirrors. Once 4 bits of information have been read, the corresponding command is executed. The ? character will skip over the following character if the stack has a 0 on top.
An example of program flow:
 ####\
 #
 /###/
 #
 \####
The program follows the S shape, reading each character (represented by the #s).
== Commands ==
Command (binary)	Description
0000 	Push a 1 bit onto the stack, unless it is a Monday and the program doesn't feel like it.
0001 	Pop the top bit off of the stack and ethically recycle it.
0010 	Nor the top two bits on the stack.
0011 	Duplicate the top bit on the stack and provide therapy to the bits with identity crises.
0100 	Remove the bottom bit from the stack and push it on top. Print "Jenga" if the stack falls over.
0101 	If the top bit on the stack is a 1, pop it and rewind the program to the previous 0101 command, continue from there.
0110 	Rip bits off of the stack like an angry toddler until there is a 0 bit on top.
0111 	Push the program off a cliff, shattering the source code into bits.
1000 	Rudely mug the user for an input in binary, which is pushed onto the stack one bit at a time starting from the righthand side.
1001 	Pop the top 8 bits off the stack and output them as an ASCII character.
1010 	Pop the top bit off the stack and output it, unless it is the 17th bit on the stack, because they had a falling out with the program.
1011 	Tell a joke. That's... that's it.
== Interpreter ==
No
Category:2023
Category:Two-dimensional languages
Category:Unimplemented
Category:Languages
Category:Unknown computational class
Butng

== What is Butng? ==
Butng was originally created by User:Baidicoot as an extension of lambda calculus. However, it has since grown, and, with the help of User:Gollark, who did the diagrams (!), now resembles nothing like lambda calculus.
== Syntax ==
Butng is wholly, entirely, made up of data structures called 'Fields'. Each and every field is a field of another field, or a field of the program, which in itself is modeled as a field. All fields must implement all possible subfields.
Let's break down this program:
 a = 1
 a
As you may have guessed, this sets the field a to equal 1, and then returns the value of a, namely 1. But hey, isn't using the operator = kind of un-field-y? Well, in Butng, , or space, is the syntax for accessing a subfield of a field. So, in this case, we are accessing the field 1 of = of a, and = is acting as the setter method for a, setting a to 1. Wait, what, I hear you ask. How can the field = of a act as the setter method for a? This is because any, and indeed every, program written in Butng has pre-defined fields that every field contains, called the 'standard fieldset', or std, and = is just one of these, as is 1.
== Placeholder Law ==
One of the primary rules of Butng is that every field must have every possible subfield implemented. As field names can be any length of ASCII string, this is an infinite amount of subfields. How then, does Butng do this? The answer is with 'placeholder law'.
If a field is unimplemented, placeholder law dictates that the field must be inherited from it's parent. This triggers the parent's placeholder law, and this recurses up the program's genealogy, until it reaches the scope field, which implements the standard fieldset. If it isn't found there, then it is implemented in the same place it was first referenced, with a default return of the field 0.
== Scopes ==
A special field implemented by the standard fieldset is the ( field. This field, when referenced, opens a new scope. Take the following program:
 b = 3
 a = ( b + 1 )
This program sets a to b + 1, or 4. More specifically, it creates a scope object, which, when referenced, evaluates to 4. The ) field returns the last referenced field to the parent scope.
Category:Languages Category:Unknown computational class
Buttons

Buttons is a 2D esolang created by User:AnotherUser05.
==Syntax==
This esolang uses ASCII art of buttons, like this:
 [_]
 |||
And a pushed button looks like this:
 ‎‎
 [_]
A button needs to be pushed in order to work. The symbol replacing the _ is the command. Buttons are placed next to each other. 
*_ - Nothing.
*+ - Increase the accumulator.
*- - Decrease the accumulator.
*! - If the accumulator is 0, then toggle the next button.
** - Toggle the next button.
*& - Skip the next button.
*: - Get a 1 or a 0 from the user, if it's a 1, then toggle the next button.
*; - Set the accummulator to the user's input.
*. - Output the accumulator as an ASCII character.
*, - Output the accumulator.
*> - Jump to the previous <.
*{ - Jump to the next }.
*= - Set the accumulator to 0.
*x - Terminate the program.
==Examples==
===Truth Machine===
 [{] 
 [:] ||| [,] [x] [}] [+] [<] [,] [>]
===Cat Programs===
 [+]
 [:] ||| [,] [x]
 ‎
 [;] [,] [x]
 ‎
 [<] [;] [,] [>]
Category:Languages Category:Two-dimensional languages Category:Thematic
BuxRo

An esolang created by User: Areallycoolusername. It has only one command and that's "Oof...". This command is used to print whatever the user desires. When any other wording is used, BuxRo will return an error code which is an infinite loop of "oof."
== Interpreter in Python 3 Made By: User: Areallycoolusername ==
i = input("Oof?\n")
if i == 'Oof...':
	print("Oof!\n")
	j = input()
	
if i != 'Oof...':
	i = 1
while i == 1:
	print("oof.")
	
	
if j == 'Oof...':
	i = 1
while i == 1:
	print("oof.")
else:
	print(j)
== Golfed interpreter by User:Quito0567 ==
i = input("Oof?\n") != 'Oof...' or (j := input()) == 'Oof...'
while i: print("oof.")
if i: print(j)
== Hello World Program ==
Oof...
Hello, world!
Output:
Oof?
Oof!
Hello, world!
Category:Languages
Category:Joke languages
Category:Unusable for programming
Category:Thematic
Category:Total
Category:Implemented
BuzzFish

BuzzFish is a esolang by User:Yayimhere to demonstrate the problem with Looping counters.
== the syntax ==
BuzzFish has 3 commands:
 *: print *
 n: print a newline
 |x}: loops x forever 
 |x}=: move the string |x}= to after the = and then a % which will not let it duplicate longer
 % delete itself
== the problem ==
the problem is either BuzzFish is more power full than a Linear bounded automaton in some aspects or a Looping counter can be ran by something with a lower computational class
== a looping counter ==
 ||*}=n}
Category:Languages
By+

by+ is an esolang created by raff4814 on Discord that uses emojis for commands. It has a single accumulator, called the "zap variable", which is a float by default, as well as one slot for a savestate.
== Commands ==
* denotes an optional argument.
Command 	Explanation
⚡<num> 	Increments the zap variable by <num>. Only supports positive/negative single-digit integers.
📍<*base> 	Rounds the zap variable down to the nearest integer. If <base> is given, then it also converts from that base.
👋 	Stops the program.
⏏️ 	Outputs the zap variable as a number.
🖨️ 	Outputs the zap variable as an ASCII character. If a non-decimal digit is in the zap variable, it will raise an error.
0️⃣ 	Sets the zap variable to 0.
🎱<min>,<max> 	Sets the zap variable to a random integer between <min> and <max>. Supports multi-digit integers.
✖️<num> 	Multiplies the zap variable by <num>. Only supports positive/negative single-digit integers.
➗<num> 	Divides the zap variable by <num>. Only supports positive/negative single-digit integers.
🔝<num> 	Sets the zap variable to its exponent by <num>. Only supports positive/negative single-digit integers.
⛓️<num> 	Concatenates <num> at the end of the zap variable. Only supports positive/negative single-digit integers. Can concatenate numbers after the decimal point e.g. concatenating 6.0 with 3 will result in 6.03.
↔️<base> 	Converts the zap variable to the base <base>. Supports integers from 2 to 62. The list of base digits is as follows: 0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ.
💾 	Makes a savestate of the current value of the zap variable and stores it in the savestate slot.
📲 	Loads the value of the savestate slot into the zap variable.
〰️ 	Does nothing.
== Example programs ==
nothing here for now
== Interpreters ==
raff4814 on Discord has made a by+ interpreter in Robot Is Chill macroscript, which is accessible from the by+ macro.
== Computational class ==
by+'s computational class is currently unknown.
Category:LanguagesCategory:ImplementedCategory:2024Category:Unknown computational class
Bynary

==Registers and operators==
 a, b, c, d, e, f, g, h	-registers, 0 by default
 x			-any register
 y			-any register or 1 or 0
 z			-1 or 0
 n			-any positive integer
 v:x,y			-sets register x to y
 i:x			-invert register x
 d:x,y			-nand registers x y
 p:z			-prints the registers in binary abcdefgh, 0 for decimal and 1 for character
 r:n			-loops next operation for n times
==Example==
 v:a,1
 v:d,1
 p:1
 v:b,a
 v:h,i:d:a,b
 p:1
should output
 Hi
== Implementation ==
An implementation in node js, written by User:Conor O'Brien, can be found here.
Category:Languages
Category:2013
Category:Implemented
BytFuck

:Not to be confused with Bitfuck
BytFuck is a brainfuck derivative which means it's inspired by the brainfuck esoteric language.
== The "thing" that makes this unique ==
This language is exactly brainfuck but in original brainfuck you had a pointer pointing to a cell in a tape.
Now there are 2 pointers, 1 pointer pointing to a cell, but the other pointer is pointing to a bit in that cell.
=== I didn't understand ===
I know that you didn't.
Let's say this is normal brainfuck with the pointer, the cells, the tape, well in this brainfuck there are two pointers.
The first pointer is pointing to a cell, like normal brainfuck.
One cell is made by 8 bits (1 byte), 8 bits looks something like this: 0 0 0 0 0 0 0 0
Now there is one pointer pointing to a bit, which bit points? Is pointing to a bit in a byte, the same byte pointed by the other pointer.
And when you move the other pointer, this pointer also moves to the other byte.
== New instructions ==
Instruction	Description
≥ 	Move bit pointer to right
≤ 	Move bit pointer to left
* 	Flip pointer bit
! 	Make bit pointer to point the first bit in the cell
( ... ) 	Executes the code inside of the parenthesis if the pointed bit is 1
Category:Languages
Category:Brainfuck_derivatives
Category:Unimplemented
Category:2020
Category:Turing complete
Category:Turing tarpits
Byte

Byte is a esoteric subset by User:Yayimhere. its of Python 3. the name has nothing to do with the subset
== commands ==
allowed commands
* := the walrus operator
* = equal to
* str(x) turn x into a string
* if x == y: if x is not equal to y
* if x > y: if x more than y
* | OR
* + add together two object
* x.pop() pop element from x
* str(x) turn x into a string
* f = lambda x : a define lambda function f with only a single input(only single input lambda function are allowed)
* x[i] index i of x
* eval(x) evaluate x as code
* for i in len(x): for loop of length x
* print(x) print x
* input() take input
* .append(x) append x to list
* len(x) length of x
* break break out of loop
* while true: infinite loop
== symbols ==
these are the symbol allowed in code(for data):
* [] empty list
* "\n" newline
== types ==
only types supported:
* list
* string
* nonetype
* ints(for index)
== explicitly unallowed things ==
* the null program
* 1-9 bytes programs
== computational class ==
Byte is turing complete since it can simulate a Bitwise Cyclic Tag:
 datastring=[]
 #memory
 while true:
 #code
 if (len(datastring) == 0):
 break
and this is the translation(of course must be ordered):
 memory:
 0
 |
 V
 datastring.append("\n")
 1
 |
 V
 datastring.append(str([]))
 commands:
 0
 |
 V
 datastring.pop(0)
 10
 |
 V
 if (datastring[0] == str([])):
 datastring.append("\n")
 11
 |
 V
 if (datastring[0] == str([])):
 datastring.append(str([]))
this is the collatz sequence program:
 datastring=[]
 datastring.append(str([]))
 datastring.append("\n")
 datastring.append("\n")
 while true:
 if (datastring[0] == str([])):
 datastring.append("\n")
 if (datastring[0] == str([])):
 datastring.append(str([]))
 if (datastring[0] == str([])):
 datastring.append("\n")
 if (datastring[0] == str([])):
 datastring.append("\n")
 if (datastring[0] == str([])):
 datastring.append("\n")
 if (datastring[0] == str([])):
 datastring.append(str([]))
 if (datastring[0] == str([])):
 datastring.append(str([]))
 datastring.pop(0)
 if (datastring[0] == str([])):
 datastring.append(str([]))
 if (datastring[0] == str([])):
 datastring.append("\n")
 if (datastring[0] == str([])):
 datastring.append("\n")
 if (datastring[0] == str([])):
 datastring.append(str([]))
 if (datastring[0] == str([])):
 datastring.append("\n")
 if (datastring[0] == str([])):
 datastring.append("\n")
 if (datastring[0] == str([])):
 datastring.append(str([]))
 if (datastring[0] == str([])):
 datastring.append("\n")
 if (datastring[0] == str([])):
 datastring.append("\n")
 if (datastring[0] == str([])):
 datastring.append(str([]))
 if (datastring[0] == str([])):
 datastring.append("\n")
 if (datastring[0] == str([])):
 datastring.append("\n")
 datastring.pop(0)
 datastring.pop(0)
 datastring.pop(0)
 datastring.pop(0)datastring.pop(0)
 if (len(datastring) == 0):
 break
the: 
 datastring.append(str([]))
 datastring.append("\n")
 datastring.append("\n")
is the number of times 100 is added to the datastring
Category:Esoteric subset Category:Turing complete Category:Languages
ByteMover

ByteMover is an OISC CPU design based on the ByteByteJump concept.
An instruction consists of 3 consecutive fields A, B and C.
A and B occupy 24 bits (3 bytes) each. C occupies 16 bits (2 bytes) for a total of 64 bits (8 bytes) per instruction
A, B and C are stored in memory as little-endian values.
The operation performed is:
# Copy one byte from address A to address B.
# Jump to instruction C (at address C * 8).
The whole instruction is read as a 64-bit word from memory before it is executed. This means that no program counter is needed.
24-bit source and destination addresses means 16 MiB of addressable RAM. The 16-bit jump index can address 65536 instructions, each taking up 8 bytes. This means that only the lowest 512 KiB can be used for executing code, unless some sort of bank switching scheme is devised.
BytePushCore

=== What is the goal? ===
The initial goal is to build a standard collection of useful opcode tables for the BytePusher virtual machine. A sort of "BytePusher ALU".
This will not be part of the VM specification itself, but an add-on which a VM may or may not support. It will be in the form of a binary file. A VM may choose to generate the data algorithmically instead. If it's not directly supported by the VM it can still be indirectly supported by preprocessing in an external program, or by runtime generation by the program itself.
=== Preceding brainstorming ===
This page was becoming a big mess, so I moved the old contents to the talk page --Javamannen 00:09, 24 October 2010 (UTC)
Below is a list of some of the stuff which has been discussed (see talk page) --Javamannen 17:37, 25 October 2010 (UTC)
* Runtime generation of the tables by the VM or by the BytePusher program itself
* Extending this into a general mechanism to have a program specify an external file which it depends on to run.
* File extensions and stuff. 
* Size of the table set. The consensus was: we decide this later.
* Ordering of the tables. The consensus was: we decide this later.
* Adding other stuff like a set of standard system routines. Probably this will have to wait until we have the "BytePusher ALU".
* A standard way to extend VM capabilities.
=== The opcode list ===
The first step is to build a set of potentially useful tables. Better too many than too few. So let's not worry about redundancy or ordering now. Later we'll select which ones to include, and in what order.
There are 2 basic types of table.
* Small ones, a.k.a pages. 256 bytes each.
* Big ones, a.k.a banks. 65536 (256*256) bytes each.
Anyone is welcome to contribute. What should be provided:
* A link to a raw binary file with the table data. Suggested file extensions: ".BytePusherPage" for the small ones, ".BytePusherBank" for the big ones.
* A reasonably clear description of the function performed by the table.
* Optionally, a link to a table generator program. Any programming language goes.
* Optionally, your name / handle.
====Small tables====
Raw data (*.BytePusherPage)	Description 	Generator file	Made by
Identity 	The identity function f(x) = x	 	Javamannen
====Big tables====
Raw data (*.BytePusherBank)	Description	Generator file	Made by
BytePusher II

===== Intro =====
BytePusher II is more powerful than the the original BytePusher but not much more complex.
===== Memory =====
Memory is an array of 32-bit words. BytePusher II uses word addressing, not byte addressing.
===== CPU =====
BytePusher II uses the NybbleScrambler CPU.
===== Endianness =====
Since all operations are performed on whole words the VM is independent on the byte order of the host computer.
Memory image files are stored in the big-endian format.
For a little-endian host the byte order needs to be reversed only when loading or saving a memory image file.
More to come...
Category:Unimplemented
Category:Languages