nyuuzyou/wikis huggingface dataset:
Brachylog

Brachylog is a declarative golfing language based on SWI-Prolog. It was created by Fatalize in 2015. The compiler is written in Prolog and generates SWI-Prolog code based on the input Brachylog code.
== Overview ==
Brachylog is a declarative language designed to write SWI-Prolog code tersely. As such the philosophy of coding in Brachylog is extremely close to the philosophy of coding in Prolog, and so is the vocabulary used.
A brachylog program is always constitued of a main predicate which has two arguments called Input and Output. In general, every predicate in Brachylog (built-ins included) has one Input and one Output argument. The program is entirely written on one line, and things get processed left to right. Predicates call will use the variable immediatly to the left of the predicate as Input and the variable immediatly to the right of the predicate as Output. Implicit variables are used when chaining predicates. Logical and and Unification are mostly implicit in programs as well. 
An in-depth presentation of Brachylog and all its built-in predicates can be found on the Github page of the project.
== Example Code ==
===Hello, world!===
 "Hello, world!"w
Alternatively, the following code:
 Ḥw
will output "Hello, World!" (capital W).
== External resources ==
* Official Github page
Category:2015
Category:Declarative_paradigm
Category:Implemented
Category:Turing complete
Category:Golfing language
Category:Languages
Brack

Brack is an esoteric programming language based on matching brackets.
== Syntax ==
A Brack program consists of a series of brackets, separated by spaces. In order for a Brack program to be valid, all brackets must match up in the end. This means that these are all valid Brack programs:
 [ ]
 ( )
 { }
 { ( [ ] ) }
 ( ( ) [ { } ( ) ] )
Whereas these are not:
 ( ]
 ( ( ( ] ) )
 [| |] (
== Semantics ==
The available brackets, coupled with their meanings (blank for undecided), are:
Left	Right	Meaning
( 	) 	
[ 	] 	
{ 	} 	
< 	> 	
Category:Languages
Category:2015
Category:Thematic
Bracket

Bracket is a programming language that only uses brackets
 [
Units 	How
[ 	add one
] 	subtract one
output ascii	
 	output number
[] 	input
][ 	apple 2
( 	start loop, stops when the top of the stack is 1 or 0
) 	end loop
: 	sepotator
[[[ 	go up
]]] 	go down
 	if the top of the stack, is 0 then jump to the nearest [][, if 1, ][], else no goto
[][ 	goto result
][] 	goto result
[][] 	ends the program
[[][ 	create var
[[] 	var add
[]] 	var subtract
][]] 	output var
& 	output as the input, used for setting vars from input
][][ 	spider
; 	comment and ends line
You can also switch around the brackets and the parentheses, for some reason
xkcd random number:
Normal
 [:[:[:[:]]:[][];
Swap
 (;(;(;(;));()():
Umm
 <.<.<.<.>>.<><>,
Cat:
 [:[:(:[]:[[:):[][];
Yeah
Category:Languages Category:2024
Bracket Hax

Bracket Hax is a high-level esoteric language created by MeTh0Dz, first published in August 2008. Brackets and other grouping symbols are frequently used in its syntax, hence the name.
==Code examples==
Example Code
Fibonacci's Sequence
# (0 + 0 = !f 0 + 1 = !g) #
# ($RESD $DISP 0 + !f = !f ~ 0 + !g = !g ~) #
#{[^ !f < 200] $RESD $DISP !f + !g = !f ~ !f + !g = !g ~} #
Example Code
Print 1 through 10
#(0 + 0 = !r) #
#[{^ !r < 10} $RESD $DISP !r + 1 = !r ~] #
==External resources==
Original post on Rohitab community forum (interpreter in C++)
Category:Languages
Category:Implemented
Category:High-level
Category:2008
BracketsLang

BracketsLang is esoteric programming language invented in 2021 by user PoetLuchnik to show that brackets are better than Python tabs. Code is a sequence of atoms and blocks of sub-code. The program is always curly brackets block. Each block contains sub-code and has its own accumulator, which is zero at the beginning. Atoms have no code in, and they works with parent block accumulator. Accumulator is byte value [0..255]. Brackets are code, everything else is notes.
== What do the brackets do ==
case 	description 	c-like
() 	print accumulator as ASCII character 	putchar(accumulator);
[] 	increase accumulator by the ASCII value of entered character 	accumulator += getchar();
<> 	set accumulator to null 	accumulator = 0;
{} 	increment accumulator 	accumulator++;
(sub-code) 	store parent accumulator by address in own accumulator 	RAM[accumulator] = parent_accumulator;
[sub-code] 	load value by address in accumulator and add it to parent accumulator 	parent_accumulator += RAM[accumulator];
<sub-code>	when ends if the accumulator not equals 0 then ending parent block immediately 	subcode(); if (accumulator != 0) break;
{sub-code} 	repeats sub-code endlessly, subtract accumulator from parent accumulator if ends	ui8_t T = 0; while(!isbreak) T = subcode(); parent_accumulator -= T;
== Examples ==
=== Hello World (almost) ===
 add 64
 {}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}
 add 8
 {}{}{}{}{}{}{}{}
 print 72 'H'
 ()
 sub 3
 {{}{}{}<{}>}
 print 69 'E'
 ()
 add 7
 {}{}{}{}{}{}{}
 print 76 'L' x2
 ()()
 add 3
 {}{}{}
 print 79 'O'
 ()
 enter any key to continue
 []
 escape from program
 <{}>
=== Cat ===
 [] input
 () output
 <> void accumulator
 and no escape
=== Alphabet ===
 r0 = 26
 {}{}{}{}(<>)[<>][<>]{}(<>)[<>](<>)
 65
 {}{}{}{}{}{}({})[{}]{}
 r1 = 65
 ({})
 infinity loop
 {
 	load r1
 	[{}]
 	print r1
 	()
 	+1
 	{}
 	store r1
 	({})
 	if --r0 == 0 then break
 	<{
 		if --r0 != 0 then break
 		<[<>]{{}<{}>}(<>)>
 		+1
 		{}
 		<{}>
 	}>
 } 
 end of program
 <{}>
== Compilers ==
Not exists now...
== Interpreters ==
=== EasyBracketsLang ===
EBL is interpreter created by author of this esolang. EBL on itch.io
Category:Low-level 
Category:Cell-based 
Category:Implemented 
Category:Languages
Category:2021
Category:Turing complete
Braimmental

Braimmental is a simple combination of Brainfuck and Emmental by User:BoundedBeans that drastically changes how to write programs in either one.
==Syntax==
Syntax is like normal brainfuck, except that inside of loops, the code becomes Emmental. That's not all, however. If you want to redefine an Emmental command, you have to give it a Braimmental program, starting with the normal outer brainfuck layer and inner Emmental. This creates an alternating depth structure that gets worse the more you want to nest loops. 
==Transferring of data==
The tape is made out of bytes, but is unbounded in both directions. The area to the left of the pointer represents the queue in Emmental, up until the point where there are three zeroed cells in a row, which ends it. The front of the queue is closer to the pointer, while the back of the queue is farther. The stack is at the pointer and to the right, where the pointer is at the top of the stack. Whenever a loop starts, it converts the tape to the stack and queue, and at the end of the loop, it checks if the top of the stack is not zero, and if that is true, restarts the loop and repeating the Emmental program. This allows for some weird things, like shifting cells easily. In redefined Emmental commands, when they are run it converts it back to the tape, and any loops in that convert it to the stack and queue, and so on.
==Examples==
===Cat===
 ,.[,.]
===Hello world===
(This exits the loop at the end because the stack is empty, and therefore is considered to have zero at the top.)
 +[#0#10#33#100#108#114#111#119#32#44#111#108#108#101#72...............]
Category:Self-modifying
Category:Cell-based
Category:Stack-based
Category:Queue-based
Category:Languages
Category:Unimplemented
Braimproved

Braimproved is BF but improved.
==Commands==
Command	Description
> 	Moves the pointer right
< 	Moves the pointer left
+ 	Increments the cell at the pointer
- 	Decrements the cell at the pointer
, 	Asks for user input in ASCII character form and save its character code to the cell at the pointer
. 	Outputs the cell at the pointer as an ASCII character
? 	Asks for user input in numeric form and saves it to the cell at the pointer
! 	Outputs the cell at the pointer as a number
[ 	Goes to the corresponding ] if the cell at the pointer is 0
] 	Goes to the corresponding [ if the cell at the pointer is nonzero
( 	Goes to the corresponding ) if the cell at the pointer is nonzero
) 	Goes to the corresponding ( if the cell at the pointer is 0
O 	Gives you a donut
h 	Halts the program
==Examples==
===Cat===
====ASCII====
 +[,.]
====Numbers====
 +[?!]
===Hello World===
 ++++++++++[>++++++++++<-]>+>+++++++++[>++++++++<-]>.<<.>++++++++++++[<<+++++++++>>-]<<..>>+++++++++++[>>++++++++++<<-]>>+.>++++++++[>++++<-]>.+<<++++++++.--------.+++.
 <<<<.>-.>>>>>.
===Kiwiscript===
 ++++++++++[>+++++<-]>+++[<+>-]<[>++>++>++<<<-]>+>->+++++++++++++<<.>.>.<.
===Truth Machine===
 ?(!h)[!]
==Interpreter==
* Common Lisp implementation of the Braimproved programming language.
Category:LanguagesCategory:Brainfuck derivativesCategory:2023Category:Implemented
Brain--

Brain-- is created by User:H3h3h0h0, and is a superset of brainfuck.
==Method of operation==
Instead of the linear series of memory cells offered in regular BF, this language is built around a tree-based data structure. Each cell, while still acting the same way when accessed from outside, can itself become an array of cells. The following diagrams show the structuring in comparison to brainfuck:
brainfuck
 ... [ ] [ ] [ ] [ ] ...
brain--
 [ ] [ ] [ ] [ ] [ ] ...
 |-> [ ] [ ] ...
 |-> [ ] ...
The user is provided with a set amount of cells (3000 by default instead of 30000, due to the ability to create new cells as branches) at the start of execution, and they may choose to move the pointer freely between cells, as well as allocating and deallocating additional layers of cells (with the caveat that you cannot move into a 'leaf' cell or deallocate cells that do not exist). When none of the extra operators are used, it results in exactly the same operation as standard brainfuck. However, if they are used, it can result in analogues of data structures typically found in more complex languages, such as linked lists and binary trees. While this may seem like it improves usability at first, the limited additional syntax combined with more complex addressing arguably make this language more difficult to use to its full extent.
== Syntax ==
Besides the traditional <>+-[],. there are 4 other symbols:
 @: allocate an additional byte to the end of the current cell, in other words, create an additional branch on the currently pointed cell
 #: deallocate the last byte from the current cell (if available), in other words, remove the last branch on the currently pointed cell
 ?: "inwards" operator, placing the pointer on the first element inside the current cell (if available), in other words, move into and access the subtree rooted at the pointed cell
 !: "outwards" operator, placing the pointer on the encapsulating cell (if available), in other words, move to the parent of the current cell
== Computational class==
Due to the ability to allocate more memory by design (meaning it can act like an unbounded implementation of brainfuck), this language classifies as a Universal Turing Machine.
== External resources ==
Repo with interpreter (by User:H3h3h0h0): Github
Category:Languages Category:Implemented Category:Brainfuck derivatives Category:Cell-based
Brain-Flāk

Brain-Flāk is an esolang invented by User:None1 and derived from Brain-Flak. It uses Chinese characters as commands.
==Commands==
Brain-Flak uses 4 left brackets and 4 right brackets, but User:None1 realized that right brackets are only used to match left brackets, so we need only 1 kind of right bracket.
The Chinese characters have 5 tones: (no tone, - (1st tone), / (2nd tone), v (3rd tone), \ (4th tone) ), for example, the pinyin for the character 鸡 is jī, so its tone is 1st tone.
Many Chinese characters have multiple pronounciations, in Brain-Flāk, the "no tone" is prioritized, then the 1st-4th tones.
For example, in Chinese, the character 和 has these pronounciations: hé, hè, hú, huó, huò, huo, but this esolang chooses huo because it is no tone.
===Tones to Brain-Flak===
Tone 	Brain-Flak
no tone 	<
1st tone	right bracket
2nd tone	(
3rd tone	[
4th tone	{
Characters that don't have pinyin are ignored.
==Examples==
===A+B Problem===
 阳四阴四阴阴
==Translator to Brain-Flak==
===Python===
Requires the pypinyin package
from pypinyin import *
c=input()
p=pinyin(c,heteronym=True,errors='ignore',style=TONE2,neutral_tone_with_five=True)
r=''
for i in p:
 z=.join(i)
 if '5' in z:
 r+='<'
 elif '1' in z:
 r+='|'
 elif '2' in z:
 r+='('
 elif '3' in z:
 r+=']'
 else:
 r+='{'
st=[]
for i in r:
 if i!='|':
 st.append(i)
 print(end=i)
 else:
 print(end={'(':')','[':']','{':'}','<':'>'}[st.pop()])
Category:Languages
Category:CJK
Category:Turing complete
Category:2024
Category:Implemented
Brain4Ever

Brain4Ever is a Branflakes derivative created by User:LEOMOK. It was inspired by other Branflakes derivatives, as well as other programming languages.
== Instructions ==
The language operates on a tape of signed, unbounded integers, infinite on both sides, each initialized with 0. There is also a backup cell.
Some instructions require an argument, e.g. 12/ divides the current cell by 12. Use the raised minus ¯ to right a negative number.
If no argument is given, the value in the memory cell is used.
 Basic Arithmetic And Tape Manipulation
 : - Print cell value.
 . - Print cell value mod 65536 as Unicode character.
 ; - Input decimal number or arithmetic expression into cell.
 , - Input Unicode character into cell.
 " - Print the string going from here to the next unescaped ". Valid escape codes are \\ (backslash), \" (double quote) and \n (newline).
 n\ - Set the input/output base to n, e.g. 2\ will start printing numbers in binary. Error if over 36 or under 1
 n< - Move the pointer back by n.
 n> - Move the pointer forward by n.
 n# - Set current cell to n.
 ' - Set current cell to Unicode value of the character before.
 n+ - Add n to current cell.
 n- - Subtract n.
 n* - Multiply by n.
 n/ - Divide by n.
 n% - Modulo n.
 n^ - Raise to the power of n.
 n& - Bitwise and.
 n| - Bitwise or.
 n_ - Bitwise xor.
 ! - Bitwise not.
 n$ - Bitwise select. Taken from INTERCAL.
 n~ - Bitwise mingle. Also taken from INTERCAL.
 ¿ - Set to random integer between 0 and cell value.
 ( - Set backup cell to current cell.
 ) - Set current cell to backup cell.
 [ - Inserts a new cell before the current pointer, shifting all following cells to the right.
 ] - Removes the cell at the current pointer, shifting all following cells to the left.
 Control flow and functions
 { - Code block start.
 } - Code block end.
 ? - If cell != 0 then {codeblock} else {codeblock} (else is optional)
 @ - While cell != 0 do [codeblock]
 [A-Za-z] - If followed by codeblock, define functiom, else run function
 Multiverse time travel
Category:Languages
Category:Brainfuck derivatives
Brain:D

Brain:D is a Brainfuck derivative made by User: Areallycoolusername. It's made to make a person's life miserable.
Brainfuck 	Brain:D
+ 	D
- 	DD
> 	DDD
< 	DDDD
. 	DDDDD
, 	DDDDDD
[ 	DDDDDDD
] 	DDDDDDDD
No equivalent	:
As shown above, all the code is the same except for the fact that they've all become Ds. Another command has also been added, which just signifies the start of the program. The Brain:D syntax is as follows:
(Starting token)(Code tokens)
With that being said, a hello world program, one of the most tedious programs you'll ever make in this language, is shown below.
:D D D D D D D D DDDDDDD DDD D D D D DDDDDDD DDD D D DDD D D D DDD D D D DDD D DDDD DDDD DDDD DDDD DD DDDDDDDD DDD D DDD D DDD DD DDD DDD D DDDDDDD DDDD DDDDDDDD DDDD DD DDDDDDDD DDD DDD DDDDD DDD DD DD DD DDDDD D D D D D D D DDDDD DDDDD D D D DDDDD DDD DDD DDDDD DDDD DD DDDDD DDDD DDDDD D D D DDDDD DD DD DD DD DD DD DDDDD DD DD DD DD DD DD DD DD DDDDD DDD DDD D DDDDD DDD D D DDDDD
Spaces are ignored, but they're included for clarity.
If spaces weren't allowed, the program would look like:
:DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD
This hello world example was made in Python since coding it in actual Brain:D would take too long. Basically, Brain:D is meant to mess you up. The thing about this language is that in theory, you could type in a colon and as many Ds as you want, and there would be output.
Category: Cell-based
Category:Brainfuck derivatives
Category:2018
Category:Languages
Category:Unimplemented
Category:Uncomputable
BrainClub

BrainClub is a program language (invented by User:Zzo38) for compiling to client-brainfuck. The name is based on BrainSub (and a similar ideas) but "Cl" instead of "S" because it is "cl"ient-brainfuck.
There is a BrainClub compiler written in JavaScript and runs on XPC shell. Download at http://zzo38computer.org/brainclub/.
== Examples ==
This program allows you to type something, and it puts spaces in between the letters.
 ."Make space" CR
 0 BEGIN
 INPUT OUTPUT
 DUP 8 = IF
 DROP DROP
 THEN
 DUP 10 = IF
 DROP 0
 THEN
 DUP WHILE REPEAT
 ."OK: "
 DROP REWIND
 ITERATE EMIT 32 OUTPUT NEXT
 CR
This code is a hangman game:
 \---------------------------\
 \ Hangman game in BrainClub \
 \---------------------------\
 
 \ Subroutines
 : UPPERCASE DUP 96 > IF 32 - THEN ;
 : YOUWIN 1EMPH ."You win!" BEGIN {,} AGAIN ;
 : YOULOSE CR 1EMPH ."You lose!" BEGIN {,} AGAIN ;
 
 \ Declare variables
 ( LIVES 1 )VAR
 ( LETTER 1 )VAR
 ( CORRECTLETTER 1 )VAR
 ( BLANKS 1 )VAR
 ( WORDLENGTH 1 )VAR
 ( DISPLAYWORD 36 )VAR
 ( WORD 36 )VAR
 
 \ Initialize some variables
 7 ( ! )LIVES
 
 \ Read word to play game with
 BEGIN
 ( 1+ )WORDLENGTH
 INPUT DUP
 ( @ )WORDLENGTH INDEX ( ! )WORD ?"." ( ! )DISPLAYWORD OUTDEX
 ?"!" =
 UNTIL
 ( 1- @ )WORDLENGTH ( ! )BLANKS
 
 \ Main game loop
 BEGIN
 CLS 1EMPH ." HANGMAN! " 0EMPH CR
 ." <"
 ( ZERO )BLANKS
 0 BEGIN
 1+
 DUP INDEX ( OUTPUT @ )DISPLAYWORD OUTDEX
 ?"." = IF ( 1+ )BLANKS THEN
 DUP ( @ )WORDLENGTH =
 UNTIL DROP
 .">" CR
 ."Lives: " ( @ )LIVES ?"0" + EMIT CR
 ( @ )BLANKS 0= IF YOUWIN THEN
 ."Guess a letter: " INPUT UPPERCASE OUTPUT
 ( ZERO )CORRECTLETTER
 0 BEGIN
 1+
 DUP INDEX ( @ )WORD OUTDEX
 ( 2 )PICK = IF
 2DUP INDEX ( ! )DISPLAYWORD OUTDEX
 ( 1+ )CORRECTLETTER ( 1- )BLANKS
 THEN
 DUP ( @ )WORDLENGTH =
 UNTIL DROP DROP
 ( @ )CORRECTLETTER 0= IF
 ( 1- @ )LIVES 0= IF YOULOSE THEN
 THEN
 AGAIN
==External resources==
* http://zzo38computer.org/brainclub/ BrainClub compiler
Category:Compilers
Category:Languages
Category:Brainfuck derivatives
Category:2009
Category:Implemented
Category:High-level
BrainCrash

BrainCrash is a Brainfuck derivative language designed by ぬこ, published in 2008. The purpose of the language is to make a "Hello, world!" program with zero-byte file.
== Features ==
In addition to original 8 instructions, this language has 4 bitwise logical operation instructions and a special behaviour, which is executed when the program begins and ends.
=== Extended Instructions ===
Instructions	Descriptions
 	OR operation: Performs a bitwise OR operation on the byte at the pointer and the byte in storage, storing its result in the byte at the pointer. The pointer gets incremented.
& 	AND operation: Performs a bitwise AND operation on the byte at the pointer and the byte in storage, storing its result in the byte at the pointer. The pointer gets incremented.
~ 	NOT operation: Performs a bitwise NOT operation on the byte at the pointer.
^ 	XOR operation: Performs a bitwise XOR operation on the byte at the pointer and the byte in storage, storing its result in the byte at the pointer. The pointer gets incremented.
=== Special Behaviours ===
*The first 13 memory cells are initialized with 72, 101, 108, 108, 111, 44, 32, 119, 111, 114, 108, 100, and 33 ("Hello, world!" in ASCII, without LF-termination) respectively. In other words, the following code is inserted to your beginning of program:
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>
++++++++++++++++++++++++++++++++++++++++++++>
++++++++++++++++++++++++++++++++>
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>
+++++++++++++++++++++++++++++++++>
<<<<<<<<<<<<<
*When the program ends, the pointer keeps being incremented until the value at the pointer is zero, outputting the currently pointed-to value. In other words, the interpreter automatically appends [.>] to your program.
== Examples ==
;File
:(empty)
;Output
:Hello, world!
;File
:|
;Output
:mllo, world!
== External resources ==
*
**
**
;Other implementations
*BaseOutside/braincrash - in C++.
Category:Languages
Category:Brainfuck derivatives
Category:2008
Category:Turing complete
Category:Turing tarpits
Category:Low-level
Category:Implemented