The _BIT datatype can return only values of 0 (bit off) and 1 (bit on).
Syntax
_DEFINE Letter[Range ,…] AS [_UNSIGNED] _BIT [* numberofbits]
Description
 An _UNSIGNED _BIT can hold 0 or 1 instead of 0 and 1, if you set the numberofbits you can hold larger values depending on the number of bits you have set (_BIT * 8 can hold the same values as _BYTE for example) and the information below is compromised if setting any number of bits other than 1.
 If you set the variable to any other number then the least significant bit of that number will be set as the variables number, if the bit is 1 (on) then the variable will be 1 and if the bit is 0 (off) then the variable will be 0.
 The least significant bit is the last bit on a string of bits (11111) since that bit will only add 1 to the value if set. The most significant bit is the first bit on a string of bits and changes the value more dramatically (significantly) if set on or off.
 The _BIT datatype can be succesfully used as a Boolean (TRUE or FALSE) and it requires minimal amount of memory (the lowest amount possible actually, one byte can hold 8 bits, if you want to use bits in order to decrease memory usage, use them as arrays as a _BIT variable by itself allocates 4 bytes  DIM bitarray(800) AS _BIT uses 100 bytes).
 When a variable has not been assigned or has no type suffix, the value defaults to SINGLE.
 Keywords_currently_not_supported_by_QB64 Use a _BYTE and assign up to 8 bit values as shown below.
Use a _BYTE and assign up to 8 bit values as shown below.
*Suffix Symbols The _BIT type suffix used is below the grave accent (`), usually located under the tilde (~) key (not an apostrophe). Foreign keyboards may not have the ` key. Try Alt+96 in the IDE.
You can define a bit onthefly by adding a ` after the variable, like this:
variable\
= 1`
If you want an unsigned bit you can define it onthefly by adding ~` instead, like this:
variable~\
= 1`
You can set the number of bits on the fly by just adding that number  this defines it as being two bits:
variable\
2 = 1`

The MSB is the most significant(largest) bit value and LSB is the least significant bit of a binary or register memory address value. The order in which the bits are read determines the binary or decimal byte value. There are two common ways to read a byte:
 “Bigendian”: MSB is the first bit encountered, decreasing to the LSB as the last bit by position, memory address or time.
 “Littleendian”: LSB is the first bit encountered, increasing to the MSB as the last bit by position, memory address or time.
**Offset or Position: 0 1 2 3 4 5 6 7 Example: 11110000**
 
**BigEndian Bit On Value:** 128 64 32 16 8 4 2 1 240
**LittleEndian Bit On Value:** 1 2 4 8 16 32 64 128 15
The bigendian method compares exponents of 2^{7} down to 2^{0} while the littleendian method does the opposite.
 INTEGER values consist of 2 bytes called the HI and LO bytes. Anytime that the number of binary digits is a multiple of 16 (2bytes, 4 bytes, etc.) and the HI byte’s MSB is on(1), the value returned will be negative. Even with SINGLE or DOUBLE values!
**16 BIT INTEGER OR REGISTER**
**AH (High Byte Bits) AL (Low Byte Bits)**
BIT: 15 14 13 12 11 10 9 8  7 6 5 4 3 2 1 0

HEX: 8000 4000 2000 1000 800 400 200 100  80 40 20 10 8 4 2 1

DEC: 32768 16384 8192 4096 2048 1024 512 256  128 64 32 16 8 4 2 1
The HI byte’s MSB is often called the sign bit! When all 16 of the integer binary bits are on, the decimal return is 1.
Example(s)
Shifting bits in a value in QB64 versions prior to 1.3 (you can use _SHL and _SHR starting with version 1.3).
n = 24
Shift = 3
PRINT LShift(n, Shift)
PRINT RShift(n, Shift)
END
FUNCTION LShift&(n AS LONG, LS AS LONG)
IF LS < 0 THEN EXIT FUNCTION
LShift = INT(n * (2 ^ LS))
END FUNCTION
FUNCTION RShift&(n AS LONG, RS AS LONG)
IF RS < 0 THEN EXIT FUNCTION
RShift = INT(n / (2 ^ RS))
END FUNCTION
192
3