nyuuzyou/wikis huggingface dataset:
BitCode/PicCode

Bitcode is an image programming language.
It uses pixels in an image as characters for code, unlocking the ability to use a normal image, like one of a sunset, as code.
With advanced programs you might even end up with a rainbow!
The "bit" in "bitcode" comes from "bitmap", since the interpreter uses a bitmap version of the image to read the image's pixels.
A nickname/second name for it is "piccode" because programs in it are pictures. The "pic" comes from "picture".
Bitcode will have decent error handling faster than I even started on error handling for NScript since it's way easier to tell the user where the error occurred.
== The system ==
The idea of the system is that the red value of the color represents a "channel".
For example, characters use channel 1, builtin methods use 2, variables use 3, user-defined methods use 4
The system is basically [channel,arg1,arg2] or [channel,arg,sub-arg] 
Using this method, 255 different channels can be made.. more than enough.
I chose the [channel,arg,sub-arg] system because it makes the programming lang easy to learn&use.
Image langs are virtually infinitely expandable, with over 16M different color combinations possible, so you'll never run out of commands.
Unicode has 143,859 characters, a tiny fraction of how many is possible.
Because of the [channel,arg,sub-arg] system and the way characters are used in it, only 255 characters are actually possible.
Soon this will be changed by having different "scripts"/"alphabets", though only 65k characters are possible even with 255 alphabets to chose from.
== Usage ==
Characters will use Red-1, Green-charnum, Blue-capital (1 = capital, 0 = lowercase)
Example: [1,3,1] - C / [1,7,0] - g / [1,30,0] - 3 
Builtin methods will use Red-2, Green-methodnum, Blue-arg
The characters are: "abcdefghijklmnopqrstuvwxyz 1234567890~!@#$%^&*()_+=-`{}[]\\|:;\"'<>,.?/"
a is 1, b is 2, c is 3, and so on..
a space is 27.
Quotation marks are not listed but are [1,0,0].
Quotation marks are not listed because they represent a print() statement event without any special "initializers" to tell the interpreter if its as an argument or something else.
Numbers are not possible yet.
Comments are impossible.
Hello world:
https://imgur.com/a/3slP761
== Reading it ==
Reading it easily requires an editor for ONLY bitcode,
Category:Languages Category:Non-textual
BitFlip

BitFlip is a language by User:Zzo38.
There are an unlimited number of variables that can store 1 bit each, and they can be named using numbers, letters, and the symbols -+_~'.
==Commands==
 .var = Toggle value of var
 ?name = Go to the first ?name that matches this one and is constant
 [var commands] = Loop while var is set
 ^name = Call subroutine at label ?name if it exists
 % = Return from subroutine or stop program if not in one
 & = Forget one entry from call stack
Pre-processor commands:
 !name{commands} = Define a macro (name cannot include _ and ~)
 ,macro{parameters} = Run macro (parameters are separated by semicolons)
 $number = When you run the macro, $1 is replaced by the first parameter, $2 by the second parameter, etc.
 @number{parameter} = Repeat parameter number times
 /*comment*/ = Comment
Expressions:
 (var) = Returns _ if var is unset, ~ if var is set
 <name> = Calls an external function and returns one bit, _ or ~
 #_ = Returns ~
 #~ = Returns _
 #char = If char isn't _ or ~ then returns value of var called char
External functions for I/O:
 <IN> = Input a bit
 <OUT~> = Output 1, return 1
 <OUT_> = Output 0, return 0
==Examples==
Copy input to output, forever (infinite cat program):
 .1[1.<OUT<IN>>]
Display all characters 0 to 255:
 !x{?_$1.$1^#$1$2%}!O{.<OUT#$1>}
 .z[z,O{7},O{6},O{5},O{4}
 ,O{3},O{2},O{1},O{0}^_0]
 ,x{0;1},x{1;2},x{2;3},x{3;4}
 ,x{4;5},x{5;6},x{6;7},x{7;x}
 ?_x@8{&}%
Nested macros:
 !create{!$1A{.$1$$1}!$1B{,$1$$1A{$$2}}}
 ,create{First}
 ,create{FirstSecond}
 ,FirstA{B}
 ,FirstB{Second;C}
 /* Now these bits are set: FirstB FirstSecondC */
==Compuational class==
It is Turing-complete, because it is postible to translate every Smallfuck program to it
==See also==
Other languages operating on bits (implemented only):
* BIT
* BoolX
* Bitch
* Boolfuck
* BitChanger
* Bitter
* Boolet
* BitBitJump
* FlipJump
* Smallfuck
Category:Languages
Category:2006
Category:Turing complete
Category:Unimplemented
BitP

BitP is an estoteric programming language (who would've guessed!) that uses 16 commands, stored as nybbles. It was originally intended as a more readable assembly language, but, uh... it's here now, so you can guess what it has become.
==Notes==
All programs in BitP are compiled down to nybbles before running. These nybbles are themselves interpreted. This means that comments are not ignored, but removed. This is important.
The only data type is a single 8-length 64-bit stack, called a 'disc' (because it loops around).
Everything is 0-indexed, even when it doesn't make sense to 0-index it. Also, everything is in hex.
Though each command has a single character associated with it that the compiler will recognize, using its hex code will also work. However, values A-F hex must be capitalized.
Also, programs are self-modifying. It is possible to edit the program itself. While this can lead to very bizarre or compact programs (in theory), its main use is mundane; since the disc is useless for long-term storage, often times the best place to put them is in unused space within the program.
==Command List==
BIN 	HEX	Character	Name 	Description
0000	0 	# 	VALUE 	Gets the value of the next function and puts it on the disc, left shifting the previous value by 4.
0001	1 	, 	NEXT 	Moves the pointer to the next value in the disc.
0010	2 	{ 	REMEMBER	Remembers the previous disc value as the location of a bit in the program, and current disc value as the number of bits after that one to also edit.
0011	3 	 	 	
==External links==
GitGud Repository for compiler-interpreter
Category:Languages
Category:Implemented
BitQueue

BitQueue is a language created by DivergentClouds.
== Overview ==
In BitQueue data is operated on in the form of a queue of individual bits. Any operation that looks at the queue must dequeue whatever it views. The commands are:
 Commands
Command	Description
1 	Enqueue 1
0 	Enqueue 0
> 	Call the function with the name that follows
< 	Return from current function
^ 	Return from current function and then jump to the start of the calling function
* 	Return from current function and the calling function
" 	Call the currently running function
: 	Define a function with the name that follows and the body being the next command or block
' 	Create and call an anonymous function with the body being the next command or block
? 	Dequeue a bit, if it is 0, then skip the next command or block
( 	Start a block
) 	End the block starting with the matching '('
, 	Enqueue the next 8 bits of input, if no input is available, then nothing is enqueued
. 	Dequeue 8 bits and send them to the output
# 	Print the queue state as a series of 1s and 0s followed by a newline
; 	Start a comment that lasts until the end of the line
=== Notes ===
* Named functions may only be created at the top level (not within a function, conditional or block).
* Function names are of the form /[A-Za-z_][A-Za-z0-9_]*/ and may not conflict.
* Calling a non-existent function is not allowed.
* Function definitions may be out of order.
* When the end of a function is reached, then the function implicitly returns.
* When a command or block is expected then it must be given.
* Returning when not inside a function halts.
* Dequeuing from an empty queue halts.
* Reaching the end of the file halts.
* If a single command is given when a command or block is expected, then any arguments it takes are included as well.
* . dequeues and outputs bits in the order they were given. For example, 01000001. will output A (assuming the output is displayed as ASCII).
* , enqueues the inputted bits such that the high-order bit is enqueued first. For example, ,. will output the same byte that was inputted (assuming an empty queue).
== Computational class ==
BitQueue is Turing complete as it can simulate Bitwise Cyclic Tag. For details see bitwise-cyclic-tag.bq in the official implementation's GitHub repo.
== Implementations ==
* Interpreter in Zig by DivergentClouds
** Official implimentation
* Interpreter in Haskell by Reconcyl
** Does not support * or #
* Interpreter in C++ by MoshiKoi
** Does not support *, # or out of order definitions
Category:Languages Category:2022 Category:Queue-based Category:Turing_complete Category:Implemented
BitShift

BitShift was created by user:Bas to reminisce the old days, when computers only understood zeroes and ones.
==Language overview==
A BitShift program only knows of 2 valid instructions, 0 and 1. Other characters are invalid and will thus throw an error on execution. Instructions are interpreted as alternating 0's and 1's. Whenever 2 of the same instructions are entered, the program will count the alternating instructions preceding it and perform a command. It doesn't matter if you start your program with a 0 or a 1.
0101011010011101011 will perform the instructions 6, 4, 2, 1, 5, 1
010101 1010 01 1 10101 1. Here, the non alternating characters have been seperated by a space for improved readability.
BitShift programs don't have any stack operations or loops. They have one single value which can be altered.
This value can range from 0-255 (0000 0000 - 1111 1111)
==Instructions==
BitShift supports the following instructions:
Alternations	Description
1 	Shift the value 1 bit to the left (0000 0001 > 0000 0010)
2 	Shift the value 1 bit to the right (0000 0010 > 0000 0001)
3 	XOR the value with 1 (0000 0000 > 0000 0001)
4 	XOR the value with 128 (0000 0000 > 1000 0000)
5 	Set the value to 0
6 	Convert the value to an ASCII character and print it
7 	Read an ASCII character from user input and set the value to it
==Examples==
===Hello, World!===
 0100000100000101011010011011010100110100110100110101001010110010001001010111100110011110101001000000010101101111011110111011101101010001000101100101011111011101001010110111101110111101010001000010101111101101010
===Cat===
 0101010010101
==Implementations==
The simplistic nature of BitShift is reflected in the following implementation in Common Lisp:
 (defun interpret-BitShift (code)
 "Interprets the BitShift CODE and returns ``NIL."
 (declare (type string code))
 (let ((value 0)
 (alternations 0))
 (declare (type (unsigned-byte 8) value) (type (integer 0 *) alternations))
 (flet ((execute-command ()
 (case alternations
 (1 (setf value (ldb (byte 8 0) (ash value 1))))
 (2 (setf value (ldb (byte 8 0) (ash value -1))))
 (3 (setf value (logxor value 1)))
 (4 (setf value (logxor value 128)))
 (5 (setf value 0))
 (6 (write-char (code-char value)))
 (7 (format T "~&Please input a character: ")
 (setf value (char-code (read-char)))
 (clear-input))
 (T (error "Invalid alternations: ~d." alternations)))))
 (loop
 for previous-bit of-type (or null character) = NIL then current-bit
 for current-bit of-type (or null character) across code
 for position of-type fixnum from 0
 do (cond
 ((not (member current-bit '(#\0 #\1) :test #'char=))
 (error "Not a bit at position ~d: ~s." position current-bit))
 ((null previous-bit)
 (incf alternations))
 ((char/= previous-bit current-bit)
 (incf alternations))
 (T
 (execute-command)
 (setf alternations 1)))
 finally (execute-command)))))
==Interpreter==
* 
* Common Lisp implementation of the BitShift programming language.
Category:Finite state automata 
Category:Low-level 
Category:Implemented 
Category:Languages
Category:2015
BitSwitch

BitSwitch is an esolang made by User:Bloodyknucles.
==Commands==
Here is a table of the commands in BitSwitch:
Name	Function
0-1 	Outputs the other digit
b 	Outputs Itself (Requires Immediately Previous Binary Digit)
==Interpreter in Python 3==
 import sys
 while True:
 cmd = input("bitswitch > ")
 if cmd in DIGITS: print(int(not(int(cmd))))
 elif 'b' in cmd: print(cmd)
 else: print('Syntax Error')
== External links ==
* Tynker Project
==See also==
Other languages operating on bits (implemented only):
* FlipJump
* BIT
* BoolX
* Bitch
* Boolfuck
* BitChanger
* Bitter
* Boolet
* BitBitJump
* Smallfuck
Category:Languages Category:Implemented Category:Total Category:Unusable for programming Category:2020 Category:Output only Category:Low-level
BitTurn

BitTurn is an esolang that operates on a 2D bitmap. The pointer can read/write the bits on the map and move.
==Commands==
Command	Meaning
T 	Flip the current bit pointing and move forward.
A 	Move backward.
G 	Rotate counterclockwise.
[ 	If the current bit is 0, go to the matching ].
] 	If the current bit is not 0, go to the matching [.
Bit Stupid

Bit Stupid is an esoteric programming language by User:A.
,	inputs the register.
.	outputs a variable.
:	starts a do...while loop with register==1. Runs the rest of the line.
==Examples==
===Truth-machine===
 ,:.
===Hello, world! (Unary)===
 .[5735816763073854953388147237921]
.[n] means . repeated n times.
==Implementation==
An implementation by AmNow can be found here.
Category:LanguagesCategory:ImplementedCategory:Unusable for programmingCategory:Low-level
Bit bucket

A bit bucket is a general term for a data structure that would be capable of storing data, or that at least implements an API to allow data to be written to it – but which is never read, only written to. While mostly useless in regular programming, bit buckets are occasionally useful when programming in esoteric programming languages, with two primary uses having been seen.
One of the main uses for bit buckets is as a method of implementing control flow in languages that do not have fully-featured control flow of their own (or where the control flow is avoided where possible due to being excessively awkward to use), in languages which have some sort of equivalent to a reference that is capable of referencing multiple different variables or structures. The idea is to conditionally skip over parts of code by doing all the writing in those parts indirectly via a reference, changing the reference to point to useful memory if the code is supposed to be run, or to point to a bit bucket if the code is supposed to be skipped; although the code runs regardless, any writes it makes if it's supposed to be skipped will be written somewhere that is never read, and thus may as well not have happened. In order for this to work, the bit bucket needs to match the API of the data structure it's replacing exactly. For example, in the I/D machine Turing-completeness proof, there are two queues: the data queue that stores data, and a bit bucket that exists simply to have somewhere to put unwanted data. (The I/D machine does not have control flow which would enable the commands that normally push data to the data queue to be skipped, and thus the bit bucket is used to allow those commands to run to no effect.) This technique has also been observed in INTERCAL programming, where performing useless writes is often easier than conditionally skipping blocks of code.
The other major use of bit buckets is when writing in reversible programming languages, especially when compiling into them from non-reversible programming languages: the problem is that a reversible program can be run in reverse in order to reconstruct its entire history of execution, and that in turn means that the data stored by the program needs to be sufficient to do that reconstruction of history. However, the program often doesn't care about its own execution history, being written to execute the same way regardless of the history. As such, it is common to use bit buckets to store the information needed to reconstruct the execution history; the bit buckets are write-only while executing the program normally, because the data stored there isn't supposed to impact the program execution in any way, but allow the data to be "reverse-written" (i.e. read) when the program is run in reverse. In most cases, compiling from an irreversible programming language into a similar reversible language is primarily a matter of implementing a bit bucket and using it to store the information needed to reverse the irreversible operations of the original language.
Category:Concepts
Bitcoin

Bitcoin is a brainfuck-derivative joke language, where you can only increment or decrement the pointer by the current price of bitcoin.
== Commands ==
 sell : increment the pointer by the cost of bitcoin.
 buy : decrement the pointer by the cost of bitcoin.
 next : move the pointer to the right once.
 prev : move the pointer to the left once.
 start : begin a loop.
 end : end a loop.
 brag : brags (outputs) the current amount of money you have in bitcoin as an ASCII char.
 beg : begs for any amount of money in bitcoin.
== Examples ==
"Hello World!" (Assumes the price of bitcoin is currently $1.00 USD):
 sell
 start
 sell
 start
 prev prev
 start
 sell
 start
 buy buy buy
 end
 buy
 start
 prev prev prev
 end
 end
 end
 next next next
 sell
 end
 next
 buy
 brag
 buy buy buy
 brag
 next
 brag brag
 next
 brag
 prev prev prev prev
 buy
 brag
 prev
 sell
 brag
 next next next next next
 brag
 next
 brag
 prev prev
 brag
 prev
 buy
 brag
Cat program (Assumes the price of bitcoin is currently $1.00 USD):
 sell
 start
 	beg
 	brag
 end
== Compiler ==
compiler in slashes (by User:Yes) (compiles to bf)
Category:Joke languages Category:Unusable for programming Category:Implemented Category:Turing complete Category:Brainfuck derivatives Category:Languages
Bitdeque

Bitdeque is an esoteric programming language created by User:Nobody in 2019. It operates on a deque of bits and a register. 
== Overview ==
Bitdeque operates on a deque of bits and a register. When the program starts, the deque is empty and the value in the register is 0. There is (currently) no I/O.
== Instructions ==
Bitdeque has 6 instructions:
* PUSH: Push the bit in the register to the right side of the deque (Does not change the bit in the register)
* INJECT: Push the bit in the register to the left side of the deque (Does not change the bit in the register)
* EJECT: Pop the bit from the left side of the deque to the register (This removes the bit on the left. The register becomes 0 if the deque is empty)
* POP: Pop the bit from the right side of the deque to the register (This removes the bit on the right. The register becomes 0 if the deque is empty)
* INVERT: Invert the bit in the register
* GOTO: Take a number N (specified in the program) and go to the Nth operation in the program if the bit in the register is 1
== Examples ==
===Hello, world!===
The following example stores the binary ASCII values of each character in 'Hello, world!' in the deque:
 [H] 100 1000: INVERT PUSH INVERT PUSH PUSH INVERT PUSH INVERT PUSH PUSH PUSH
 [e] 110 0101: INVERT PUSH PUSH INVERT PUSH PUSH INVERT PUSH INVERT PUSH INVERT PUSH
 [l] 110 1100: PUSH PUSH INVERT PUSH INVERT PUSH PUSH INVERT PUSH PUSH
 [l] 110 1100: INVERT PUSH PUSH INVERT PUSH INVERT PUSH PUSH INVERT PUSH PUSH
 [o] 110 1111: INVERT PUSH PUSH INVERT PUSH INVERT PUSH PUSH PUSH PUSH
 [,] 010 1100: INVERT PUSH INVERT PUSH INVERT PUSH INVERT PUSH PUSH INVERT PUSH PUSH
 [ ] 010 0000: PUSH INVERT PUSH INVERT PUSH PUSH PUSH PUSH PUSH
 [w] 111 0111: INVERT PUSH PUSH PUSH INVERT PUSH INVERT PUSH PUSH PUSH
 [o] 110 1111: PUSH PUSH INVERT PUSH INVERT PUSH PUSH PUSH PUSH
 [r] 111 0010: PUSH PUSH PUSH INVERT PUSH PUSH INVERT PUSH INVERT PUSH
 [l] 110 1100: INVERT PUSH PUSH INVERT PUSH INVERT PUSH PUSH INVERT PUSH PUSH
 [d] 110 0100: INVERT PUSH PUSH INVERT PUSH PUSH INVERT PUSH INVERT PUSH PUSH
 [!] 010 0001: PUSH INVERT PUSH INVERT PUSH PUSH PUSH PUSH INVERT PUSH
== Implementation ==
* A Python interpreter by User:Bangyen.
* User:Nobody is also currently writing an interpreter for this.
== Computational class ==
According to User:Camto, Bitdeque is Turing-complete, because with a 0 in the middle and 1's on the left and right, one can simulate a Minsky machine with 2 registers, which is Turing-complete.
Category:Languages Category:Turing complete Category:Deque-based Category:Turing tarpits Category:No IO Category:Implemented
Bite bytes

bite bytes is a esolang that can interpret n byte programs easily.
== commands ==
 p? - prints ? (or variable if b)
 q?! - prints ? (or variable if b) shifted by ! ascii characters
 a? - saves to variable
 i - saves input to variable
 b - reference variable
 e - executes variable as python
 g - goto last p if var is 1
 G - goto last p if var is not blank
 v - evaluates variable as python
 N - interpret ℵ₀ Bytes ^_^
== examples ==
notice: negative bytes are not included here because uninterpretable smh
=== 0 bytes XD ===
 iprg
=== ¼ bytes :3 ===
 p1p1ipbipbipbipbipbipb
=== 1⅞ bytes :3 ===
 iqb3
=== 2 bytes :^) ===
 ipb
=== 2 bytes B) ===
 ipb
=== 3 bytes :v) ===
 iq`1
=== 6 bytes of useless element ===
 iafpbiG
=== 7 bytes XD ===
 i
=== 9 bytes :I ===
 i
=== 13 bytes :D ===
 iv
=== 16 bytes :P ===
 ipb
=== 25 bytes o: ===
 ipb
=== ℵ₀ Bytes ^_^ ===
 N
Category:Languages Category:Joke languages Category:2024 Category:Unimplemented Category:Turing complete
Bitflipper

Bitflipper is a basic esoteric programming language created on March 23, 2022 by User:gapples2 where you flip bits.
This only has 5 instructions which makes programming in this hard and long.
==Instructions==
Instruction	Effect
FLIP X 	Flip bit X.
SKIP X 	Skip the next line if bit X is 1.
JUMP X 	Jump to line X.
OTPT X 	Output an ASCII character where the byte starts at X.
INPT X 	Set the byte starting at X to the ASCII value of an input character.
# 	Comments out the rest of the line.
Negative values of X enter the source code, making it possible to edit the code while it's running.
==Sample programs==
===Cat program===
 INPT 0
 OTPT 0
 JUMP 0
===Cat Program that terminates on null byte===
 FLIP 0 #forced skip
 INPT 1
 #0xxxxxxx
 SKIP 1
 SKIP 0
 JUMP 33
 #00xxxxxx
 SKIP 2
 SKIP 0
 JUMP 33
 #000xxxxx
 SKIP 3
 SKIP 0
 JUMP 33
 #0000xxxx
 SKIP 4
 SKIP 0
 JUMP 33
 #00000xxx
 SKIP 5
 SKIP 0
 JUMP 33
 #000000xx
 SKIP 6
 SKIP 0
 JUMP 33
 #0000000x
 SKIP 7
 SKIP 0
 JUMP 33
 #00000000 - input is a null byte
 SKIP 8
 JUMP -1 #end execution if null
 OTPT 1
 JUMP 1 #loop
===Hello, World!===
 # H - 01001000
 FLIP 1
 FLIP 4
 OTPT 0
 # e - 01100101
 FLIP 2
 FLIP 4
 FLIP 5
 FLIP 7
 OTPT 0
 # l - 01101100
 FLIP 4
 FLIP 7
 OTPT 0
 OTPT 0
 # o - 01101111
 FLIP 6
 FLIP 7
 OTPT 0
 # , - 00101100
 FLIP 10
 FLIP 12
 FLIP 13
 OTPT 8
 # <space> - 00100000
 FLIP 18
 OTPT 16
 # W - 01010111
 FLIP 2
 FLIP 3
 FLIP 4
 OTPT 0
 # o - 01101111
 FLIP 2
 FLIP 3
 FLIP 4
 OTPT 0
 # r - 01110010
 FLIP 3
 FLIP 4
 FLIP 5
 FLIP 7
 OTPT 0
 # l - 01101100
 FLIP 3
 FLIP 4
 FLIP 5
 FLIP 6
 OTPT 0
 # d - 01100100
 FLIP 4
 OTPT 0
 # ! - 00100001
 FLIP 23
 OTPT 16
===Truth Machine===
 FLIP 0 #guarentee a skip
 INPT 1 #get input
 
 #test for 0011000x
 #0xxxxxxx
 SKIP 1
 SKIP 0
 JUMP -1
 #00xxxxxx
 SKIP 2
 SKIP 0
 JUMP -1
 #001xxxxx
 SKIP 3
 JUMP -1
 #0011xxxx
 SKIP 4
 JUMP -1
 #00110xxx
 SKIP 5
 SKIP 0
 JUMP -1
 #001100xx
 SKIP 6
 SKIP 0
 JUMP -1
 #0011000x
 SKIP 7
 SKIP 0
 JUMP -1
 
 OTPT 1 #output
 
 #repeat if 1
 SKIP 8
 JUMP -1
 
 OTPT 1
 JUMP 43
===Interpreters===
An interpreter (here) has been written in javascript by User:dtp09, with the exceptions that you cannot modify the source code, because there was not enough info given here for me to know how to interpret it properly, and the other exception being that jumping to -1 will end execution for convenience. It is best to write the program somewhere that can number the lines, then paste to the website.
An interpreter is also being created in C++ by User:gapples2.
Category:Languages
Category:Low-level
Category:Turing complete
Category:Self-modifying
Category:Implemented