nyuuzyou/wikis huggingface dataset:
Backway

backway is a esolang thats just made to f*ck with the user. a lot. made by User:yayimhere
== overview ==
all simple information like syntax is listed here
=== syntax ===
the simplest syntax of backway
 syntax
symbol	how to 	description
↸ 	A↸B 	take A a flip its binary, then add B to it then flip this new numbers octal then convert to unicode using its hexadecimal then convert this unicode back to its octal numbers and treat that as base 64 then convert it back to base 10. gives error if it can't convert to unicode
⥺ 	A⥺B(C) 	if A has more than 2 factors then it take B subtracts C from B adds A flips the octal adds A with its last digit incremented by C and then flips it octal back around
⊯ 	A⊯B(C<-B) 	A and B must be strings. runs function C if A can(after each value of ascii has been flipped in octal then bit swapped in binary) can be shuffled into B or B after doing the same procedure as on A. then runs C using B(if multi input uses bit flipped copies of B). also what inside the brackets will just be the functions spesified the get in here is just to show how it works. so technically it's A⊯B(C)
<- 	A<-(B, C,...)	A is a function(described later) then it uses the input B, C and so on with commas separating inputs. all the inputs have had it's two front binary the front bit swapped with the last and flipped and then swapped with the second to last digit
⍻ 	A⍻B⍻ 	replace L and R with W the string A then take its total sum of ascii(A# and B#) and replace L and R with ⎋ in B then subtract the last 3 bits of B# from A#(binary) then add the other bits of B#
⎇ 	A⎇(B-<CπB<-D)	if A(a string) replace L and R with (whitespace) includes more whitespaces than A's it chooses the first option(C) else its the second option(D)
π 	AπB 	used in conditional branches like ⎇. is or so A or B. the number of or's is based on the number of branches a operations has. if there is no ors and only one option its(sometimes) just a simple if-then statement
∞ 	A∞B 	and. works like π but is two things in 1
ℵ[]-∑ 	ℵ[...]-∑... 	runs what's inside the []'s while whats infront of the ∑ as long as its not true. runs something that is true once and only once
⏚ 	⏚ 	user input(number or char)
♅ 	♅(A) 	prints A
this below is for the if's of a loop:
 returns bool commands
symbol	how to 	description
℥ 	A℥B 	returns true if the bits can be swapped and flipped(every bit is flipped at each flip no 
individual flips) around from A to B
⋥ 	A⋥(B, C)	returns false if A can be swapped and flipped(like in ℥) around and put into two pieces with one piece being B and another C
⌧ 	⌧ 	always returns false
⎈ 	⎈ 	always returns true
⏎ 	⏎ 	takes user input(1 is true 0 is false)
=== memory syntax ===
all the syntax for functions
start of function:
 /name\‡[inputs]¶operations
there is <- or get which gives all the inputs(in the order of the functions input
to save a variable:
 name<-{list index}
to add to list:
 value-@index
0 is first index in the infinite list
put +- around value to say its binary:
 +-(value
Category:LanguagesCategory:APL-like
BadScript

BadScript is an esoteric language created by User:Celerition in 2016. Its purpose is being a new scripting language.
== Tokens ==
BadScript currently uses these tokens in the lexer.
Token 	Meaning
DEFVAR 	Used to define variables.
SETOP 	= Operator.
ADDOP 	+ Operator.
SUBOP 	- Operator.
MULOP 	* Operator.
DIVOP 	/ Operator.
IDIVOP 	\ Operator.
EXPOP 	** Operator.
EQUALS 	== Operator.
NOT 	~ Operator.
NEGATE 	! Operator.
ASSIGN 	= Operator.
ROOT 	// Operator.
MODULUS 	% Operator.
ISNOTNULL	$ Operator. It returns true if the preceding expression is not null.
== Metadata / Easter Eggs ==
# BadScript is a scripting language. It has 1 GUI, the console.
# It is VBScript-powered.
Category:Languages
Category:2016
Bad command or file name

Bad command or file name or SOD-SM is a esolang created by Mihai Popa. It's inspired by 'xxx' is not recognized as an internal or external command, operable program or batch file. and it imitates a common MS-DOS error when you attempt to execute a command that does not exist. 
== Commands ==
Every command will be valid and prints this:
 Bad command or file name
== Examples ==
=== Quine ===
 Bad command or file name
== Interpreter ==
=== Batch ===
@echo off
:bad
set /p x=C:\^>
echo Bad command or file name
goto bad
Note from the author:
 THIS IS NOT WORKING. ARE YOU SURE? HA, HA, HA, IT'S A JOKE LANGUAGE!
- Mihai Popa, 2023
=== Python ===
 print('\n'.join(['Bad command or file name']*len(__import__('sys').stdin.read().split('\n'))))
==See also==
* bash: foo: No such file or directory
* 'xxx' is not recognized as an internal or external command, operable program or batch file., another similar esolang.
* foo : The term 'foo' is not recognized as the name of a cmdlet, function, script file, or operable program. Check the spelling of the name, or if a path was included, verify that the path is correct and try again., PowerShell variant.
* Bad command or file name/No Quine
* Filename "xxx" doesn't seem to be a valid filename. Please check if the filename your trying to execute written correctly, WDS Variant
Category:Languages
Category:Joke languages
Category:Unusable for programming
Category:Output only
Category:Total
Category:2023
Category:Implemented
Bad command or file name/No Quine

This is the No_Quine variant of Bad command or file name. It is designed by PSTF.
If the source code is Bad command or file name, then output Hello, world!, otherwise output Bad command or file name.
== Example ==
=== Hello, World! ===
 Bad command or file name
=== Quine(I'm going to fool you with invisible characters, lol) ===
 ​Bad command or file name
== See also ==
Bad command or file name
== Categories ==
Category:Languages
Category:Joke languages
Category:Unusable for programming
Category:Output only
Category:Total
Category:2024
Bag

Bag by Ørjan Johansen is derived from John Conway's Fractran game/language, adding syntax and side effects to make it a "practical" programming language (although still an esoteric one), while being backwards compatible with it, and perhaps allowing a semi-efficient implementation.
The power, indeed Turing completeness of Fractran comes from viewing a natural number as the product of a bag (multiset) of prime factors, where the order of primes is immaterial but the number of each is important. The name of Bag is derived from this.
==Author's note==
Many details of the language are still under construction. There might even be a module system...
==See also==
* Fractran
* Fractran++
==External resources==
* Author's Bag page, including original message to the esoteric language mailing list.
Category:Languages
Category:Low-level
Category:Turing tarpits
Category:Turing complete
Category:Unimplemented
Category:2001
BaguaFuck

BaguaFuck, or ☰☱☲☳☴☵☶☷Fuck, is based on Brainfuck.
== Command table ==
 Command table
This Esolang	Brainfuck
乾 	>
兑 	<
离 	+
震 	-
巽 	.
坎 	,
艮 	[
坤 	]
== Example ==
=== Hello, world! ===
离离离离离离艮乾离离离离离离离离离
离离离兑震坤乾巽兑离离离离离离离艮
乾离离离离兑震坤乾离巽离离离离离离
离巽巽离离离巽兑离离离离离离艮乾震
震震震震震震震震震震兑震坤乾震巽震
震震震震震震震震震震震巽兑离离离离
离离离离离离离艮乾离离离离离兑震坤
乾巽兑离离离艮乾离离离离离离离离兑
震坤乾巽离离离巽震震震震震震巽震震
震震震震震震巽兑离离离离离离艮乾震
震震震震震震震震震震兑震坤乾震巽乾
离离离离离离离离离离离离离巽兑兑兑
=== 99 bottles of beer ===
Too long.
=== Cat Program ===
 坎艮巽坎坤
== Turing Completeness ==
It is turing complete 'cause Brain Explode is.
== Categories ==
Category:Languages Category:Brainfuck derivatives Category:Brainfuck equivalents Category:Implemented Category:CJK Category:Pseudonatural Category:Turing complete Category:Turing tarpits Category:Cell-based Category:Low-level Category:2024
Bake

Bake is an esolang created by User:Ractangle in 2024 in our universe (or by Damac Toltius at the time when Snakel was almost done in gammaline universe). The whole concept is mostly inspired by 'Python' is not recognized as an internal or external command, operable program or batch file.
==Syntax==
 Creates a line.
 String.
 Goes to line n.
 Print something.
 Halts program.
 Concatenate code.
 Get user input
 defines a variable
==Examples==
===Hello, world!===
 1[O{'Hello, world!'};E]
===Cat program===
 1[O{I};E]
Category:Languages Category:2024 Category:Unimplemented Category:Unusable for programming
BallisticScript

BallisticScript is a language created by MelonMars that is based on using a cannon to fire at the memory field to influence it.
== Features ==
You use a cannon to fire at a field of memory, and the impact angle acts as the command. There is one "register" that contains one character of information.
== Syntax ==
You start off by creating a memory field similiar with the syntax:
+++
+-+
+++
, where "-" means nothing/empty, and a "+" denotes the border of the table. Then you control the cannon via the the
fire(velocity,cannonRotation,cannonAngle)
and move the cannon via
move(x,y). 
Where the projectile lands impacts what happens. If it lands at a valid tile, then an angle>10 then the place where the projectile landed is set to the register, if 20>angle>10 then the character stored where the projectile landed is printed, if 30>angle>20 then the value of the character that the projectile landed on in ascii is added to the register, if 40>angle>30 then the value of the register in ascii is added to the tile where the projectile landed on, if 50>angle>40 then the register is set tot he value of the tile it landed on.
== Example ==
.memField
++++++++++
+-------6+
+--------+
+---3----+
+------2-+
++++++++++
6: "hello"
3: "world"
2: " "
.cannonCommands
fire(20, 10, 10)
move(10, 10)
.end
I have no clue what this code does, but I believe it may do something. I have not ran it, as I don't feel like it.
== Implementation ==
There is an implementation of it at: GitHub
Category:Languages Category:Thematic Category:Implemented Category:2023
Banana Scheme

Let's call regular Scheme, with which I assume everybody is familiar, "Scheme-0".
Now let's introduce another programming language, Scheme-1: It's just like Scheme-0, but has an extra function, (H x code), which takes two arguments - x, which has to be 0, and code, a piece of Scheme-0 code.
H will determine whether the piece of code will halt or not, and return true if it does and false otherwise (a syntactically incorrect program is assumed to halt). H itself is guaranteed to halt, because it is "magical". Giving it a first parameter greater than 0 results in an error.
Now let's introduce another programming language, Scheme-2. It's just like Scheme-1, but the instruction H will now accept 0 or 1 as its first argument. (H 1 code) will halt-check a Scheme-1 program.
Now that we have Scheme-1 and Scheme-2, we can also have Scheme-N for an arbitrary natural number N.
Now consider the following program:
 (let loop ((n 0))
 (H n '(quote ()))
 (loop (+ n 1)))
It's pretty clear that this program does not halt. A more interesting question is: What programming language is it written in?
It's clearly not Scheme-N for any natural number N, since, given sufficient time, the program will execute (H X '(quote ())), with X > N.
The language in which this program is valid is the first transfinite Scheme - Scheme-omega. Note that Scheme-omega, unlike any Scheme-N, does NOT add a new legal x value to the "previous" scheme. This is because omega is a limit ordinal, which doesn't have a "previous" ordinal.
Scheme-omega is important because in it you can, if you want, write a Brainhype interpreter. Anybody care to implement one?
The next Scheme after Scheme-omega is, of course, Scheme-omega+1, which does add a new valid x value, allowing (H omega code), capable of halt-checking Scheme-omega code. Note that in order to fully support this, our Scheme would require a transfinite ordinal datatype - not a big deal. Note however than any fixed finite notation for ordinals can support only countably many of them, so that there is always a next (still countable) ordinal which requires a new kind of representation.
==External resources==
* Oracle machine on Wikipedia
* Ordinal number on Wikipedia
* Arithmetical hierarchy (Relation to Turing machines) on Wikipedia
* David Madore's article "Qu'est-ce qu'une machine hyperarithmétique ?" which leads a bit further down the same rabbit hole.
Category:Functional paradigm
Category:2006
Category:Uncomputable
Category:Unimplemented
Category:High-level
Category: Languages
Bananaban

(NOTE: if you want to name a new language this, go ahead and take this page. I abandon this.)
1hals (talk) 21:55, 7 August 2024 (UTC)
Category:Candidates for deletion :Category:Candidates for deletion 1hals (talk) 16:08, 9 August 2024 (UTC)
Bananaban is a compiled esolang similar to Set. A program consists of a sequence of lines containing commands. Command arguments are numbers, and numbers are written in decimal. Numbers can also be represented by their ascii codes as letters. Any line that does not start with a command is treated as a comment.
== Commands ==
ban A B = static memory; reserve locations A through B
set A B = assignment; set value of location A to the value B
set@ A B = assignment; set location A to value at location B
set* A B... = assignment; set locations starting from A to the sequence of values B
dif A B = difference; set value of location A to the value of location A minus value of location B
dif@ A B = difference; set value of location A to the value of location A minus the value B
== Memory mapped control ==
Every number can be read from and written to. But some locations have special meaning.
0 = program instruction pointer
1 = current output
2 = current input
3 = if set to 0, the program halts
== Example Programs ==
=== Hello world (1) ===
 set 1 H
 set 1 e
 set 1 l
 set 1 l
 set 1 o
 set 1 32
 set 1 w
 set 1 o
 set 1 r
 set 1 l
 set 1 d
 set 1 !
 set 1 10
 set 3 0
=== Hello world (2) ===
 set* 4 Hello 32 world! 10 0
 set Z 4
 set@ 3 Z
 set@ 1 Z
 dif Z -1
 set 0 1
=== Print the language name ===
 set* 3 Bananaban 10 0
 set Z 3
 set@ 3 Z
 set@ 1 Z
 dif Z -1
 set 0 1
=== Cat program ===
 set@ 1 2
 set 0 0
Category:Unimplemented Category:Languages
Bantas

Bantas is an esoteric programming language developed by Jon Velasco and inspired by Blank. The word Bantas is a Filipino/Tagalog term for punctuation mark.
==Commands==
Cmd	Description
@ 	sets the position
? 	print
> 	input
< 	puts a value to a stack
~ 	used for debugging. It simply displays the values of stack and outputs to a file
x 	a loop that displays the value of a stack horizontally
X 	a loop that displays the value of a stack vertically
% 	sets the title of the console
+ 	addition operator (adds a value/stack's value to a stack)
- 	subtraction operator (subtracts a value/stack's value to a stack)
* 	multiplication operator (multiplies a value/stack's value to a stack)
/ 	division operator (divides a value/stack's value to a stack)
^ 	exponent
& 	used to concatenate
 	loads values in the stack
[] 	repeats a process (see sample codes)
() 	manipulates strings
_ 	gets the length of a string
{ 	sine
} 	cosine
\ 	tangent
==Examples==
====Hello World====
 ?,Hello World!
====99 bottles of beer====
 %,PROGRAM : 99 Bottles of Beer
 @,1
 <,99
 [,1
 @,2
 <,@1
 @,3
 <,@1
 &, 
 &,bottles of beer on the wall, 
 &,@1
 &, bottles of beer
 ?,@3
 @,2
 -,1
 @,4
 <,Take one down, pass it around, 
 &,@2
 &, bottles of beer
 ?,@4
 ?,
 @,1
 -,1
 ],1
====Fibonacci sequence====
 %,PROGRAM : Fibonacci Sequence
 @,1
 <,1
 @,2
 <,1
 @,3
 <,
 @,4
 <,1
 [,4
 @,3
 &,@1
 &, 
 &,@2
 &, 
 @,1
 +,@2
 @,2
 +,@1
 @,4
 +,1
 ],10
 ?,@3
====Factorial of a Number====
 @,1
 >,Enter a number:
 @,2
 <,1
 [,1
 @,2
 *,@1
 @,1
 -,1
 ],1
 ?,@2
====Reverse====
 %,PROGRAM : REVERSE A STRING
 @,1
 <,1
 @,2
 >,Enter a string:
 @,4
 <,
 @,5
 _,@2
 [,1
 @,3
 <,@2
 ),@1
 (,1
 @,4
 &,@3
 @,1
 +,1
 ],@5
 ?,@4
====Radians to degrees====
 %,PROGRAM : RADIANS TO DEGREES
 @,1
 >,Enter angle value in radians:
 @,2
 <,180
 /,3.1416
 *,@1
 @,3
 <,The value in degrees is 
 &,@2
 ?,@3
==External resources==
*Website
Category:Languages Category:Stack-based
BareMinimum

BareMinimum is a programming language with only two operators: subtract and minimum.
==Expressions==
All expressions in BareMinimum are in prefix notation. There are two binary operators: - and +. - is the usual binary subtraction operator, and + returns the minimum of its arguments. Integer constants and variables are also supported. Spaces can be used to separate arguments
==Statements==
There are three kinds of statements in BareMinimum: variable, loop, and output.
===Variables===
Variables are defined using the = assignment operator like so:
var = expr
Variables can be accessed by simply putting their name.
===Loop===
Loops are done by typing a variable name, and an opening curly brace. Then enter some statements and a closing curly brace. For example:
 x{
 x = y
 }
The variable's value will be queried each time the loop is run and if it equals zero the loop will end, otherwise the loop will repeat.
===Output===
Simply typing an expression without an equal sign will output the value of the expression.
===Comments===
A line starting with a space becomes a comment and is not executed.
==Examples==
===Useful subexpressions===
 x+y
z = -x-0y
 max(x,y)
z = -0+-0x-0y
 abs(x)
z = --0+0-0x+0x
 x == y (0 or 1)
z = +1--0+0-0-x y+0-x y
==Minimization==
Using the loops, the minimum operator can actually be implemented using the subtraction operator. (Prove it? That's, uh, left as an exercise to the reader.) Also, no literals are needed except the 1. Of course, comments can be removed. We can remove support for multiple operations on one line, and we're left with a fairly minimal version of this language. One other thing to do is combine the looping function with the subtraction function, producing an OISC. Replacing it with a "GOTO if nonzero" would work. This gives us an OISC where the operation is "subtract and jump if nonzero". Seems kinda similar to another OISC on this wiki...
==Computational class==
BareMinimum is Turing complete because you can implement a Minsky machine in it. The registers are variables, and we can test if they're zero using a loop that immediately breaks out of itself after running once, so we have an if statement. We can store the state in another variable and compare it to each value, running some code on a success. This also shows that we don't need the minimum operator.
Category:Languages
Category:Turing complete
Category:Turing tarpits
Barely

Barely is an esoteric programming language created by Jeffry Johnston in 2006, with the goal of having as small a Turing complete interpreter as possible. The interpreter is in MS-DOS COM binary format and is 59 bytes in size. It was written using DEBUG, so the source listing is made from disassemblies at different points in the program.
The language was originally based on BF, but only somewhat resembles it in its current form. There is a tape of uninitialized memory cells, a memory pointer (mp) initially 0, instruction pointer (ip) initially the last input, jump offset (jmp) initially 0, and 8-bit accumulator (acc) initially 126. Commands consist of a single character. Programs are read from stdin, should be written from right to left (rather than the customary left to right), and must not contain any non-command characters (newlines, etc). The program is separated from its input by a tilde (~).
Commands (letters in parenthesis are commands that are also executed as a side effect):
] exit program
^ if acc == 0 then (b)
b ip += jmp 
f no-op
g acc = contents of cell at mp (i)
h acc += 71 (k)
i mp++ (j)
j acc++ (k)
k jmp--
l no-op
m contents of cell at mp = acc (o)
n mp-- (o)
o acc-- (p)
p jmp += 10
q no-op
s no-op
t stdin -> acc
x acc -> stdout
~ mandatory no-op, marks end of program input
BF Conversions (read right to left):
< kkkkkkkkkjn
> kkkkkkkkkoi
+ kkkkkkkkkkkkkkkkkjmjng
- kkkkkkkkkkkkkkkkkkkkkkkkkkkkjmong
. kkkkkkkkkxg
, kkkkkkkkkjmt
The `[' and `]' commands do not have a 1:1 mapping. The following algorithm can be used to find the number of l's, k's, and p's for a BF-like loop:
Initial values:
i = number of characters inside the loop (not counting the wrapping `^' or `b' characters)
k = 0
p = 0
Perform the following two calculations until the `k' and `p' values no longer change.
k = i + p + 2
p = ceil((i + p + k + 1) / 10)
l = 9p - i - k - 1
Example (read right to left):
b?????^, so i = 5, k = 0, p = 0
k = 5 + 0 + 2 = 7, p = ceil((5 + 0 + 7 + 1) / 10) = ceil(13 / 10) = 2
k = 5 + 2 + 2 = 9, p = ceil((5 + 2 + 9 + 1) / 10) = ceil(17 / 10) = 2 
k = 5 + 2 + 2 = 9, p = ceil((5 + 2 + 9 + 1) / 10) = ceil(17 / 10) = 2 (no change)
l = 9x2 - 5 - 9 - 1 = 3
The loop becomes: bpp?????^kkkkkkkkklll
==Example==
This prints "Hello, World!" and exits.
]xhhhhooooooooohhhhhhxooooooooxooooooxjjjxhoooohhhxhohhhhhhhxhhhhjjjhhhxhhhhooooooooohhhhhhxjjjxxjjjjjjjxjhhhhxjhhhhhhhhjjjhh~
==See also==
* MinISCule
==External resources==
* Barely interpreter binary (MS-DOS)
* Barely interpreter source listing
* Bootable FreeDOS disk image, with MinISCule, Barely, FreeDOS Debug
Category: Languages
Category: Implemented
Category: Turing complete
Category: 2006
Category:Cell-based
Category:Turing tarpits
Category:Low-level
Barrous

Barrous is an improvement on Modulous inspired by APL made by User:Abyxlrz.
It is a 1D stack based esoteric programming language with variables.
=Non-commands=
^ can be used in place of a value to refer to the top of the stack.
Variables may be defined by any alphabetic name when they are first called. All variables start at 0
The maximum value is 255 for variables and the stack, if a value goes over that number, it will loop over to 0.
The stack is assumed to have the value 0 when it has no values.
All commands must be separated by bars or newlines. For example: num;5|>2|=|#num|num-1|num<3|<3 
If there aren't any commands to run anymore, the program ends.
Monadic arguments only use the argument to the command's right.
Values don't get popped unless specified in explanation.
=Commands=
Command	Name 	Explanation
y>x 	Jump forward 	Monadic: The pointer jumps forward x amount of commands; Dyadic: If y is equal to 0, then the pointer jumps forward x amount of commands, otherwise, do nothing.
y<x 	Jump backward 	Monadic: The pointer jumps backward x amount of commands; Dyadic: If y is equal to 0, then the pointer jumps backward x amount of commands, otherwise, do nothing.
v+x 	Add 	Dyadic: If v is a variable, then x gets added to v and the result is stored in v. If v is ^, then the top value of the stack becomes the sum of x and v.
v-x 	Subtract 	Dyadic: Subtracts x from v and stores the result in v.
y;v 	Push 	Dyadic: If v is a variable, then the variable will become the value of x. If v ^ then the value of y will be pushed onto the stack.
:v 	Pop 	Monadic: If v is a variable, then it will become undefined. If v is ^ then the top value of the stack is popped.
! 	Reset 	Niladic: Resets the pointers position to the start of the program.
= 	End 	Niladic: Ends the program.
@x 	Print character	Monadic: Outputs an ASCII character with the value of x.
#x 	Print value 	Monadic: Outputs the value of x as a number.
v?x 	Random 	Dyadic: If v is a variable, a random integer will be generated from 0 to x and stored into v. If v is ^, a random integer will be generated from 0 to x and is pushed onto the stack.
&v 	Input character	Monadic: If v is a variable, then input is taken from the user as a single ASCII character and the value is stored into v. If v is ^, then input is taken from the user as a single ASCII character and the value is pushed onto the stack.
%v 	Input number 	Monadic: If v is a variable, then input is taken from the user as an integer and the value is stored into v. If v is ^, then input is taken from the user as an integer and the value is pushed onto the stack.
=Example programs=
==Count down from 5==
 num;5|>2|=|#num|num-1|num<3|<3 
==Truth-machine==
 %truth|truth>3|#1|<1|#0 
Category:Languages Category:APL-like Category:Unimplemented