nyuuzyou/wikis huggingface dataset:
Shinda Sakana

Shinda Sakana (死んだ魚) means 'dead fish' in Japanese. It is an esoteric programming language created by User:TheCanon2. Shinda Sakana is a Deadfish variant. Shinda Sakana was succeeded by Sakana.
===Commands===
Like Deadfish, and like its successor Sakana, Shinda Sakana has a single accumulator, x. Shinda Sakana has five commands.
Kanji	Term 	Action
増 	増加 (zouka) 	Increment x
減 	減少 (genshou) 	Decrement x
乗 	二乗 (nijou) 	Square x
出 	出力 (shutsuryoku) 	Output x as number
書 	書く (kaku) 	Output x as Unicode
Like in Deadfish, x is set to 0 if x == -1 or x == 256.
==Examples==
===Hello, World!===
増増増乗減乗増増増増増増増増書増増増増増増増増増増増増増増増増増増増増増増増増増増増増増書増増増増増増増書書
増増増書減減減減減減減減減減減減減減減減減減減減減減減減減減減減減減減減減減減減減減減減減減減減減減減減減減
減減減減減減減減減減減減減減減減減書減減減減減減減減減減減減書減減減減減減減減減減減減減減減減減減減減減乗減
減書減減減減減減減減書増増増書減減減減減減書減減減減減減減減書減減減減減減減減減減減減減減減減減減減減減減減
減減減減減減減減減減減減減減減減減減減減減減減減減減減減減減減減減減減減減減減減減減減減書
===XKCD Random Number===
増増増増出
==Implementations==
The following Python script is an interpreter.
prgm = input('>死んだ魚 ')
accumulator = 0
for inst in range(0, len(prgm)):
 if prgm[inst] == "増":
 accumulator += 1
 elif prgm[inst] == "減":
 accumulator -= 1
 elif prgm[inst] == "乗":
 accumulator **= 2
 elif prgm[inst] == "出":
 print(accumulator)
 elif prgm[inst] == "書":
 print(chr(accumulator))
 else: print("Unrecognised command.")
 if accumulator == -1 or accumulator == 256:
 accumulator = 0
The following Python script converts a program from Deadfish to Shinda Sakana.
deadfish = input('>deadfish ')
shinda = [""]
for inst in range(0, len(deadfish)):
 if deadfish[inst] == "i":
 shinda.append("増")
 elif deadfish[inst] == "d":
 shinda.append("減")
 elif deadfish[inst] == "s":
 shinda.append("乗")
 elif deadfish[inst] == "o":
 shinda.append("出")
 else: print("Unrecognised command.")
shinda = .join(shinda)
print(shinda)
Category:Languages
Category:Accumulator-based
Category:Deadfish derivatives
Category:CJK
Category:Implemented
Category:Output only
Category:Total
Category:Unusable for programming
Category:2024
ShitLang

==ShitLang==
Shitlang is the best worst programming language ever, created in 2022
===history===
ok so basically this was a programming language that was going to be just renamed lua but then since im lazy it got cancelled
now i am making a new version of this that isnt lua
also do not expect a compiler/interpreter for this
===things in shitlang===
instructions:
 print something to the console:
 writetoconsole /w=("string")
 a comment:
 acomcoOCMEORMWERJWNEFIUHDFASDUHFDYUFASUDFS*/comment goes here*/SFDUSAFUYDFHUDSAFDHUIFENWJREWMROEMCOocmoca
 print something to the console, but add gibberish to it:
 writetoconsosdfadsnfnfdbDSFDHBDJKSDKSDKSFSKJHFBKJBSJBHGJDBSJDJKBJKHJKBJHBJHBle /w=("string")
 print a number:
 writetoconsole /n=(2)
 
 define variables (string):
 variable vartype=(STRING), varname="name", value="John"
 define variables (number):
 variable vartype=(INTEGER), varname="age", value="30"
 end program:
 end
 crash:
 KNJKNSADKFJNSADKJFNSKLJFANASDKLJFNSADFKJNSDKJFNASDKJFNSDKFNSDKJFSDNKJFNAKJNDFNADJKNFDNNDNNNNDNDNDNDNDN
 newline:
 \n
 use a lot of memory:
 GOOGLECHROME
 crash the os somehow:
 freeminecraft
god i am tired of doing this
(not putting an end statement makes the program loop)
===examples===
hello world:
 writetoconsole /w=("Hello, World!", \n)
 end
pc exploder o matic:
 GOOGLECHROME, GOOGLECHROME, GOOGLECHROME, GOOGLECHROME, GOOGLECHROME, GOOGLECHROME, GOOGLECHROME, GOOGLECHROME, GOOGLECHROME, GOOGLECHROME, GOOGLECHROME, GOOGLECHROME, GOOGLECHROME, GOOGLECHROME, GOOGLECHROME, GOOGLECHROME, GOOGLECHROME, GOOGLECHROME, GOOGLECHROME, GOOGLECHROME, GOOGLECHROME, GOOGLECHROME, GOOGLECHROME, GOOGLECHROME, GOOGLECHROME, GOOGLECHROME, GOOGLECHROME, GOOGLECHROME, GOOGLECHROME, GOOGLECHROME, GOOGLECHROME, GOOGLECHROME, GOOGLECHROME, GOOGLECHROME, GOOGLECHROME, GOOGLECHROME, GOOGLECHROME, GOOGLECHROME, GOOGLECHROME, GOOGLECHROME, GOOGLECHROME, GOOGLECHROME, GOOGLECHROME, GOOGLECHROME, GOOGLECHROME, GOOGLECHROME, GOOGLECHROME, GOOGLECHROME, GOOGLECHROME, GOOGLECHROME, GOOGLECHROME, GOOGLECHROME, GOOGLECHROME, GOOGLECHROME, GOOGLECHROME, GOOGLECHROME, GOOGLECHROME, GOOGLECHROME, GOOGLECHROME, GOOGLECHROME, GOOGLECHROME, GOOGLECHROME, GOOGLECHROME, GOOGLECHROME, GOOGLECHROME, GOOGLECHROME, GOOGLECHROME, GOOGLECHROME, GOOGLECHROME, GOOGLECHROME
do not use this programming language:
 KNJKNSADKFJNSADKJFNSKLJFANASDKLJFNSADFKJNSDKJFNASDKJFNSDKFNSDKJFSDNKJFNAKJNDFNADJKNFDNNDNNNNDNDNDNDNDN, freeminecraft
if someone creates a real compiler/interpreter for this, please tell it in the talk tab
Category:Languages Category:Unimplemented Category:2022 Category:Output only
Shoe

Shoe(puSH dOwn machinE) is push-down automation by ChuckEsoteric08 that compiles into Fist
==Commands==
Command	Meaning
<X 	declare label X and push X to the bottom of the stack. If you will goto to this label it will push it to the stack again
^X 	jump to label X unconditianally
!X>Y 	if last input was X goto Y
?X 	push X and ask for input. Push X
==Examples==
===Push "Hello world" to stack infinitly===
 <Hello World
 ^Hello World
===Truth-machine===
 ?input?
 !0>0
 !1>1
 <1
 ^1
 <0
==External resources==
Compiler in Scratch
Category:Languages Category:Push-down automata
Shoopuf

Shoopuf is a list-based language created by Deathping in 2004. It is loosely based on Brainfuck and Kipple. The name Shoopuf comes from a creature in the computer game Final Fantasy X.
Shoopuf has 26 circularly-linked lists named A-Z which contains integers. The lists I, O and D are special. I contains the program's input read from stdin when the program starts, and when the program terminates the contents of O list is written to output. Input and output during execution is not possible. The D list is will convert any number inserted into it in to an ASCII string representing that number.
A shoopuf program consists of a set of opcodes. An opcode is a three-character string, where the first character denotes the instruction and the two other characters are it's parameters. The first parameter has to be a list identifier, while the second can be either a list identifier or a numerical value.
==External resources==
* Deathping's home page, which unfortunately doesn't contain any info about Shoopuf.
* Picture of a shoopuf
Category:Languages
Category:Implemented
Category:2004
Short Minsky Machine Notation

Short Minsky Machine Notation is a notation for Minsky machines created by User:Yayimhere that uses subscripts and superscripts. It was created for the translation from an MM to BUT, and has been used in other esolangs he made.
== Notation ==
this is how to write it:
 Notation
symbol	in MM
℘xy 	Decrement register y and goto line x.
℘y 	Increment register y
℘ 	Halt
lines are just numbered by the first line is 1 second is 2 ect.
==Examples==
===Infinite loop===
 ℘1℘1℘11
Category:Concepts
Shortest Code Challenge

Shortest Code Challenge is arranged from One Line Challenge.
Here is something of this challenge. 
== Python ==
One!
 print("Hello, world!")
Two!
 a = int(input()); b = int(input()); c = a + b; print(c)
Note: PEP-8 makes it clear that it's best not to write code like this.
== C++ ==
Note: Code that starts with a hashtag cannot be written on a single line with code that starts with not a hashtag(except for comments).
One!
 #include<iostream>
 using namespace std; int a, b, c; int main(){cin >> a >> b; c = a + b; cout << c << endl; return 0;}
Two!
 #include<bits/stdc++.h>
 using namespace std; int main(){for(int i = 0; i < 10; i++){printf("%d, ", i);} return 0;}
Category:Program forms
Shortstack

:Note that shortstack is typically lowercased except, often, at the start of a sentence.
Shortstack is a codegolfed language created by User:mmph. It should not be used for codegolfing.
Shortstack starts with a tape of which's content is only a 0.
Every new instruction, it prints the current value of the tape.
Shortstack also has a pointer for both the tape and the instruction pointer.
Shortstack is a tape based programming language with only 5 commands.
Command Name	Command Action
< 	Moves the tape pointer left, if outside of bounds, sets it to the top of the tape.
> 	Moves the tape pointer right, if outside of bounds, appends a 0 at the end of the tape, and sets the tape pointer to new cell.
[ 	If the cell is 0, sets the instruction pointer to the corresponding "]"
] 	If the cell is not 0, sets the instruction pointer to the corresponding "["
, 	Flips the cell at the current tape pointer position. (0 to 1, 1 to 0)
It's point was for its source file to be golfed, and is just a Turing machine at its core.
Source file:
 i=open("f","r").read()
 s=[]
 l={}
 for a,x in enumerate(i):
 	if x=="[":s.append(a)
 	if x=="]":b=s.pop(0);l[b]=a;l[a]=b
 t=[0]
 p=0
 a=0
 while a!=len(i):
 	x=i[a]
 	if x in"<>":
 		p+=ord(x)-61
 		if p==len(t):t.append(0)
 	if x==",":t[p]=1-t[p]
 	if x=="["and not t[p]:a=l[a]
 	if x=="]"and t[p]:a=l[a]
 	print(t)
 	a+=1
One example program is one that "prints" "Hi".
 ,>>>,>>>><<<<<<<,>,>,>,>,<<<<<,
In reality it prints the binary values of "Hi", but only 2 of them.
It actually prints: 
 [1]
 [1, 0]
 [1, 0, 0]
 [1, 0, 0, 0]
 [1, 0, 0, 1]
 [1, 0, 0, 1, 0]
 [1, 0, 0, 1, 0, 0]
 [1, 0, 0, 1, 0, 0, 0]
 [1, 0, 0, 1, 0, 0, 0, 0]
 [1, 0, 0, 1, 0, 0, 0, 0]
 [1, 0, 0, 1, 0, 0, 0, 0]
 [1, 0, 0, 1, 0, 0, 0, 0]
 [1, 0, 0, 1, 0, 0, 0, 0]
 [1, 0, 0, 1, 0, 0, 0, 0]
 [1, 0, 0, 1, 0, 0, 0, 0]
 [1, 0, 0, 1, 0, 0, 0, 0]
 [1, 0, 0, 1, 0, 0, 0, 0]
 [0, 0, 0, 1, 0, 0, 0, 0]
 [0, 0, 0, 1, 0, 0, 0, 0]
 [0, 0, 0, 1, 0, 0, 0, 0]
 [0, 1, 0, 1, 0, 0, 0, 0]
 [0, 1, 0, 1, 0, 0, 0, 0]
 [0, 1, 1, 1, 0, 0, 0, 0]
 [0, 1, 1, 1, 0, 0, 0, 0]
 [0, 1, 1, 0, 0, 0, 0, 0]
 [0, 1, 1, 0, 0, 0, 0, 0]
 [0, 1, 1, 0, 1, 0, 0, 0]
 [0, 1, 1, 0, 1, 0, 0, 0]
 [0, 1, 1, 0, 1, 0, 0, 0]
 [0, 1, 1, 0, 1, 0, 0, 0]
 [0, 1, 1, 0, 1, 0, 0, 0]
 [0, 1, 1, 0, 1, 0, 0, 0]
 [0, 1, 1, 0, 1, 0, 0, 1]
Which converts to:
 ����	�$H������������PPpp``hhhhhhi
Truth machine:
This language does not support input, so you have to modify the source file in order to "input" a number.
 ,[]
Removing the comma, results in you putting in a 0, leaving it is a 1.
If it has a 0, it outputs a 0, if it has a 1, it outputs 1 forever.
Category:Languages Category:Implemented Category:Cell-based Category:Turing complete Category:Turing tarpits Category:Low-level Category:Output only
Shove

Shove is an esoteric programming language created by User:ais523 in 2008, but ais523 forgot to tell anyone about it until 2013. It is based on the idea of shoving strings into a self-modifying, two-dimensional program, pushing other content out of the way.
==Specification==
A Shove program is the initial state of a two-dimensional playfield of cells containing characters, in which execution may pass in any of the four cardinal directions.
At the start of execution the instruction pointer begins on the leftmost cell of the topmost line of the program, moving rightwards until some instruction causes its direction to change. Execution halts when the instruction pointer passes beyond the boundary of the current playfield, so that no further instructions to execute can be reached.
Shove has a stack, to which strings may be pushed from the playfield, or from which they may be popped, shoving them into the playfield.
===Shoving===
When a string is shoved into the playfield, its first character is put into a specific neighboring cell of the currently running instruction. Further characters of the string are placed relative to the first, in the current execution direction. This does not overwrite any characters, instead an entire ray of characters, from the starting cell and onwards in the current execution direction, is shoved out of the way to make room for the new characters.
In the case where the currently executing character is one of those shoved, so is the instruction pointer, so that execution continues from after the new position of that character.
The process of shoving may enlarge the boundaries of the playfield in any direction.
===Instructions===
Commands 	Description
' " 	Push a string from the playfield onto the stack. The string is read in the current execution direction and ends before the matching ' or ", respectively, after which execution continues. ' quoted strings may be nested inside " quoted strings and vice versa, to unlimited depth.
< v > ^	Change direction of execution to the one pointed to.
A V ( ) 	Pop a string from the stack and shove it onto the playfield, starting at the neighboring cell in the direction pointed to.
(space) 	Do nothing.
! 	Do nothing. This also signals to the implementation that any characters behind the instruction pointer (the entire half-plane in the direction it is coming from) will never again be used.
S 	In implementations with output, print the string at the top of the stack, without popping it. Otherwise do nothing.
n 	In implementations with output, print a newline. Otherwise do nothing.
==Example==
===Hello, World!===
 " ,olleH"V v
 S"!dlroW"<
==External resources==
*Original implementation in Perl.
*Slightly modified implementation with some command line options.
Category:Languages 
Category:Stack-based 
Category:Cell-based
Category:Two-dimensional languages 
Category:Implemented 
Category:Output only
Category:Low-level 
Category:Self-modifying
Category:2008
Shrekcode

== Background Information ==
Shrekcode is an esoteric programming language (idea (insert trollface)) made by User:Quartadias Jingleton. The length of a word in the Shrek script corresponds to an opcode. A word can only be written down in lowercase script. If you wrote down the longest word in the Shrek script and you don't know what to do, just write down "SHREK". If you don't want to write this down too much, then write down "DONKEY X DRAGON SHIPPING CUTE", which is just "SHREK", but written down 10 times. The number of times the text is repeated also corresponds to an opcode. You also can't learn this language unless you have watched Shrek before and you are very smart.
== Examples ==
You can add some lmao, this page's short asf
There's also no compiler for this esolang, but maybe you can make one because you are awesome and I love you. <3
Also this is a bad page but please don't delete it. Thx :D
Category:Languages Category:Thematic
Shut up

shut up is a joke brainfuck derivative made by User:masalt. shut up is turing complete, but most programs are too long to be shown on this page.
==Examples==
===Copy Input to Output===
This program takes one input and outputs it once.
shut up shut up shut up shut up shut up shut up shut up shut up shut up shut up shut up shut up shut up shut up shut up 
shut up shut up shut up shut up shut up shut up shut up shut up shut up shut up shut up shut up shut up shut up shut up 
shut up shut up shut up shut up shut up shut up shut up shut up shut up shut up shut up shut up shut up shut up shut up 
shut up shut up shut up shut up shut up shut up shut up shut up shut up shut up shut up shut up shut up shut up shut up 
shut up shut up shut up shut up shut up
Category:Languages Category:Joke languages Category:Brainfuck derivatives
SiacB

SiacB, aka siacB v2, is a python esotaric programming language that PartehTheEsolangDev rewrote from it's previous owner, PyGamer0. 
The syntax goes as follows:
 WAKEY WAKEY = Start
 BEDTIME = End
 sciab::test = HWorld
 sciab::lennyshrug = "¯\_(ツ)_/¯" aka the lenny face shrug
 sciab::arnoldc = A reference to ArnoldC's beginning line: "IT'S SHOWTIME".
 sciab::changelog = the changelog
You can find it here.
Category:Joke languages Category:Languages Category:Implemented
SickPig

SickPig is a version of the language Pig, that simulates a pig that is sick.
==Usage==
SickPig follows the same syntax rules as Pig. You write the name of the text file you want to create, write PIG, then write the contents of the text file. However, because the pig is sick, it will ignore your desired contents and write one of these words instead:
GRUNT
MOAN
OINK
BURP
GROAN
WHINE
Therefore, a complete SickPig program will be a text file which contents are one of these words.
==Various Programs in SickPig==
===Text File Named "Hello, World!"===
The following code creates a text file named "Hello, World!" that has random contents.
 Hello, World!PIG
===Cat Program===
SickPig cannot create the Cat program because it is output only.
===Quine===
SickPig cannot create a Quine either.
====Probabilistic-quasi-quine====
 Any text goes herePIGWHINE
This program generates a file with the specified filename and has 1/6 chance to output WHINE so it is a probabilistic-quasi-quine.
==The Pig Series==
The Pig series is a a series of programming languages that are all based on Pig.
The languages are Pig, SickPig, DeadPig, and QuinePig.
Other languages based on Pig are DeafPig and ExtendedPig.
==External resources==
* Interpreter in Python 3
Category:Languages Category:Output only Category:Unusable for programming Category:Joke languages Category:Total Category:Implemented
Sickfrog

Sickfrog is an esoteric programming language created by Stysan (talk) that commands are based on Frog commands. Syntax of this language is based on Batch syntax. Sickfrog scripts extension is .sfrgp. This language is remake of Frog programming language.
 Commands
Example 	Output 	Description
cr Hello World! 	Hello 	Outputs first 5 letters of a value without new line, bc frog is sick.
qu How old are you?	How o 	Asks a question (first 5 letters of value).
ri 14 	No output 	What question answer should be. Full value.
bark 	True/False	Checks if answer is right. Full value.
beep 10 	1-10 	Outputs a random number between 1 and entered value. Full value.
cluck 1 	No output 	Sleeps value seconds. Full value.
nl 	\n 	Outputs a new line.
*something 	No output 	Comments.
== Interpreter ==
This is the original interpreter for Sickfrog written on Python 3.8.5.
 from tkinter import Tk, filedialog as fd
 from time import sleep
 from random import randint
 
 tk = Tk()
 tk.withdraw()
 
 filetypes = [("Sickfrog Scripts", "*.sfrgp"), ("All files", "*.*")]
 code = fd.askopenfilename(title="Select a Script", filetypes=filetypes)
 code = open(code, mode="r")
 code = code.read()
 code = code.split("\n")
 
 answer = ""
 answer_shouldBe = ""
 
 def bug():
 print("ERROR")
 sleep(1)
 quit()
 
 for i in code:
 try:
 if i.startswith("cr "): print(i[3:8], end="")
 elif i == "nl": print()
 elif i.startswith("qu "): answer = input(i[3:8])
 elif i.startswith("ri "): answer_shouldBe = i[3:]
 elif i == "ba": print(answer == answer_shouldBe)
 elif i.startswith("be "): print(randint(1, int(i[3:])))
 elif i.startswith("cl "): sleep(int(i[3:]))
 elif i == "" or i.startswith("*"): pass
 else: bug()
 except: bug()
== Examples ==
Hello World!
 cr Hell
 cr o Wor
 cr ld!
 Quiz! 
 cr Quiz!
 ri esolangs.org
 cr What 
 cr is th
 cr e bes
 cr t sit
 cr e abo
 cr ut es
 cr esola
 qu ngs?
 bark
 cr I won'
 cr t add
 cr more
 cr ques
 cr tions
 cr I'm l
 cr azy
== See also ==
* Ook!
* Frog
Category:Languages Category:Implemented Category:Unusable for programming Category:Total Category:Thematic
Sigil

Sigil is an esoteric programing language with only 5 meaningful characters: #$%().
== Language overview ==
A sigil program can be described with the following EBNF syntax:
main = command;
command = number ('(' command ')')*;
number = /[#$%]*/;
The Sigil VM also have a stack and a queue.
== Number system ==
The number system used by Sigil is a variant of base 3.
To convert a Sigil number to a decimal number:
Convert # to 0, $ to 1 and % to 2
Convert the number to decimal from base 3
Add 1 if the original number is not empty
== Commands ==
- NOP
#(x)(y) ADD
$(x) NEGATE
%(x) PUSH
$# POP
$$(x) ENQUEUE
$% DEQUEUE
%#(c)(x)(y) IF
%$(c)(b) WHILE
%%(n) NUMBER
$##(c) PRINT CHARACTER
$#$ INPUT CHARACTER
$#%(n) PRINT NUMBER
$$# INPUT NUMBER
$$$(a)(b)...(c) CHAIN
Sign

Sign is an esoteric programming language invented by User:A that is inspired be the "theoretical" recursion support of esolangs.org's signature system, and every proram is trivially a signature system supporting an extended wiki tag system. Every program can "theoretically" run on the signature system. Every index begins with the index 1.
Try it yourself: set your signature to ~~~~ and see what happens!
The results of Sign is usually non-deterministic, as the time that a program runs can vary every time.
==Syntax==
Any other markdown item saves that markdown to the signature. If they are executed, they are no-ops.
~~~~ 	recursion of the signature
--~~~~	recursion with timestamp inserted to the back of the signature.
 	If there is a yyy on position 3, insert xxx on position 5 of the signature. Negative indexes are possible; they index the program from the backmost index to the frontmost index, unlike what positive indexes do.
 	Break out of a level of recursion. If there are no levels to break out, stop the program.
== Notes of programming in Sign ==
Writing programs will be very easy; however, finding a right time to run a program will be very hard. Usually, a program will run correctly if it is run at the valid time (the programmer will have to specify that time).
If the valid time to run that program has passed, the user will have to modify their program to make it run correctly.
== Example programs ==
=== Hello, world! program ===
Hello, world!
=== Cat program ===
Replace this with input
=== Infinite loop ===
~~~~
==== Shortest code to do infinite output ====
--~~~~
=== Finite loop: repeat 60 times ===
I have no idea how long one step will take; let's assume that it takes 1 minute to do that. This program should be run at 08:00, 28 June 2019 (UTC)
<nowiki>--~~~~</nowiki>
 
Category:Nondeterministic
Category:Self-modifying
Category:Languages
Category:Unimplemented
Category:2019
Category:Unknown computational class
Signle

Signle is a esolang with only one function made by User:Yayimhere. The name comes from a typo of the word single cuz its a single function.
== the function ==
There os a single function. The ! function. It tales input as a string. Lets say we pass it the string: x. Here is what it does:
 x_ add a underscored
 x_xx add the input to itself twice
 xx_x rotate the last char to the right
 xx_! x add a ! And a space after the underscore
 Now here comes a conditional. If two first chars are not the same it will pass the result back to the function. In this case it is equal so it will return the result
to save a variable x as the string y:
 x y *
The passing of a string to the function is:
 x!
This passes x to the function. To pass a varible:
 *x!
If x is a variable it will pass its contents. Else it will pass the string *x
== examples ==
infinite loop:
 )()(!
Halting program:
 x!
Category:Languages Category:Unknown computational class
Silly

===What is this?===
Silly is a language designed by User:PixelatedStarfish in 2022. It is the ultimate in programming languages. It can take literally any input, convert it into text, and then convert that text into runnable Silly code. It's a Starstuff language, an attempt at realizing the vision of turning literally anything into runnable code, so that no one will ever be able to say "Ugh, I just can't code." ever again! So, how does this one work? Well, with the power of a stack! Behold, a language so simple it does not throw errors at all! First off let me introduce 
you to the accumulator!
===The Accumulator===
This is an integer that can be incremented and decremented, at the start of each program it is zero!
===The Stack===
This stack stores integers. When it gets to a size of 100, it empties, that's it!
===Interpretation===
To interpret data, convert it to ASCII text, convert each character to an integer value, and apply a mod 7 operation to produce a sequence of numbers that correspond with commands.
===Commands===
Each instruction operates in isolation. Each command can run regardless of program state.
 0 - Increment the accumulator.
 1 - Decrement the accumulator.
 2 - Push the value of the accumulator on to the stack.
 3 - Pop value of of the stack and print it as an ASCII character. If the stack is empty, do nothing.
 4 - Print the absolute value of the accumulator as an ASCII character.
 5 - Set the accumulator to the value at the top of the stack and pop, if the stack is empty set to 0.
 6 - Increment the program counter by the value of the accumulator. It should wrap to the start and end as needed.
 7 - End program.