nyuuzyou/wikis huggingface dataset:
B sharp

== Introduction ==
In music, there are a couple marks known as "sharp" or "flat". They raise or lower the pitch half a tone, respectively. Since B is half a tone below C, B♯ IS C. Therefore, the language B♯ IS C as well.
=== Pronunciation ===
B♯ is pronounced "Bee-sharp".
== Program ==
=== Hello, world! ===
#include<stdio.h>
void main()
{
 printf("%s", "Hello, world!\n");
 // return 0;
}
== See also ==
* D♭♭
* CFUCK
Category:Languages
Category:Bounded-storage machine
Category:Implemented
Category:Low-level
Category:Joke languages
Baa

baa is a register-based esolang created by User:Joaozin003 where each command has the form "b*insert two or more a's*"
== Syntax ==
The syntax is very easy to understand.
Also, commands can only appear once per line.
=== Numbers ===
It's the only form of objects and can be passed as arguments to some commands (more on that later!) and is held by the registers (more on that later!).
Numbers are represented by any amount of consecutive letters (not at the start of the line, otherwise it's a command) and the amount of letters is the number.
Examples: 10 = tenletters, 11 = elevenchars
== Registers ==
Registers can hold numbers and are the "replacements" of variables.
There are 3 registers in baa and we call them a, b and r.
Registers a and b serve as inputs for mathematical operations and r is the result of them.
== Constants ==
The only constant is zero (represented by 0) (it's a constant because it can't be achieved without mathematical operations) and can be put in registers a and b just like if it was a normal number.
== Commands ==
Command 	Description
baa 	Start program
baaa 	End program
baaaa 	Print specified number as Unicode
baaaaa 	Print the r register as Unicode
baaaaaa 	Set the a register to the specified number
baaaaaaa 	Set the a register to the r register
baaaaaaaa 	Set the b register to the specified number
baaaaaaaaa 	Set the b register to the r register
baaaaaaaaaa 	Set the r register to the sum of a and b
baaaaaaaaaaa 	Set the r register to the difference of a and b
baaaaaaaaaaaa 	Set the r register to the product of a and b
baaaaaaaaaaaaa 	Set the r register to the quotient of a and b
baaaaaaaaaaaaaa 	Set the r register to a modulo b
baaaaaaaaaaaaaaa 	Set the r register to a squared
baaaaaaaaaaaaaaaa 	Put a label here with a id of the line number
baaaaaaaaaaaaaaaaa 	Goto the label with a id of the specified number if a > 0
baaaaaaaaaaaaaaaaaa 	Goto the label with a id of the specified number if b > 0
baaaaaaaaaaaaaaaaaaa	Goto the label with a id of the specified number if r > 0
== Example programs ==
=== Print every Unicode character ===
 baa
 baaaaaa 0
 baaaaaaaa a
 baaaaaaaaaaaaaaaa
 baaaaa
 baaaaaaaaaa
 baaaaaaa
 baaaaaaaaaaaaaaaaa four
 baaa
This program loops and prints all unicode characters (starting with NUL) until unicode ends and the interpreter likely throws an exception.
== Contribute ==
If you have any ideas, make sure to put them in the talk page!
==External resources==
* An interpreter written in Python
Category:Implemented
Category:Languages
Category:2022
Babacode

Babacode is a language based on Babalang and Baba Is You.
==Commands==
All commands on variables are <optional condition><variable1><verb><variable2>. If verb is IS, variable2 can instead be a method.
Verbs:
Babacode || Python
IS || variable1 = variable2
EAT || variable1 += variable2
WIP
Category:Works-in-Progress
Category:Languages
Category:Stubs
Babbage

Babbage is an unfinished joke language from 1981 by Tony Karp, designed as the antithesis and replacement of Ada. It contains such statements as WHAT IF, DO UNTO OTHERS</CODE>, JUST-IN-CASE and BASKET CASE. Babbage is also the name of the GEC4000 series assembler.
==External resources==
*Babbage - The language of the future
*Babbage - GEC4000 series assembler
Category:Joke languagesCategory:Before 1993Category:Languages
Babble

==Concept==
According to Saussure, a symbol may be absolutely arbitrary (using 3 to mean the number after 2), or only relatively arbitrary, like the compound word "screwdriver", which is built from component parts that already have denotations ("screw" and "driver"). 
In Babble: 
# There are no relatively arbitrary signs -- each symbol is both entirely arbitrary until it's explicitly defined
# Any sign is applied globally and permanently, across every Babble program running anywhere
==Language Overview==
Babble (not to be confused with Babel) has two types of functions: anonymous and named. Named functions have a global scope -- globally global, in that, once defined, they are available from any Babble program running anywhere. They can never be changed.
A small selection of symbols will be defined when the language goes live (1, 0, +). All other symbols are available to be defined by anyone. If I decide to use the symbol 27 to mean -4.39428, someone will have to come up with a different symbol for 27, perhaps twenty-seven, unless that too is already used. If a function has no inputs and only refers to other constants, it cannot be defined twice (if someone decides to define 28 to mean the number 27, assigning another symbol for 27 will be return an error).
Implementation to follow. It will probably be a LISPy language.
Category:Languages
Category:2015
Category:Unimplemented
Babel

Babel is an esolang currently developed by Sinthorion, in which the source code may only contain the lowercase letters, whitespace, commas and periods. It is a general purpose imperative language. Babel is named after the Library of Babel, both in the sense of Borges' original work and the fanmade website based on it.
As there are (almost) no special symbols in Babel, the language is based heavily on contextual keywords. Integer literals are written as the number written out in English. The keywords and the language in general are intended to be as non-technical sounding as possible. Often times there are multiple ways to express something or even optional redundant keywords to allow the programmer to write a program more like English text.
The language has a string type but it is restricted to holding only the same reduced character set of the code itself: Only lowercase letters, whitespace, commas and period. Babel programs are incapable of reading or writing any character outside this character set; depending on the method used, either the read attempt errors or the text is converted to valid text.
== Character Set ==
Formally the Babel character set contains:
- All 26 lowercase letters of the Latin alphabet (U+0061-U+007A).
- Whitespace: An implementation must at least allow space (U+0020) and linefeed (U+000A) but may additionally support tab, carriage return, and any other Unicode character considered whitespace. All of these in any quantity and combination are considered syntactically equivalent to a single space.
- Comma (U+002C) and period (U+002E).
Any other character is to be either ignored or raised as syntax error.
== Data ==
Babel has variables, which are identified with any word that is not a reserved keyword. Variables are dynamically typed. (Possibly, a combination of multiple non-keyword words can also be a valid name. Yet to be decided in further development.)
Babel has the following primitive data types:
* number (integer; usually signed 64 bit)
* text (a string that may only contain characters of the Babel character set)
* option (boolean, with the value of true/yes or false/no)
* list
== Examples ==
As the language is still early in development, any of this might still change in future.
hello world:
 write text hello world.
hello <name>:
 write line text enter name.
 name is read line.
 hello is word hello
 hello name is concat with space hello and name.
 write hello name.
Category:Languages
Category:Works-in-Progress
Baby Language

Baby Language is a conceptual esoteric programming language created by User:ais523 in 2016.
A Baby Language interpreter ignores the input program and does something random. (Likewise, a Baby Language compiler generates a random executable.) As such, whatever you wanted your program to do, there's an (admittedly small) chance that it will actually do it.
The intended use case for the language is to run your program repeatedly until it does what you want. Just like trying to reason with a real baby, this may take quite a while.
An interpreter created in Python 3 by User:Enoua5: View Source
Category:Joke languagesCategory:2016Category:NondeterministicCategory:Unusable for programmingCategory:ImplementedCategory: Languages
Back

Back is a Fungeoid that can reflect back to the program when the program counter goes out of bounds.
==Reflection==
Take this program as an example:
\\
 *
It will eventually halt. These are the steps that Back takes:
# Move down a char
# Move down a char. This reaches the end of the program, so it maps back to the top of the line.
# Move right a char. This reflects the PC down a char, and then it reaches the end of the program.
As another example, this will also halt(which reflects 2 times):
//
 *
==Syntax==
The program counter starts at row 1, column 1, with the direction as right. It will stop when a * is encountered.
\	Reflect the direction down if the direction is right; Reflect the direction right if the direction is down. And vice versa.
/	Like \, but reversed. Reflect the direction down if the direction is left; Reflect the direction left if the direction is down. And vice versa.
<	Move the bitwise tape head left a bit.
>	Move the bitwise tape head right a bit.
-	Flip the current bit.
+	Execute the next instruction if the current bit is nonzero.
*	Halt the program.
==Computational class==
It can compile quite easily to Boolfuck without I/O.
+=-
<=<
>=>
[]=Conditionally switching the program flow; there is no exact translation
Example:
+\
==Implementations==
A Python interpreter by User:Bangyen.
Category:Languages
Category:2019
Category:Implemented
Category:Two-dimensional languages
Category:Turing complete
Category:Turing tarpits
BackStart

BackStart is a version of the Minsky machine with a single counter.
==Commands==
Command	Operation
i x 	Add x to the counter.
d x 	Decrement the counter x times if it is not zero; if it is zero return to the start of the program. If the counter is lower than zero following the decrementing, an error is signaled.
b 	Return to the start of the program.
o x 	Output the number x if does not equal zero. If x is zero, output the counter instead.
==translation to UBLANG==
BackStart	UBLANG
i x 	+ x times
d x 	- x times
b 	/
o 0 	.
o x 	* x times, ; and / x times
==Examples==
===Hello World===
The following program prints “Hello, world!”:
 o 72
 o 101
 o 108
 o 108
 o 111
 o 44
 o 32
 o 119
 o 111
 o 114
 o 108
 o 100
 o 33
===Infinite Counter===
This program prints the infinite sequence of integers starting from inclusive one (1):
 i 1
 o 0
 b
==Interpreter==
* Common Lisp implementation of the BackStart programming language.
Category:Languages Category:Push-down automata Category:Output only Category:Implemented
BackTurn

Category:LanguagesCategory:UnimplementedCategory:2018Category:Reversible computingCategory:Two-dimensional languagesCategory:Self-modifying
BackTurn is a 2D reversible programming language. There are three kinds: level 0, level 1, and level 2.
Commands:
* \ Fixed mirror*
* / Fixed mirror*
* [ Rotate counterclockwise and flip
* ] Rotate clockwise and flip
* + Input**
* ? Output
* ! Halt
(* = available only at level 1 or 2, not at level 0; ** = available only at level 2, not at level 0 or 1)
When the rotation is flip, then the entire group of rotators is flipped between clockwise and counterclockwise. The group consists of all rotators (regardless of direction) connected by a series of king moves.
Input: If hit moving right, is input one bit; if 0 then go up but if 1 then go down. If hit moving left just bounces back. If hit moving down then push back input 0 and go left. If hit moving up then push back input 1 and go left.
Output is a list of directions up/down/left/right; if the output is the reverse direction of the previous output then it cancels that previous output and now the one before that is considered as the last one so far in case that one will be cancelled too.
The program may begin at any exclamation mark and in any direction.
If the "unlimited memory" option is used, copies of the initial program can tile the infinite grid in order to make infinite memory. A program using this option may also have initialization of tiles; the initialization is done by initially flipping some rotator groups in some of the copies.
==Patterns==
The flipping mirrors from BackFlip can be made from the following patterns of two rotators each:
 v^ v^
 > [<] >
 <] > [<
 ^v ^v
 >[ < ]>
 < ]>[ <
 v^ ^v
These patterns are for the / mirror (to make \ mirror, flip the rotators). Which one of these four patterns is needed to form it depends on what other mirrors are in the same row/column (the v^<> are just to explain which direction it is going) (which pattern makes a / mirror makes a \ mirror instead if the context is different).
Back Alley

==Back Alley==
Have you ever wanted to worry about your program getting jumped by a criminal?
Ever wanted to juggle programming with constantly not getting arrested?
Great! Welcome to Back Alley a programming language with the goal of acting as if everything went on in a dark alley.
Github: 
==Hello, World==
Since Back Alley is transpiles into C++ you have to make a main function that can be done as so.
 hire yourself int
 	say "Hello, World"
 pay 0
hire creates a function and yourself becomes main, you can't type main because I said so and so does the compiler.
==Fizz Buzz==
 hire yourself int
 crime 2
 say "Welcome to a Fizz Buzz program in back alley!\n"
 
 trip i 30
 ask criminal i != 0
 ask criminal i%3 == 0
 say "Fizz "
 stop asking
 
 ask criminal i%5 == 0
 say "Buzz"
 stop asking
 
 ask criminal i%3 != 0 and i%5 != 0
 say I
 stop asking
 
 say ", "
 stop asking
 stop tripping
 pay 0
In Back Alley you have a heat level if it get's to high your program will get caught.
If your heat get's to low your program will leave the Back Alleys and become a good citizen.
==Syntax==
Back Alley doesn't care about indentation or new lines so the "Hello, World" program can also look like this
 hire
 yourself
 int
 say 
 "Hello, World"
 pay
 0
Command	Description
say 	Will print the next value given
buy 	Will make a variable with the given type name and value buy int var1 0
mug 	Gets input and puts it into the variable give mug var1
hide 	Will reduce heat by value given hide 2
crime 	Will increase heat by value given crime 2
ask 	Starts an if state ment can be followed by a person for if by another person for elif and no-one for else ask person "e" == "e" say "true"
skip 	Acts as continue
end 	Acts as break
stop 	After tripping or asking you must stop the activities stop asking
trip 	A for loop starts at 0 goes to the number given current number stored in the variable given trip i 10 say i stop tripping
whisper	Everything at compile time will be in lowercase, so strings and variable names unlike say it will not increase heat whisper "HELLO, WORLD"
use 	Allows you to change variables use var1 69
hire 	Creates a function hire zing int
pay 	ends a function and determines what it will return pay 69
call 	calls the function all arguments after the name of the function will be considered arguments for the function call zing
hang-up	Must be put after a call statement so the program knows what is a function argument or not
Note: task can be put after a function call to allow for arguments
==Opposite number Function==
 hire opp_n int task int num
 	say num*-1
 pay 0
 
 hire yourself int
 	call opp_n 69 hang-up
 pay 0
Currently functions can't be pased as arguments, and as this is being typed I'm working on allowing the user to actually get input back from function's.
==External resources==
* GitHub
Category:Languages Category:Implemented Category:Thematic
Backshar

Backshar is a programmable language with actual commands similar to real languages such as C#, C++, JS, Python, and more.
Nothing about it, excluding strings, comments and variable values, use A-Z & 0-9. It's all symbols.
This is the first functional language by threesodas. Unlike the rest, it actually has IO capability.
You are 100% allowed to create a compiler for this. It'd be appreciated!
==Syntax==
===Print & read input===
(string)=>[@] : Print a string.
()<=[@] : Read a user input. Does not set input to anything.
===Variables===
#[var name]=>[value] : Set a variable to value.
#[var name]<=[@] : Set a variable to user input.
#[var name]<=[var name] : Set a variable to another variable's value.
#[var name]<=(type) : Convert a variable to a certain type (string, int, bool, etc.)
===Condition Statements===
$%(value or var) (condition) (value or var) & : If statement
$&(value or var) & : Switch statement
$@ (condition)=> (action) : Case (Switch statement)
===Operators & Conditions===
Conditions
!# : Equals (==)
$# : Not equals (!=)
&# : Greater than (>)
*# : Less than (<)
+# : Or (||)
-# : And (&&)
Operators
^% : Plus (+)
@% : Minus (-)
*% : Times(*)
!% : Divide (/)
?% : Join (+)
===Comments===
_(string) : Single Line Comment
!( + )/ : Multi Line Comment
===Functions===
@[func name]( + )@ : Function
===Time & Date===
All info is returned as a numerical value.
*! : Current Day of Month
!! : Current Year
?! : Current Day of Week
$! : Current Month
&! : Current Week
^^ : Current Hour
@^ : Current Minute
#^ : Current Second
Timezones are returned as UTC-6:00 or UTC+5:00.
$^ : Timezone
==Program Examples==
===Print Hello, World!===
 ("Hello, World!")=>[@]
===Simple addition calculator===
 ("Input your first number.")=>[@]
 #[x]<=[@]
 ("Input your second number.")=>[@]
 #[y]<=[@]
 #[z]<=[x] ^% [y]
 ("The sum of " ?% [x] ?% " and " ?% [y] ?% " is " ?% [z])=>[@]
==="Predict" the future===
 ("Hmm, yes... 5 days from now, it will be the " ?% *! ?% "th of month " ?% $!?% " of " ?% !! ?% ".")=>[@]
===Family===
* Sequel: Backshar+
* Sequel: Backsharp
Category:Languages
Category:Object-oriented paradigm
Category:Total
Category:Nondeterministic
Category:queue-based
Category:Usability unknown
Category:Unimplemented
Backshar+

Backshar+, a sequel to Backshar, is a completely symbol-based language. Nothing, unlike Backshar, uses A-Z & 0-9. It was remade like this by threesodas to be more "esoteric". Every single command is the same, except when writing variable names, string names, function names, etc. It uses a combination of symbols to represent the character desired to use.
==Syntax==
===Print & read input===
(string)=>[@] : Print a string.
()<=[@] : Read a user input. Does not set input to anything.
===Variables===
#[var name]=>[value] : Set a variable to value.
#[var name]<=[@] : Set a variable to user input.
#[var name]<=[var name] : Set a variable to another variable's value.
#[var name]<=(type) : Convert a variable to a certain type (string, int, bool, etc.)
===Condition Statements===
$%(value or var) (condition) (value or var) & : If statement
If statements must use indent.
This is valid code:
 $%=#. &# ^#.
 #[\\,]=>=#.
 #[:&,]=>^#.
This is invalid code:
 $%=#. &# ^#.
 #[\\,]=>=#.
 #[:&,]=>^#.
This too is invalid:
 $%=#. &# ^#.
 #[\\,]=>=#.
 #[:&,]=>^#.
$&(value or var) & : Switch statement
$@ (condition)=> (action) : Case (Switch statement)
===Operators & Conditions===
Conditions
!# : Equals (==)
$# : Not equals (!=)
&# : Greater than (>)
*# : Less than (<)
+# : Or (||)
-# : And (&&)
Operators
^% : Plus (+)
@% : Minus (-)
*% : Times(*)
!% : Divide (/)
?% : Join (+)
===Comments===
_(string) : Single Line Comment
!( + )/ : Multi Line Comment
===Functions===
@[func name]( + )@ : Function
===Time & Date===
All info is returned as a numerical value.
*! : Current Day of Month
!! : Current Year
?! : Current Day of Week
$! : Current Month
&! : Current Week
^^ : Current Hour
@^ : Current Minute
#^ : Current Second
Timezones are returned as UTC-6:00 or UTC+5:00.
$^ : Timezone
==Symbols which represent characters==
Character	Combination
Aa 	#$,
Bb 	@#,
Cc 	^&,
Dd 	%%,
Ee 	$+,
Ff 	]?,
Gg 	[@,
Hh 	!$,
Ii 	{%,
Jj 	!,,
Kk 	~$,
Ll 	(@,
Mm 	:&,
Nn 	;@,
Oo 	)^,
Pp 	*~,
Qq 	$$,
Rr 	##,
Ss 	!!,
Tt 	&&,
Uu 	{&,
Vv 	*},
Ww 	"",
Xx 	\\,
Yy 	">,
Zz 	//,
0 	??.
1 	#@.
2 	^#.
3 	%#.
4 	:;.
5 	=#.
6 	(&.
7 	%^.
8 	[].
9 	**.
SPACE 	!%\
. 	>?!
, 	&&!
! 	!!!
? 	%#!
==Hello, World! Program==
 ("!$,$+,(@,(@,)^,!%\&&!"",)^,##,(@,%%,!!!")=>[@]
==Family==
* Backshar: Prequel
* Backsharp: Sequel
Category:Languages
Category:Object-oriented paradigm
Category:Total
Category:Nondeterministic
Category:queue-based
Category:Usability unknown
Category:Unimplemented
Backslash Calculus

Backslash Calculus is a programming language invented by User:Tailcalled after reading this reddit comment.
== Syntax ==
Backslash Calculus is based on lambda calculus, but it only uses two characters: backslash and space. This is the basic syntax:
 E = \ \ E - abstraction
 | \ \\ E E - application
 | \\ - innermost variable
 | \\\ - the variable one level more out
 | ... - ...
== Computational Class ==
Backslash Calculus is clearly Turing-complete, even if one ignores its simple translation to lambda calculus. Here are the SKI combinators:
 S = \ \ \ \ \ \ \ \\ \ \\ \\\\ \\ \ \\ \\\ \\
 K = \ \ \ \ \\\
 I = \ \ \\
== Alternative alphabets ==
Tailcalled imagined a few alternative alphabets for Backslash Calculus.
=== Unreadable ===
One can replace backslash with ' and space with ". The SKI combinators will look like this with that alphabet:
 S = '"'"'"'"'"'"'""'""'""'"""''
 K = '"'"'"'"'''
 I = '"'"''
=== Brainfuck ===
One can change the syntax a bit to make Backslash Calculus look more like brainfuck:
 E0 = + E1 -
 | [ E0 E0 ]
 | .
 | ,.
 | ,,. <- unary-ish
 | ...
 E1 = > E0 <
 | [ E1 E1 ]
 | .
 | ,.
 | ,,. <- unary-ish
 | ...
The SKI combinators will look like this:
 S = +>+[[,,..][,..]]-<-
 K = +>[,.]<-
 I = +.-
==See also==
* Lambda calculus
* Combinatory logic
* S_and_K_Turing-completeness_proof
* Real Fast Nora's Hair Salon 3: Shear Disaster Download
Category:LanguagesCategory:Functional paradigmCategory:Turing completeCategory:UnimplementedCategory:2012
Backtracking INTERCAL

Backtracking INTERCAL is an extension of INTERCAL by Malcolm Ryan to include backtracking like in Prolog.
*A MAYBE tag on a statement creates a choice point, containing the entire state of the program except ABSTAIN/REINSTATE status, after which the statement is performed normally.
*A GO BACK statement backtracks to the most recent choice point, redoing the statement in the negated sense, ignoring it if it is active and performing it if it is abstained from.
*A GO AHEAD statement eliminates the most recent choice point from the stack.
==See also==
*Threaded INTERCAL
*POGA-INTERCAL
*Backtracking INTERCAL was implemented in version 0.25 of C-INTERCAL.
==External resources==
* 
Category:Languages
Category:Implemented
Category:Low-level
Category:2002