nyuuzyou/wikis huggingface dataset:
Snake Script

Snake Script is a language created by Dylan Turner aka BlueOkiris (talk) 16:24, 11 September 2020 (UTC)
== Description ==
The goal was to make a language that fits nicely in a traditional terminal. In other words and 80x25 character display. It achieves this goal by only allowing one to have programs whose lines are 80 characters wide and 'snake,' programming backwards on every other line. One example that shows this 'snaking' is the 99-bottles of beer on the wall program:
 \brwl:#>[@]{$' bottles of beer on the wall.\n'++<<}\br:#>[@]{$ 
 '.reeb fo selttob 99n\.llaw eht no reeb fo selttob 99'}<<++'n\.reeb fo selttob '
 '\nTake one down pass it around.\n'++. 98i=i2?>[?]{i1-i=i(brwl)['\n']++i(brwl)++
 '.llaw eht no reeb fo elttob 1'}>?2i.++'n\.dnuora ti ssap nwod eno ekaT' ++)rb(i
 '\n\n'++'1 bottle of beer on the wall.\n1 bottle of beer.\n'++ 
 .++'n\.llaw eht no reeb fo selttob erom oNn\.dnuora ti ssap nwod eno ekaT'
Beyond the snaking feature, the language is statically typed, stack-based, and supports functions, while loops, dynamically-size arrays (lists), and tuples. The language is not only supposed to fit 80x25 displays, but is also designed to be usable as a programming language.
Because this site does not use markdown, the github site for the compiler/vm is LOCATED HERE.
On that site, the README explains how to program in snake-script, so I won't show that here. Essentially, it walks through the data types, function definitions, and while loops, and then provides a table of all instruction statements and their description.
== Examples ==
99-bottles program:
 \brwl:#>[@]{$' bottles of beer on the wall.\n'++<<}\br:#>[@]{$ 
 '.reeb fo selttob 99n\.llaw eht no reeb fo selttob 99'}<<++'n\.reeb fo selttob '
 '\nTake one down pass it around.\n'++. 98i=i2?>[?]{i1-i=i(brwl)['\n']++i(brwl)++
 '.llaw eht no reeb fo elttob 1'}>?2i.++'n\.dnuora ti ssap nwod eno ekaT' ++)rb(i
 '\n\n'++'1 bottle of beer on the wall.\n1 bottle of beer.\n'++ 
 .++'n\.llaw eht no reeb fo selttob erom oNn\.dnuora ti ssap nwod eno ekaT'
Factorial program (with spaces for clarity):
 \fac : # > # { 
 
 >< 
 
 1?= [?] { << } 
 
 >< 1-(fac)* 
 
 << 
 
 } 
 
 ,!?(fac). 
 
 '\n'.
Hello world:
 'Hello, world!\n'. 
Truth-machine:
 ,!?><1?=[?]{><.><1?=}.'\n'.
Program to test List functionality:
 [[(0'Hi')(1'Bye')(2'wut')][(4'Hi')(5'Bye')(6'wut')]] 
 
 [ 0 1 2 3 4 5 6 ]><><.'\n'. 4--][[].'\n'. 2@@.'\n'..'\n'. 
The above program is interesting because it shows and extremely complex data type that can be created in the language. It's a list of lists of tuples of numbers and lists of characters (strings)
Category:Languages
Category:2020
Category:Implemented
Snakel

Snakel is an alternative universe version of Python created in 1989 by Tolly Edd in the gammaline universe
==Compatibility methods==
Snakel can't suport EVERY operating system due to some issues by either with hardware or by something else. This page tells the ways to make Snakel compatible with your OS (Like Ultium)
===Computers===
====Ultium====
Method 	Disk system hardware 	"New" hardware 	Moddern hardware
Official Snakel add-on 	Yes, but in Ultium 2.0 to Ultium 3.0 	No, since thoss Ultium computers don't have add-on slots	No, since thoss Ultium computers don't have add-on slots
Using a coding extension of Snakel 	No 	Yes 	Yes
Using the "Beginner-Friendly Programming Tool"	No 	Somewhat stable 	Yes
Using the codefree.com/recodefree.com website 	Yes but only in Ultium 2.0 to 3.0 since they contain the internet feature	Yes 	Yes
==Syntax==
Every program starts with a definition, to actually define a function, you can do this:
translated into python:
 def name(arguments):...
 def name():...
I/O in Snakel also exist:
translated into python:
 print("""anything here""")
 input()
By the way. The strings are actually multi-liners so:
translated into python:
 print("""multi
 line""")
Now let's talk about the "ignore" and "end".
translated into python:
 try:1/0
 except:print("""inf""")
 exit()
Also i think i kinda stole the logic of rust's case statements for Snakel conditional
translated into python:
 i:int=0
 if i==0:print(0)
 elif i==1:exit()
 else:print(3)
Snakel also has the feature of making multiple files in one file (just like in DreamBerd). You can also import that file to another file as a internal module
==Errors==
If you make an error in the code (for example putting an undefined variable into the code) in a Snakel interpreter. Then the terminal (or emiter as it's called in the gammaline universe) will emit an error and will explain and show where you made a mistake
===TypeError===
====Using a wrong type in a variable====
code:
emiter:
====Not specifying a type or specify a non-existent type to a variable====
code:
emiter:
====Removing an entry that is not on the list====
code:
emiter:
===SyntaxError===
====Using anything BUT a tab/4 spaces as indentation====
code:
emiter:
==Examples==
===Hello, world!===
translated into python:
 print("Hello, world!")
===Cat program===
translated into python:
 print(input())
===Truth-machine===
translated into python:
 def truth():
 i:int=input()
 if int(i)>0:return
 else:print(0);exit()
 truth()
 while 1:print(1,end="")
===A+B Problem===
translated into python:
 def APB (a:int,b:int):print(a+b)
 APB(7,4)
==See also==
Bake - The language made before the first version of Snakel was uploaded
Category:Languages Category:2024
Snakes and bits (Snakes and ladders)

Snakes and Bits (Snakes and Ladders) is an esoteric stack based programming language that functions in 2 dimensions. You denote a entry point of the prorgam using S and use Ladders (#) and snakes (~) to move vertically other wise you constantly move to the right.
There's more in depth info on how the language works and the location of the program that executes/visualizes the code on my github.
Program examples
bottles of beers 
 ~ \
 S "set number of beers" _ 0 . $ " bottles of beers on the wall" $ " bottles of beers on the wall" "take one down pass it around" $ " bottoles of beer on the wall" d ?!
 . @ 
truth machine 
 ~\
 ~\#
 ~\ #
 .$ # 
 S _ 0 > i <?=
 .$
fibonacci sequence 
 
 S 0 i 0 > i [ + ~ ~\ 
 ~ ~\#
 ~ ~\ #
 ~ ~\ #
 ~ ~\ #
 ~ ~\ #
 ~~\ #
 ~\ #
 $ > + # @
Snek

A stack-based language made almost entirely by the following characters: | _ / \. An instruction pointer moves along the "paths" made by these characters and commands are encoded as different numbers of each character in succession. Snek is so-called because of the tendencies for the program to look a bit like a snake with a long body and a @ as a head.
A single character is a noop, therefore you can move the instruction pointer without performing any operations.
== List of Commands ==
 ______ = push number of _s - 1
 
 |
 | = 2: add, 3: sub, 4: mul, 5: push 0, 6: div
 |
 
 \
 \ = 2; dup, 3: swap, 4: get char input, 5: print as number, 6: print as ascii,
 \
 
 /
 / = 2: ==, 3: >, 4: <, 5: >= 6: <=
 /
 @ = ends program
Where the numbers represent the number of characters in a row.
== Control Flow ==
When the instruction pointer comes across a fork in the path, it will choose the right path if the top value on the stack is zero and the left path if the value is one. Left and right are relative to the fork pointing upwards, like so:
 left right
 \ /
 |
And likewise
 ___/ left
 \ right
== Ambiguity in latyout ==
The ascii-art style of this language creates some ambiguity. Since the instruction pointer can only turn 45 degrees at once, examples such as this arise:
 _ _
 / /
 | |
Both of these are valid in Snek, however which one is picked if there are multiple options is not defined. Take this example:
 __
 /__
 //
 |
This is undefined behaviour, it is implementation specific which path the instruction pointer will take.
== Examples ==
==== Truth machine ====
This program takes a single character from the user, if it is 1 then it prints 1 forever, else it exits. This is an example of how loops and control flow can be used.
 _
 \
 \ ____ _
 \ _____/ \ / \ _@
 \_____/ | | \ _/
 | | \ / \__
 | | | | / \
 | | | | | \
 \_/ | | \ \
 \__/ | \
 \ \
 | |
 \_/
==== Adder ====
This program takes 2 single digit numbers from the user, adds them and prints the result.
 _
 \
 \
 \ _____
 \_____/ \
 |
 _ |
 / \_ |
 | \ |
 \ | \____
 \ | \
 \ | |
 | \ |
 | | |
 | | |
 | \ \
 \_ \ \
 \ \ \
 | \ |
 | \ | 
 | @ |
 | \
 \____ \
 \ \
 | \
 / |
 | /
 \_____ _ |
 \_____/ \_/
== Reference Interpreter ==
The reference interpreter is a work in progress. Knowing my track record with finishing projects, it may remain that way for a while. Pull requests are welcome.
Category:Languages
Category:Two-dimensional languages
Category:Thematic
Snigl

Snigl Snigl is a dynamic language aiming for functional simplicity and tight C integration.
 func: fib-rec (0) _
 func: fib-rec (1) _
 func: fib-rec (Int) (-- dup fib-rec swap -- fib-rec +)
 20 fib-rec
 
 [6765]
Category:Languages Category:Stack-based Category:Implemented
Snowman

Snowman is an esoteric programming language created by Stack Exchange user Doorknob.
==Hello World!==
In Snowman, the Hello World program is very easy to understand. It looks like this:
 ("Hello World!"sP
The program works by first making variables a and f active. Then, "Hello World!" is automatically put into a, the first undefined active variable. Then sP (or sp) prints the string out (sP = String Print).
==External resources==
* Interpreter
* Documentation
Category:Languages
Category:Implemented
Category:2015
Snub

Hey, Future User:Buckets! It's not Snub, It's Stub.
Snub isn't an Esoteric programming language created by User:Buckets in 2020, The original name was Kotery, but User:Buckets keeps forgetting the word Stub and Types Snub instead, so this is a pretty good workaround.
Commands	Instructions
& 	+1 if the line number is odd.
* 	Skip all commands remaining on this line once.
(a) 	go to the ath line if = The first print in digits.
! 	Print in ASCII.
/ 	-1 if the line number is even.
; 	Input if the line number is prime.
(Starting with Line 1.)
Truth-machine Program*:
 &*
 ;
 (5)
 *
 &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&!
 ////////////////////////////////////////////////(9)
Category:Languages
Category:2020
So is your face.

So is your face. is an esolang created by User:None1.
==Syntax==
So is your face. uses a stack, the stack is initially empty.
Every line is a command, commands other than So is your face. pushes itself into the stack.
The command So is your face. prints the string in the top of the stack and pops it.
==Example Programs==
===Hello World===
 Hello World!
 So is your face.
===Nope. interpreter===
 Nope.
 So is your face.
==Interpreter==
===Python===
b=[]
while 1:
 try:
 a=input()
 except:
 break
 if a=="So is your face.":
 print(b.pop())
 else:
 b.append(a)
Category:Total
Category:Languages
Category:Implemented
Category:Joke languages
Category:Stack-based
Category:Unusable for programming
Category:Output only
Soh supplementary private use area-b u+10fffe

�􏿾 (U+0001 and U+10FFFE), or "soh supplementary private use area-b u+10fffe" is a programming language where different operations are performed on a bit tape initialized with 50,000 zeroes. You can find more information in this GitHub repo.
==Commands==
�(SOH) takes input from the standard input stream "overwriting the bits it needs, encoded as utf-8 if the current bit is 1, otherwise, encoded as latin-1. Remember to end the input stream with an EOF!" (Input overwrites the bits in the bit tape, using utf-8 if the bit on the tape is 1, and Latin-1 otherwise.
�(U+10FFFE) "prints the bits in the output bit buffer, decoded as utf-8 if the current bit is 1, otherwise, encoded as latin-1. No overwriting occurs."
1 adds the current bit to the output bit buffer.
0 pops a bit from the output bit buffer, placing it in the current bit.
> and < move the data pointer one bit in the specified direction. 
- performs a logical NOT.
? skips the next command if the current bit is 1.
A, O, N, and X perform a logical AND, OR, NAND, or, XOR respectively of the previous 2 bits, and stores the result in the current bit.
| goes back to the beginning of the code.
Category:Languages Category:Cell-based Category:Implemented
SolboScript

==Introduction==
SolboScript is a joke esoteric programming language created by User:Ganondork consisting entirely of 'ROCK SOLBO' and variations of 'BWEEEEE'. It was inspired by this page of Sweet Bro and Hella Jeff. 
==Syntax==
Command 	Description
ROCK SOLBO 	Begins every program.
BWEE (variable) 	Print variable.
BWEEE (variable) 	Print variable, with value corresponding to letter of alphabet.
BWEEEE (variable) (value) 	Define variable and value.
BWEEEEE (variable) 	Increment variable.
BWEEEEEE (variable) 	Decrement variable.
BWEEEEEEE (variable) (variable) (output variable) 	Add two variables.
BWEEEEEEEE (variable) (variable) (output variable) 	Subtract two variables.
BWEEEEEEEEE (variable) (variable) (output variable) 	Multiply two variables.
BWEEEEEEEEEE (variable) (variable) (output variable)	Divide two variables.
BWEEEEEEEEEEE (variable) BWEE (variable) 	If variable = variable
BWEEEEEEEEEEE (variable) BWEEE (variable) 	If variable > variable
BWEEEEEEEEEEE (variable) BWEEEE (variable) 	If variable < variable
BWEEEEEEEEEEEE 	Loop forever.
BWEEEEEEEEEEEEE (variable) BWEE (variable) 	Loop until variable = variable
BWEEEEEEEEEEEEE (variable) BWEEE (variable) 	Loop until variable > variable
BWEEEEEEEEEEEEE (variable) BWEEEE (variable) 	Loop until variable < variable
==Examples==
===Hello===
 ROCK SOLBO
 BWEEEE BWEE BWEEEEEEEEE
 BWEEEE BWEEE BWEEEEEE
 BWEEEE BWEEEE BWEEEEEEEEEEEEE
 BWEEEE BWEEEEE BWEEEEEEEEEEEEEEEE
 BWEEE BWEE BWEEE BWEEE BWEEE BWEEEE BWEEE BWEEEE BWEEE BWEEEEE
===If a = b then print c===
 ROCK SOLBO
 BWEEEE BWEE BWEEEEEEE 
 BWEEEE BWEEE BWEEEEE 
 BWEEEE BWEEEE BWEEEE 
 BWEEEEEEEEEEE BWEE BWEE BWEEE 
 BWEEE BWEEEE
===Fibonacci===
 ROCK SOLBO
 BWEEEE BWEE BWEE
 BWEEEE BWEEE BWEE
 BWEEEEEEEEEEEE
 BWEE BWEE
 BWEE BWEEE
 BWEEEEEEE BWEE BWEEE BWEE
 BWEEEEEEE BWEE BWEEE BWEEE
==Interpreter==
* Common Lisp implementation of the SolboScript programming language.
Category:Joke languages
Category:2017
Category:Languages
Category:Implemented
Category:Pseudonatural
Category:Output only
Solbofuck

==Introduction==
Solbofuck is the SolboScript version of Brainfuck, created by User:Ganondork, and is a TrivialBrainfuckSubstitution. It was inspired by this page of Sweet Bro and Hella Jeff. 
==Syntax==
All Solbofuck programs begin with ROCK SOLBO. Other than that, simply write a Brainfuck program, and then translate it according to the below table. All bwees must be followed with a space.
==Commands==
Brainfuck	Solbofuck
> 	BWEE
< 	BWEEE
+ 	BWEEEE
- 	BWEEEEE
. 	BWEEEEEE
, 	BWEEEEEEE
[ 	BWEEEEEEEE
] 	BWEEEEEEEEE
==Examples==
===Hello World===
 ROCK SOLBO
 BWEEEE BWEEEE BWEEEE BWEEEE BWEEEE BWEEEE BWEEEE BWEEEE BWEEEEEEEE BWEE BWEEEE BWEEEE BWEEEE BWEEEE BWEEEEEEEE BWEE BWEEEE BWEEEE BWEE BWEEEE BWEEEE BWEEEE BWEE BWEEEE BWEEEE BWEEEE BWEE BWEEEE BWEEE BWEEE BWEEE BWEEE BWEEEEE BWEEEEEEEEE BWEE BWEEEE BWEE BWEEEE BWEE BWEEEEE BWEE BWEE BWEEEE BWEEEEEEEE BWEEE BWEEEEEEEEE BWEEE BWEEEEE BWEEEEEEEEE BWEE BWEE BWEEEEEE BWEE BWEEEEE BWEEEEE BWEEEEE BWEEEEEE BWEEEE BWEEEE BWEEEE BWEEEE BWEEEE BWEEEE BWEEEE BWEEEEEE BWEEEEEE BWEEEE BWEEEE BWEEEE BWEEEEEE BWEE BWEE BWEEEEEE BWEEE BWEEEEE BWEEEEEE BWEEE BWEEEEEE BWEEEE BWEEEE BWEEEE BWEEEEEE BWEEEEE BWEEEEE BWEEEEE BWEEEEE BWEEEEE BWEEEEE BWEEEEEE BWEEEEE BWEEEEE BWEEEEE BWEEEEE BWEEEEE BWEEEEE BWEEEEE BWEEEEE BWEEEEEE BWEE BWEE BWEEEE BWEEEEEE BWEE BWEEEE BWEEEE BWEEEEEE
===Cat program===
An infinitely repeating cat program, equivalent to brainfuck's ,.[,.], is implemented in the following:
 ROCK SOLBO
 BWEEEEEEE BWEEEEEE BWEEEEEEEE BWEEEEEEE BWEEEEEE BWEEEEEEEEE
==Interpreter==
* Common Lisp implementation of the Solbofuck programming language. Conversion routines betwixt Solbofuck and brainfuck are supplied as well.
Category:Languages
Category:Brainfuck equivalents
Category:Joke languages
Category:Implemented
Category:Turing complete
Category:Turing tarpits
Category:Low-level
Category:2017
Solo

Solo is created by User:A.
==Syntax==
s	scan a number from the console to the accumulator
o	output the accumulator to the console
l	loop the next byte forever if the accumulator is not 0
==Examples==
===Truth-machine===
 solo
===1-time numeric cat===
 so
==Interpreter in C (solo.h)==
 #include <stdio.h>
 void solo(const char *code)
 {
 int acc = 0;
 while(*code != '\0')
 {
 switch(*code)
 {
 case 's':
 scanf("%d", &acc);
 break;
 case 'o':
 printf("%d\n", acc);
 break;
 case 'l':
 if(acc != 0)
 {
 char charToLoop = *code;
 while(charToLoop == 'l')
 charToLoop = *++code;
 switch(charToLoop)
 {
 case 's':
 while(1) scanf("%d", &acc);
 break;
 case 'o':
 while(1) printf("%d\n", acc);
 break;
 default:
 while(1);
 }
 }
 }
 ++code;
 }
 }
Category:Languages Category:2018 Category:Unusable for programming Category:Implemented Category:Push-down automata
Something

Something is a low level programming language created by User:PixelatedStarfish. The only error message in the language is the phrase Oops! Something went wrong!
Something is similar to that most famous of languages by Urban Müller, referred to here as brainfood. Like brainfood, in Something, cells on a tape can store values from 0 to 255, and a pointer can read and write to a cell. Unlike brainfood, Something has an unbounded tape, and it has 13 instructions instead of 8. 
==Instructions==
Instructions move the pointer and modify cells. Some instructions can take one argument separated by a space, which must be an integer. Instructions are separated by a newline.
 Instructions
Instruction	Description
MOV	V 	moves the pointer V cells on the tape
ADD	V 	Add V to the current cell
SUB	V 	Subtract V from the current cell
INP 	Set cell to input (throws exception if input is not between 0 and 255 inclusive)
LBL	L 	A label L
GTO	L 	Go to label L
CBZ	L 	Go to L if the current cell is zero.
CHR 	Print value of cell as an ASCII character
VAL 	Print value of cell
TAS 	move pointer to start of tape
ZER 	set cell value to zero
QNE 	Prints “QNE” (a Quine)
HLT 	Halt, end program
A comment is written with angle brackets:
 <this is a comment>
 <
 this is a multiline comment
 >
==Program Examples==
===Hello World===
 ADD 72
 CHR 
 ZER
 ADD 69
 CHR 
 ZER
 ADD 76
 CHR 
 ZER
 ADD 76
 CHR 
 ZER
 ADD 79
 CHR 
 ZER
 ADD 32
 CHR 
 ZER
 ADD 87
 CHR 
 ZER
 ADD 79
 CHR 
 ZER
 ADD 82
 CHR 
 ZER
 ADD 76
 CHR 
 ZER
 ADD 68
 CHR 
 ZER
===Truth Machine===
 INP
 CBZ 0
 LBL 1
 <set to one for the machine>
 ZER
 ADD 1
 VAL
 GTO 1
 LBL 0
 VAL
===Quine===
 QNE
==Proof of Turing completeness==
Brainfood is Turing complete.
By translating each brainfood command to Something, it can be shown that Something is also Turing complete.
(Note that ' :: ' is a stand-in for a newline.)
 Conversion Table 
Something 	Brainfood	Desc
MOV 1 	> 	increment
MOV -1 	< 	decrement
ADD 1 	+ 	add 1 to cell
SUB 1 	- 	take 1 from cell
CHR 	. 	Output ASCII value at cell
INP 	, 	Take input at cell
CBZ X 	[ 	Jump past ' ] ' (to label X)
CBZ X :: GTO Y :: LBL X	] 	goto ' [ ' (label Y) if cell is greater than 0
==External Resources==
*Interpreter
*REPL
Category:Languages Category:2021 Category:Implemented Category:Cell-based Category:Turing complete Category:Turing tarpits Category:Low-level
Something?Oops!

Something?Oops! is a simple esolang by User:A.
==Syntax==
The syntax is as follows:
 Statement: "<identifier> <identifier>?Oops<variable>"
 Identifier: A nonnegative integer or a variable
 Variable: "!" or "?" or "." or ","
==Commands==
A statement of the form A B?OopsC stores A + B in C.
As opposed to traditional programming languages, the various effects, including value storage, input/output, and control flow, does not depend upon the choice among the available instructions, but upon utilized variables and whether they are applied in a reading or writing context.
Four variables exist, each of which distinguished by their identity and side effects:
Variable	Effect
? 	Is a special variable in that reading from it produces input from the user rather than ?'s value, thus making ? effectively read-only as a variable. The user input is expected to be communicated in the form of a nonnegative integer number.
. 	Produces output, and though it can be used as a normal variable, anything written to it is also output to the screen.
, 	Is also special: it's the instruction counter. When reading, it returns the current instruction index. When writing, a jump (goto) to the specified instruction is exercised. The enumeration starts at one (1).
! 	In fact, only ! is a “normal” variable at all.
==Example==
===Truth-machine===
 ? 2?Oops,
 0 5?Oops,
 0 1?Oops.
 0 3?Oops,
 0 0?Oops.
===Counter===
This short program prints the numbers 1, 2, and 3 by employment of the instruction counter.
 0 ,?Oops.
 0 ,?Oops.
 0 ,?Oops.
==Interpreter==
* Common Lisp implementation of the Something?Oops! programming language.
Category:Languages 
Category:Finite state automata 
Category:Implemented 
Category:Low-level 
Category:2018
Something positive

something positive is an esolang by User:PythonshellDebugwindow.
==Overview==
something positive is a string-rewriting language. Programs take a program in a program-specified language as input and produces the program, with rewriting rules applied, as output; if the input and output programs are the same, the program halts immediately, but if they are different, the program never halts. The brainfuck programs +[] and ++[] are different (because the tapes end up with 1 and 2 respectively, not because of the differing lengths, so +[] and ++-[] would be the same), but the Nil programs A and B are the same. Neither the input program or the output program are ever executed.
==Syntax==
The first line of the program specifies the language to be used. The remaining lines are the rewriting rules, each in the form of string → replacement. Each rule is applied in turn, so each line is executed exactly once. Each rule matches as many times as possible, but X → X won't go into an infinite loop, as rules don't overlap.
==Examples==
===Hello, World!===
 Quine
 → Hello, World!
Input nothing. Loops forever. Note the leading space.
===Cat program===
 Text
No rewriting rules are applied, so the input and output are the same.
===Truth-machine===
Always outputs 0.
 Stackint
 0 → 1
 1 → 0
Category:Languages Category:2020 Category:String-rewriting paradigm Category:Unimplemented Category:Uncomputable
Son of a BitCh

Son of a BitCh is an esolang with 2 instructions, created by islptng.
As the title says, it is heavily inspired and based on BitChanger. The program itself, has not only a tape, but a state storage, which the value is always one of diojn.
<
d: toggle current bit and move left
i: receive a bit from input buffer
o: push current bit to output buffer
j: if current bit is 0, jump back to the last 19th <, if next instruction is >, skip it; else continue jump back to the 38th
n: NOP
>
d: move right
else: NOP
every time a ">" is executed, shift the state storage(d->i->o->j->n->d)
that's it.
>>>>> moves right
<>>>>>< moves left.
<>>>>> toggle s a bit.
<>>>>><><>>>> input. 
<>>>>><>><>>> output.
Category:Languages
Category:Cell-based
Category:Turning tarpits
Category:Brainfuck derivatives
Category:Low-level
Category:Unimplemented
Category:2024
Category:Unknown computational class