nyuuzyou/wikis huggingface dataset:
FHC

FHC is a joke language created by Mihai Popa. It's inspired by HQ9+. There are ONLY 3 commands in this language, and there are:
 Command list
Command	Meaning
F 	Execute the Fizz Buzz program
H 	Print "Hello, world!" to the console.
C 	Execute the Cat program
== Examples ==
=== Hello, world! ===
H
=== Fizz Buzz ===
F
=== Cat ===
C
== Interpreter ==
=== Batch ===
@echo off
title FHC Interpreter
:exe
cls
echo Type one of these characters (F, H, C) and we execute it...
set /p fhc=
if /i %fhc% EQU H goto hello
if /i %fhc% EQU C goto cat
if /i %fhc% EQU F goto fizzbuzz
cls
echo Error! You chose a wrong character. Only these are accepted: F, H and C
pause >nul
goto exe
:cat
cls
set /p cat=
echo %cat%
pause >nul
goto exe
:hello
cls
echo Hello, world!
pause >nul
goto exe
:fizzbuzz
cls
set num=1
goto fizzbuzzloop
:fizzbuzzloop
set /a modulobuzz=%num%%%15
set /a buzzmodulo=%num%%%5
set /a fizzmodulo=%num%%%3
if %modulobuzz% equ 0 (
set num2=Fizz Buzz! ^(%num%^)
) else if %buzzmodulo% equ 0 (
set num2=Buzz! ^(%num%^)
) else if %fizzmodulo% equ 0 (
set num2=Fizz! ^(%num%^)
) else (
set num2=%num%
)
echo %num2% >> paper.txt
set /a num=%num%+1
if %num% EQU 100 exit
goto fizzbuzzloop
Category:Joke languages
Category:Unusable for programming
Category:Languages
Category:Output only
Category:Implemented
Category:High-level
Category:2023
Category:Total
FHQ9+-

An extension of HQ9+- that adds the F operator to print FizzBuzz up to 100 by wyattscarpenter. - preceded by an F deferences a null pointer.
== See also ==
* HQ9+
* HQ9++
* HQ9+-
* HQ9F+
== External resources ==
* HTML/JS implementation by wyattscarpenter on github: code, interactive.
Category:Joke languages
Category:Unusable for programming
Category:Languages
Category:Output only
FIFOrth

==What is FIFOrth==
FIFOrth is my first esolang and it is basically Forth but with a queue (TIBO) instead of a stack (TITO). I am currently working on an interpreter, which I'll link when done.
It's gonna probably be hard to use since you cannot access any of the recently added values until you dequeue the ones before them.
I will edit this page as I will move forth with this project.
Category:Joke languages
Category:Queue-based
Category:2021
Category:Languages
FIFTH

FIFTH is a joke language created by John Unger Zussman, and is one of the lesser known programming languages. It was described in the Info World article as follows:
:FIFTH is a precision mathematical language in which the data types refer to quantity. The data types range from CC, OUNCE, SHOT, and JIGGER to FIFTH (hence the name of the language), LITER, MAGNUM, and BLOTTO. Commands refer to ingredients such as CHABLIS, CHARDONNAY, CABERNET, GIN, VERMOUTH, VODKA, SCOTCH and WHATEVERSAROUND.
:The many versions of the FIFTH language reflect the sophistication and financial status of its users. Commands in the ELITE dialect include VSOP and LAFITE, while commands in the GUTTER dialect include HOOTCH and RIPPLE. The latter is a favorite of frustrated FORTH programmers who end up using the language. 
Category:Joke languages
Category: Languages
FILO

FILO is a stack-based programming language. A FILO program consists of an expression.
==Syntax==
 program = expression;
 
 expression = "@"
 | "0"
 | expression, "*", expression
 | expression, "+", expression |
 | expression, "-", expression
 | identifier, "*", identifier, expression, ",", expression, ","
 | "[", definitions, "]", expression;
 
 definitions = definition, { definitions };
 
 definition = identifier, "=", expression;
Identifiers are consecutive sequences of non-whitespace characters, excluding @, 0, *, +, -, ,, [, ] and =. Whitespace separates identifiers and is otherwise ignored.
*, +, and - are right-associative and have equal precedence.
A , at the end of a definition or at the end of a program may be omitted.
Comments begin with == and extend to the end of the line.
==Expressions==
===Argument===
 @
The argument of the function.
===Empty===
 0
An empty stack.
===Push===
 x * y
A new stack with x pushed onto y.
===Top===
 x + y
The top element of x unless x is empty, then y.
===Pop===
 x - y
The stack consisting of x with its top element removed unless x is empty, then y.
===Apply===
 f*g x, y,
A new stack with the result of applying function f to top element of x pushed onto
the result of applying function g to x with its top element removed unless x
is empty, then y.
===Let===
 [f=x g=y]z
Defines f and g when evaluating z. This is a recursive let, so f
and g are defined for x and y as well.
==Input/Output Encoding==
How input and output are encoded is implementation-defined.
One possibility is for the argument and result to be interpreted as stacks of bits, where the each element of the stack is interpreted as 0 if it is empty, and interpreted as 1 if it is not empty, and the argument being constructed from the bits of the input, and the result being interpreted as the bits of the output.
==Examples==
These examples use the input/output encoding defined by the implementation
below.
===cat===
 @
===Hello world===
 [h=0*0*0*@*0*0*@*0 * @*0*@*0*0*@*@*0 * 0*0*@*@*0*@*@*0 * 0*0*@*@*0*@*@*0
 *@*@*@*@*0*@*@*0 * 0*0*0*0*0*@*0*0 * @*@*@*0*@*@*@*0 * @*@*@*@*0*@*@*0
 *0*@*0*0*@*@*@*0 * 0*0*@*@*0*@*@*0 * 0*0*@*0*0*@*@*0 * @*0*0*0*0*@*0*0
 *0*@*0*@*0*0*0*0] h*h 0*0*0,0,-0
==References==
* Implementation
Category:Languages
Category:Implemented
Category:Stack-based
Category:2021
Category:Functional paradigm
FISH WALKING 🚶

FISH WALKING 🚶 is a joke esolang made by User:MathR with a FISH WALKING 🚶.
== Commands ==
 OMG FISH WITH LEGS 👣 Initialize program
 FISH WALKING 🚶 Increment cell pointer
 WHO WILL IT EAT DOE 🤔 Inputs number of food in the cell
 FISH HUNGRY WHEN <NUMBER> FOOD 🍴 Sets the hunger threshold to <NUMBER>
 FISH DIE 💀 Interprets Deadfish
 FISH GET FOOD 😋 Increment number of food in the cell
 FISH UNGET FOOD 😔 Decrement number of food in the cell
 FISH SWIMMING NOOOOO 🏊 Decrement cell pointer
 FISH FLY TO <LINE> 🛫 Jumps to line <LINE>
 FISH TOO HUNGRY TO DO NEXT LINE LOL 🤣 Skips the next line if the number of food in the cell < the hunger threshold
 FISH SHOW HIS FOOD COLLECTION 👀 Outputs the number of food
== Why? ==
FISH WALKING 🚶 is based on a drawing made by User:Iamn00b.
Link to the image
== Example programs ==
 OMG FISH WITH LEGS 👣
 FISH DIE 💀
Deadfish interpreter
 OMG FISH WITH LEGS 👣
 FISH HUNGRY WHEN 1 FOOD 🍴
 WHO WILL IT EAT DOE 🤔
 FISH SHOW HIS FOOD COLLECTION 👀
 FISH TOO HUNGRY TO DO NEXT LINE LOL 🤣
 FISH FLY TO 4 🛫
Truth-machine
== Python interpreter ==
 import re
 
 with open(input("Filename: ")) as file:
 program = file.readlines()
 
 program_started = False
 hunger_threshold = 5
 
 TAPE_SIZE = 255
 cell_pointer = 0
 tape = [0] * TAPE_SIZE
 
 line_index = 0
 while line_index < len(program):
 line = program[line_index]
 if program_started:
 if line == "FISH WALKING 🚶\n":
 cell_pointer = (cell_pointer + 1) % TAPE_SIZE
 elif line == "FISH SWIMMING NOOOOO 🏊\n":
 cell_pointer = (cell_pointer - 1) % TAPE_SIZE
 elif re.match(r'^FISH HUNGRY WHEN [0-9]+ FOOD 🍴$', line):
 hunger_threshold = int(line[16:-8])
 elif line == "FISH TOO HUNGRY TO DO NEXT LINE LOL 🤣\n":
 if tape[cell_pointer] < hunger_threshold: line_index += 1
 elif line == "FISH GET FOOD 😋\n":
 tape[cell_pointer] += 1
 elif line == "FISH UNGET FOOD 😔\n":
 tape[cell_pointer] -= 1
 elif line == "WHO WILL IT EAT DOE 🤔\n":
 tape[cell_pointer] = int(input())
 elif line == "FISH SHOW HIS FOOD COLLECTION 👀\n":
 print(tape[cell_pointer])
 elif re.match(r'^FISH FLY TO [0-9]+ 🛫$', line):
 line_index = int(line[11:-2]) - 2
 elif line == "FISH DIE 💀\n":
 value = 0
 while 1:
 commands = input(">> ")
 for command in commands:
 if command == 'i':
 value += 1
 elif command == 'd':
 value -= 1
 elif command == 'o':
 print(value)
 elif command == 's':
 value *= value
 if value == -1 or value == 256:
 value = 0
 elif line == "OMG FISH WITH LEGS 👣\n":
 program_started = True
 line_index += 1
Category:LanguagesCategory:Joke languagesCategory:Implemented
FJ

FJ is a brainfuck equivalent by User:None1. Its aim is to have programs very easy to type in using a QWERTY keyboard.
==Commands==
Just like its name, FJ has only 2 valid symbols: f and j, it is case sensitive.
When typing a program in you computer, you just have to directly tap on the keys under your index finger, so it is easy to type.
Here is the brainfuck to FJ conversion table.
Brainfuck	FJ 	Description
fff 	Increment the memory cell under the pointer	
ffj 	Decrement the memory cell under the pointer	
, 	fjf 	Input a character and store it in the cell at the pointer
. 	fjj 	Output the character signified by the cell at the pointer
< 	jff 	Move the pointer to the left
> 	jfj 	Move the pointer to the right
[ 	jjf 	Jump past the matching jjj if the cell under the pointer is 0
] 	jjj 	Jump back to the matching jjf
==Example Programs==
===Cat Program===
 fffjjffjffjjjjj
===Hello World===
ffffffffffffffffffffffffjjfjfjffffffffffffjjfjfjffffffjfjfffffffffjfjfffffffffjfjfffjffjffjffjffffjjjjjfjfffjfjfffjfjffjjfjjfjfffjjfjffjjjjffffjjjjjfjjfjfjjjfjffjffjffjfjjffffffffffffffffffffffjjfjjffffffffffjjjfjjfjfjjjffffjfjjjfffjjffffffffffjjffjffjffjffjffjffjfjjffjffjffjffjffjffjffjffjfjjjfjjfjffffjjjfjfffffffjj
==Turing completeness==
Since brainfuck is Turing complete, FJ is.
==See also==
* Binaryfuck, a similar idea, but uses zeros and ones.
* Lazyfuck, also made for ease to type, it also inspired me to create this language.
* FlipJump, A one-instruction language, that its file extension (and sometimes a shorten name for it) is "fj".
Category:Brainfuck derivatives
Category:Languages
Category:Brainfuck equivalents
Category:Turing complete
FJZ

FJZ (Flip bit and Jump if not Zero) is OISC by User:ChuckEsoteric08.
Program works like this:
 a b
If both a and b is positive flip bit a and goto label b if not zero.
If only a is negative then create label b. If only b negative then output a and next 7 bits as ASCII character. If both negative halt the program
==NFJZ==
NFJZ is language based on FJZ, but it is more like ZISC instead of OISC. You need ot input memory, not program. Every second bit is command. If that bit is zero and next is also 0 then declare a label with name that is next 8 bit after zero that is before command, then ignore that bits. If bit 0 and next is 1 then goto label that is next 8 bits after that 1, ignore that bit. If command is 1 flip next bit.
Category:Languages Category:OISC
FLIPER

The FLIPER Computer is a computational model made by User:FireCubez with 6 commands.
== Commands ==
Command	Position	Action
F 	0 	Flips the program by shifting each position, so F becomes L, L becomes I, E becomes F etc.
L 	1 	Calculates the logical NAND of the program's instructions' positions modulo 2 at an index specified by the positions of the next 2 commands and stores it in the first specified value
I 	2 	Shifts the program's code to the left x times (overflows back to the right) where x is the next command's position
P 	3 	Copies a value from position x in the program code and stores it in y, where x and y are the next 2 commands' positions
E 	4 	If the next instruction is an R, change it to an E and shift the program's code to the left so as to skip executing that instruction, otherwise change it to an R.
R 	5+ 	NOP. When flipped by F, it doesn't wrap back, instead it just gets a position of 6 and so on, always staying an R instruction unless changed.
For control flow, the program loops infinitely
Any invalid command will make the machine halt when executed, but has a position considered to be it's ASCII value modulo 65
All "indexes" mentioned are 0-based
== Examples ==
NAND 2 values
 LGHNNN__
Replace __ with any 2 characters to NAND, result stored in the first _ after execution as "F" for false and "L" for true
Broken down:
 L (NAND)
 G (The value at pos 6)
 H (and at pos 7)
 NNN (NOPs, also make the program halt)
 __ (Spaces for result and input)
Category:Computational models
FRM

FRM, or Forced Runtime Manipulation is a language that requires runtime manipulation. Each line must be executed in its original state, and then after being manipulated. 
=== Code examples ===
<T>anyvar="something"; //Declare a new variable
%-1 <T> -> string; //% means replace, in this case <T> is replaced with string. The number after % is the line.
%-2 "something" -> "Hello, World!";
@execute //After % (or after a row of %) an execute has to follow, which calls the last line not starting with %
<T>novar="";
%-1 <T> -> string;
%-2 "" -> "."; //We need to declare novar, else we can not push it to the stack.
@execute
push novar; //Push
%-1 push -> pop;
%-2 novar -> anyvar;
%-3 pop -> print; //just for demonstration
@execute
thisisaline="line"; //if no type is specified, it MUST be a string
%-1 this -> string ;
%-2 isaline -> line; 
@execute
%-4 line -> line2;
@execute
//This would create three (thisisaline,line and line2) variables with same value.
Interpreters should look for things like this...
int x=5;
%-1 x -> dummy;
%-2 dummy -> x; 
@execute
... and should not allow such manipulations.
Category:Ideas
FROM HERE TO THERE

FROM HERE TO THERE is an esolang by User:PythonshellDebugwindow.
==Syntax==
Lines can be separated by \n, \r\n, \n , \r\n , ;, ; , ;\n, or ;\r\n where \r is CR and \n is LF, but \n is used on this page for consistency. Each line has the following syntax:
 FROM x TO y
x can be LINE, IN, a file, an integer, a string, or a variable, and y can be anything x can (minus IN) as well as OUT, ERR, and a variable expression (a binary math operator and its operands).
===Values of y===
Value of y 	Effect
LINE 	Unconditionally jump to 0-indexed line x
OUT 	Output x with a newline to STDOUT
ERR 	Output x with a newline to STDERR
A file 	Write x to file y without a newline
An integer 	For every defined variable V: if V is equal to x, set it to y
A string 	Same as if y is an integer
A variable 	Set the variable named y to x (initialize it if necessary)
A variable expression	For LHS (OP) RHS, set the variable named LHS to its offset for x (please see #Variables)
===Special values of x===
If x is equal to IN, then replace it with a line of user input read from STDIN as a string before executing the rest of the line. If it is equal to LINE, then replace it with the current 0-indexed line number.
==Variables==
FROM HERE TO THERE uses a reverse-operation notation to perform math on variables; standalone math is illegal. To create a variable myVar and set it to 20:
 FROM 20 TO myVar
To increment it by n:
 FROM myVar TO myVar - n
To decrement it by n:
 FROM myVar TO myVar + n
To multiply it by n:
 FROM myVar TO myVar / n
To divide it by n:
 FROM myVar TO myVar * n
==Literals==
Type 	Example
File 	<path/to/file.txt>
Integer 	123
String 	"Hello, World!"
Variable	myVar
==BNF==
<nowiki>
<program> ::= <line> ( <endl> <line> )*
<line> ::= "FROM" " "+ <from> " "+ "TO" " "+ <to>
<from> ::= "LINE" | "IN" | <file> | <int> | <str> | <id>
<to> ::= "LINE" | "OUT" | "ERR" | <file> | <int> | <str> | <id> | <varexpr>
<file> ::= "<" ( "~" | "." | <id> ) ( "/" <id> )* ( "." <id> )* ">"
<int> ::= DIGIT DIGIT*
<str> ::= "\"" ANY* "\""
<varexpr> ::= <id> " "? ( "+" | "-" | "*" | "/" ) " "? ( <id> | <int> )
<id> ::= LETTER-UPPER | LETTER-LOWER | "_" | id id
<newline> ::= ( "\r" | "\r\n" ) ( "\r" | "\r\n" )*
<endl> ::= ( ";" " "? | ";" <newline> | <newline> )
</nowiki>
==Examples==
===Hello, World!===
 FROM "Hello, World!" TO OUT
===Infinite cat===
 FROM IN TO OUT
 FROM 0 TO LINE
===Truth-machine===
 FROM IN TO n
 FROM "0" TO 6
 FROM "1" TO 4
 FROM n TO LINE
 FROM 1 TO OUT
 FROM 4 TO LINE
 FROM 0 TO OUT
===Variable operations===
This program creates a variable, initializes it to 7, sets it to 19, increments it, then divides it by 4 and prints its value.
 FROM 7 TO myVar
 FROM 19 TO myVar
 FROM myVar TO myVar - 1
 FROM myVar TO myVar * 4
 FROM myVar TO OUT
==Computational class==
FROM HERE TO THERE’s computational class is unknown.
==See also==
* THROW THIS TO THAT
==External links==
* Interpreter in Python
Category:2020 Category:Languages Category:Unknown computational class Category:Implemented Category:OISC
FROSTWIRE-666

FROSTWIRE-666 is a esolang created by User:Yayimhere. its some combinators for Combinatory logic. The name was chosen by ChatGPT when creating AI made dis, but has been used for this language instead.
== Combinators ==
FROSTWIRE-666 has these operators:
 K from SKI
 ʎ̥ x = B (K) x (S)
 ᶑ̊ x y = y x
 ɤ̞ x y=S (B x x x) (ꞎ y) #instead of θ in ꞎ its ᶑ̊
 ƛ x=x x
 ꞎ x y z=B (θ x y) x z
 ɯ̽ x y=(x y)
for θ (the Turing fixed-point combinator) see Combinatory_logic#Non-primitives.
== Computational class ==
A Turing complete SKI basis can be formed from these combinators:
* K = K
* ɯ̽ can function as the identity function I, if we limit ourselves to functions-which-take-one-argument, i.e.: Combinators. to make sure its always identity you can do ɯ̽ɯ̽
* S = ʎ̥ɯ̽ɯ̽, because ʎ̥ = BK(x)S = K(x(S)). With x = I, ʎ̥I = KS, and KS* = S (where * can be any argument)
== Implementations ==
* Python module (Gist)
Category:Languages
Category:Implemented
Category:Turing complete
Category:Functional paradigm
Category:2024
FUCK YOU VIBEZONDISCORD

FUCK YOU VIBEZONDISCORD is an esolang made by user:tommyaweosme
== commands ==
 just got banned on pixilart - increment command pointer
 the fun from my birthday a week ago has faded.... - decrement command pointer
 why is life still worth it? - do command at command pointer
 FUCK YOU VIBEZONDISCORD - go back to +
the command pointer starts as:
 +-[]<>.,
 ^
it loops so going back on + gives ,
== ascii loop ==
 why is life still worth it?
 just got banned on pixilart
 just got banned on pixilart
 why is life still worth it?
 FUCK YOU VIBEZONDISCORD
 the fun from my birthday a week ago has faded....
 the fun from my birthday a week ago has faded....
 why is life still worth it?
 the fun from my birthday a week ago has faded....
 the fun from my birthday a week ago has faded....
 the fun from my birthday a week ago has faded....
 the fun from my birthday a week ago has faded....
 why is life still worth it?
 FUCK YOU VIBEZONDISCORD
Category:Languages
Category:Turing tarpits
Category:Turning tarpits
FUNC

FUNC is a programming language made by me that uses functions
== Stuff ==
The stuff
=== Def Func ===
 (a = a) b #b
 def id a = a
 id b #b
=== Call Func ===
 (a = a) b #b
 id b #b, if you had the id function defined
=== Ω combinator ===
 def Ω (a = a a) (a = a a)
 Ω #max stack size (1024 bytes idk) exceeded
=== SKI ===
 def I (a = a)
 def K (a = (b = a))
 def S (a = (b = (c = a (c (b c)))))
 def true = K
 def false = K I
 def not = (B = B false true)
 def and = ((b = b) b) ((b = false) b)
 true and true #true
 not false #true
FURscript

FURscript is the programming language currently in development by Broken Angel. The structure is based off a mix of html, turbo pascal, and BASIC.
==Programming Principles==
The structure of a FURscript program is as follows:
*All code is to be in BLOCK CAPITALS
*All code is encased in [ ]
*Start the code for your program with [PROG]
*Start any procedures with [PSTART]
*Start any blocks of code with [BSTART]
*End your program with [ENDPROG]
*End blocks with [END]
*End Procedures with [PEND]
*Write procedures OUTSIDE of your program code
==Current Commands==
*[WRITE:"TEXT"] WRITES THE TEXT IN THE APPLICATION
*[KEYP] WAITS FOR KEYPRESS TO MOVE ONTO THE NEXT SECTION OF COMMAND
*[KEYP=ASCII] WAITS FOR KEYPRESS OF KEY WITH MATCHING ASCII TO MOVE ON (also responds to "ENTER" OR "ESC")
*[GOTOPOS X,Y] MOVES THE CURSOR TO A DEFINED POSITION
*[ALERTMSG="TEXT"] CREATES AN ALERT MSG BOX WITH TEXT YOU DEFINE
*[OPENDIR="DIRECTORY"] OPENS AN OBJECT IN THE DEFINED DIRECTORY (must have associated program)
*[SAVFIL="DIRECTORY","TEXT","FILETYPE"] SAVES TEXT INTO A DEFINED EXTENSION (must be a valid text file eg:doc,txt,rtf etc)
*[INTSOU="PITCH","LENGTH"] CREATES A SOUND WITH THE INTERNAL SPEAKER
*[SYSDIAG] CHECKS THE OS VERSION
*[DRVFREE="DIRECTORY"] CHECKS THE SPACE OF THE DRIVE (MB'S)
*[SYSDOWN] SHUTS DOWN THE SYSTEM BY MANUAL
*[PASSMSG="PASSWORD","CONDITIONS YES","CONDITIONS NO"] CREATES A PASSWORD BOX AND DEFINES THE CONDITIONS FOR A CORRECT AND INCORRECT PASSWORD.
*[OPENWEB="URL"] OPENS A WEBSITE WITH THE DEFINED URL
*[DIRFORMAT="DIRECTORY","BYPASSSECURITY?"] FORMATS A DRIVE AND ASKS WHETHER TO BYPASS ALL RESTRICTIONS
More commands will be published soon.
==Compilers==
Broken Angel is working on a simple compiler in Visual Basic. Einsidler does not approve of the idea.
Category:Languages Category:2006
F (None1)

It is a bf derivative. bf has 8 commands, but f has only 4.
==Commands==
f has these 4 commands and . They work like in brainfuck.
==Examples==
===Input a byte===
 ,
Since f has only half of the commands, the power of it is very limited.
==Interpreters==
===Python===
 import sys
 for i in input():
 if i==',':sys.stdin.read(1)
 if i==']':raise Exception('Unmatched ]')
==See also==
* b
Category:Languages
Category:Joke languages
Category:2024
Category:Total
Category:Input only
Category:Implemented
Category:Total
Category:Unusable for programming
Category:Brainfuck derivatives
Face

Face is a programming language that is made up of entirely faces, there are 16 faces in total and are used as commands and arguments or seperators. There is also one value int
Each face, apart from =( and ;) can either be a command or an argument. As arguments the faces turn into numbers or characters and are evaluated as a mathematical expression.
 
 :)
 1
 :(
 2
 :]
 3
 ;(
 4
 :P
 5
 ;P
 6
 XD
 7
 :D
 8
 ;D
 9
 :O
 0
 :o
 +
 ;O
 -
 ;o
 *
 =)
 /
And they can be used as commands as so:
 :) [faces] =(
 Prints out character that is passed in faces
 :( [faces] =(
 Prints out number that is passed in faces
 :] [faces] =(
 Prints out the face that was passed in
 ;( [commands] ;)
 Runs the commands inside the loop until the value is 0
 :P [faces] =(
 Sets value to the int passed in
 ;P =(
 Prints the value as a character
 XD =(
 Exits the program
 :D [faces] =(
 Prints charager that was passed in with newline at the end
 ;D =(
 Prints a newline
 :O [faces] =(
 Add int passed in to value
 :o [faces] =(
 Subtract int passed in from value
 ;O [faces] =(
 Multiplies int passed in and value
 ;o [faces] =(
 Divide value by int passed in
 =) =(
 Set value to int from character user inputs
And this is "Hello World!":
 :P :) :O :D =( :) XD :( =( :) :) :O :) =( ;P =( ;P =( :) :) :) :) =( :) :] :( =( :) :D XD =( :) :) :) :) =( :) :) :) ;( =(= ;P =( :) :) :O :O =( :D :] :] =(
Here Deobfuscated and with comments:
 :P :) :O :D =( <- Set value to "l"
 :) XD :( =( <- "H"
 :) :) :O :) =( <- "e"
 ;P =( <- Get value or "l"
 ;P =( <- Get value or "l"
 :) :) :) :) =( <- "o"
 :) :] :( =( <- " "
 :) :D XD =( <- "W"
 :) :) :) :) =( <- "o"
 :) :) :) ;( =( <- "r"
 ;P =( <- Get value or "l"
 :) :) :O :O =( <- "d"
 :D :] :] =( <- "!" with newline at the end
Here is the python interpreter.