nyuuzyou/wikis huggingface dataset:
Elog

Elog is a stackbased language that can be used to model logical circuits.
== Description ==
An Elog program takes a bitstring as input (for example "10101") and can output another bitstring. You can use a single character for a variable. The first variable that appears in the program gets bound to the first input bit, the second variable gets bound to the second input bit and so on.
== Commands ==
The commands at the moment:
* ' NOT gate
* & AND gate
* | OR gate
* ^ XOR gate
* . dup top stack item
* 0 push 0
* 1 push 1
* : pop bit and assign to next variable
* ; end program and print all variables (or 0 and 1) after ;
== Computational class ==
Since Elog has no way of performing loops, it is guaranteed to terminate. Otherwise, it is able to evaluate any combinational logic expression, as it is functionally complete.
== Examples ==
The following program will take 4 input bits and will output 1 bit, 1 if the number is a prime else 0. Notice how at the end of the program the result bit is assigned to z (:z) and how z is the only variable after ;. Als notice how a, b, c and d are the first variables used, this will ensure that a, b, c and d will be bound to the right input bits.
 ab'cd&&&ab'c&&bc'd&&a'cd&&|||:z;z
The following program will take 3 input bits and will multiply it by 2.
 abc;abc0
This simulates a 2 bit multiplexer, notice how the 3 variables appear before the actual program, this to ensure the proper input bits are bound to the proper variables.
 abs as'&bs&|:z;z
== Interpreters ==
* Java interpreter
* C# interpreter
Category:Languages
Category:Implemented
Category:Stack-based
Category:2011
Category:Total
Emanator

Emanator is an esolang invented by User:Hakerh400 in 2023.
== Overview ==
Source code consists of integers separated by dots.
Memory consist of a single tape, which can be represented as a function f:\mathbb N\mapsto\mathbb Z. All cells are initially 0, except the cells at addresses 0,\dots,n-1, which contain the source code, where n is the length of the source code. Here, by source code we mean the list of integers parsed from the source code and not the literal source code string.
Memory contains the entire program state. There are no external registers such as instruction pointer or data pointer.
If we want to access cell at address i, then there are two cases:
* If i\ge0, then we access cell i directly.
* Otherwise, let j be the value from cell -i-1. The result of accessing i is the result of accessing j. If accesses form a loop, then we either read from input (if we want to read a value), or write to the output (if we want to write a value).
Perform the following algorithm until the program outputs number 0. Let ip be the value from cell 0. Let dest be the value from cell ip (keep in mind indirect addressing explained above). Let op1 be the value from cell ip + 1 and op2 be the value from cell ip + 2. Write value ip + 3 to cell 0 and then write value op1 - op2 to cell dest.
If anything in this explanation is unclear, see the implementation for details.
== Examples ==
=== Cat program ===
 3.0.3.-4.-5.1.0.2.1
Explanation. The cell 0 contains value 3. It represents the initial value of ip (instruction pointer).
Each "instruction" is 3 cells long. Our first instruction is -4 -5 1. In pseudocode it means mem[-4] = mem[-5] - mem[1]. Of course, since memory contains only positive addresses, -4 and -5 represent indirect addressing, so we are effectively addressing -(-4)-1=3 and -(-5)-1=4, respectively. However, since mem[3] = -4 and mem[4] = -5, we have a cycle in both cases. We first evaluate operands, so mem[-5] resolves to the next character code from the input string. The second operand mem[1] directly resolves to 0. The result is C - 0 = C, where C is the next character code from the input (because the indirect addressing formed a cycle at mem[-5]). Finally, since mem[-4] also forms a cycle, we output the result C directly to the output stream.
Instruction pointer gets incremented by 3, so it becomes 6. The next "instruction" is 0 2 1. It means mem[0] = mem[2] - mem[1] = 3 - 0 = 3, so we write value 3 to the instruction pointer, effectively jumping back to the first instruction. We perform these steps until we read integer 0 (the end of input stream) and output it, which terminates the program.
== Computational class ==
This language is Turing-complete. We leave to the readers to figure out why.
== Implementation ==
Implementation
Category:Languages
Category:Turing complete
Category:Implemented
Category:2023
Embedded HQ9+

Embedded HQ9+ is a variant of HQ9+ designed for use on embedded systems. In order to better serve common usecases for embedded devices, such as blinking LEDs, it has its instruction set modified. Here are its commands:
All commands defined as printing something should display it on a screen if available, serial IO otherwise, or via any other form of IO (timed LED blinking?) if even that's not available.
* H: Print "Hello, World" 
* Q: Print the program's source code
* 9: Print "99 Bottles of Beer" - since embedded systems may have limited memory, this shorter string should assist in embedded system development
* +: Increment the accumulator
* B: Blink LED (I believe this is the #1 use case for embedded systems)
Category:Languages
Category:Joke languages
Category:2018
Category:Output only
EmiT

== emiT - a Time Traveling Programming Language ==
emiT is a language all about parallel timelines. At any given point you can send a variable back in time, and make it change things about the past, starting a new timeline where the result is different.
You can kill variables, which destroys them permanantly- at least until you send another variable back in time to kill the variable doing the killing. This very quickly leads to a lot of confusion, with a constantly changing source code and the very easy possibility of creating a paradox or a time loop.
Remember, the timeline doesnt reset when you go back, any changes made before will remain until you go back even further to stop them from happening. 
Therre are a few unusual keywords for this language, shown here:
 Keywords
Keyword 	Meaning
create x 	Makes a new variable x
x kills y 	x 'kills' y, making it unable to affect the scope anymore
time x 	Defines x as a point in time to jump back to later
x warps y {}	x travels back in time to point y, and inserts the actions within the code block
collapse 	Collapses and destroys the current timeline
x is y 	Gets property y from variable x
Every variable also has properties, which can be accessed using the 'is' keyword.
 Properties
Keyword	Meaning
alive 	Is a variable alive?
dead 	Is a variable dead?
exists 	Has this variable ever existed in this timeline?
The language git repo can be found here 
https://github.com/nimrag-b/emiT-C
Category:Languages Category:Implemented Category:2024 Category:Unknown computational class
Emmental/emmental.ml

:
An Emmental interpreter in Ocaml, written by User:Koen in 2012.
==Overview==
val s : int Stack.t
val q : int Queue.t
val mci_main : (int * int list) list ref
val find : ('a * 'b) list -> 'a -> ('b * ('a * 'b) list) option
val pushnumber : int -> unit
val ( mod ) : int -> int -> int
val log2 : int -> int
val pop_a_program : int list -> int list
val supplant : unit -> unit
val execute_init : int -> unit
val execute : (int * int list) list -> int -> unit
The meta-circular interpreter is stored as a list of pairs (symbol, definition); the empty list represents the initial mci. When a symbol is executed, the function find looks for it in the mci, and returns the list of symbols it was defined as, along with the mc interpreter that was used at the time of that definition (which happens to be the remaining of the current interpreter, when everything above the definition has been discarded).
Note that input doesn't handle end of file.
===Example (cat program)===
ocamlc -o emmental emmental.ml
echo 'Hello, World!' | ./emmental ';#44#46#35#52#50#63#42!*'
:Hello, World!
:Fatal error: exception End_of_file
echo 'This is not a real cat.' | ./emmental ';#44#94#44!;#118#46#46!,,,,,,,,,,,,,,,,,,,,,,,,........................'
:This is not a real cat.
==Source==
let s = Stack.create ()
let q = Queue.create ()
let mci_main = ref []
let rec find mci c =
 match mci with
 | (hc, hl) :: t -> if hc = c then Some (hl, t) else find t c
 | [] -> None
let pushnumber c =
 Stack.push ((Stack.pop s * 10 - 48 + c) mod 256) s
let (mod) a b = let m = a mod b in if m < 0 then m + b else m
let rec log2 n =
 if n < 0 || n > 255 then log2 (n mod 256)
 else if n = 0 then 8
 else if n = 1 then 0
 else if n < 4 then 1
 else if n < 8 then 2
 else if n < 16 then 3
 else if n < 32 then 4
 else if n < 64 then 5
 else if n < 128 then 6
 else 7
let rec pop_a_program acc =
 let c = (Stack.pop s) in
 if c = 59 then acc else pop_a_program (c :: acc)
let supplant () =
 let c = (Stack.pop s) in
 let t = pop_a_program [] in
 mci_main := (c, t) :: !mci_main
let rec execute_init c =
 match c with
 | 35 (* # *) -> Stack.push 0 s
 | c when 47 < c && c < 58 -> pushnumber c
 | 43 (* + *) ->
 let x = Stack.pop s in let y = Stack.pop s in
 Stack.push ((x + y) mod 256) s
 | 45 (* - *) ->
 let x = Stack.pop s in let y = Stack.pop s in
 Stack.push ((y - x) mod 256) s
 | 126 (* ~ *) -> Stack.push (log2 (Stack.pop s)) s
 | 46 (* . *) -> print_char (Char.chr (Stack.pop s))
 | 44 (* , *) -> Stack.push (Char.code (input_char stdin)) s
 | 94 (* ^ *) -> Queue.push (Stack.top s) q
 | 118 (* v *) -> Stack.push (Queue.pop q) s
 | 58 (* : *) -> Stack.push (Stack.top s) s
 | 33 (* ! *) -> supplant ()
 | 63 (* ? *) -> execute !mci_main (Stack.pop s)
 | 59 (* ; *) -> Stack.push 59 s
 | _ -> ()
and execute mci c =
 match find mci c with
 | Some (m, mci_) -> List.iter (execute mci_) m
 | None -> execute_init c;;
let p = Sys.argv.(1) in
for k = 0 to String.length p - 1 do
 execute !mci_main (Char.code p.[k])
done;;
==See also==
* Emmental
Category:Implementations
Emoji

Emoji is a stack-based esoteric programming language that uses emoji to manipulate the stack. In most cases, non-emoji characters are ignored.
==Tokens==
 💬: Read until the next 💬 and puts that string onto the stack
 ⛽: Reads until the next 🚘 and puts that string onto the stack (can be nested, meant for storing functions)
 ➡: Prints a value from the stack
 🚲: Puts True onto the stack
 🚳: Puts False onto the stack
 🚴: Inverts a boolean value from the stack
 👫: Adds two numbers from the stack
 👪: Multiplies two numbers from the stack
 🌊: Subtracts two numbers from the stack
 🍴: Divides two numbers from the stack
 💸: Divides two numbers from the stack, returns the remainder
 💿: Rounds a number to the nearest integer
 📥: Rounds down a number from the stack
 📤: Rounds up a number from the stack
 🐂: Converts a number to a hex string
 🔢: Converts a string to a number
 👬: Checks if two numbers are equal
 🐣: Checks if a number is less than another
 🐔: Checks if a number is greater than another
 🔚: Takes a boolean from the stack. If false, skips to the next 🐧.
 🔙: If the last 🔚 did not skip past stuff, skip to the next 🐧.
 🔃: Takes two strings from the stack. Runs the first, takes a boolean. If true, runs the second and repeats.
 👥: Duplicates a stack entry
 🔣: Converts a character to its character code
 🔍: Converts a character code to its character
 📲: Takes two objects, saves the first to a variable identified by the second
 📱: Takes an object, returns the value from the variable by that name
 📃: Returns the length of a string or array from the stack
 ✂: Takes a string and two numbers. Returns the substring from the string from the first number (inclusive) to the second number (exclusive).
 🏃: Evaluates a string
 📚: Creates an empty array.
 📌: Takes an array and an object. Adds the object to the end of the array. Does not return anything, you'll want to use variables with this.
 🔑: Takes an array or string and an index. Returns the value at that index.
 🔀: Swaps two elements on the stack.
 🔊: Capitalize a string.
 🔉: Change a string to lowercase.
==Examples==
===Hello World===
 💬Hello World💬➡
==See also==
* Emojicode
* Emoji-gramming
==External resources==
* An Emoji interpreter written in python
Category:LanguagesCategory:2015Category:ImplementedCategory:Unknown computational classCategory:Output only
Emoji-gramming

Emoji-gramming (proper name 💻) is a simple emoji-based esolang.
===Variables===
There are 24 normal variables, each indicated by a specific emoji:
♈ ♉ ♊ ♋ ♌ ♍ ♎ ♏ ♐ ♑ ♒ ♓(Aries Taurus Gemini Cancer Leo Virgo Libra Scorpio Saggitarius Capricorn Aquarius Pisces)
🕐 🕑 🕒 🕓 🕔 🕕 🕖 🕗 🕘 🕙 🕚 🕛(Look at the clock by yourself)
All 24 store unbounded, signed, integers and are initialized to 0.
There is 1 special variable: 🚨
It is the Instruction Counter and stores the current line number being run.
Lines without commands are still counted.
It can be used like any other variable.
Setting it to another value jumps code execution to that line.
The Instruction Counter starts at 0 and increases by 1 before each command.
===Commands===
There are four commands; each command must be on its own line.
Any line that doesn't start with a command is treated as a comment.
The first command is on line 1.
In all commands, replace 🔳 and 🔲 with variables.
😊🔳🔲 Set 🔳 to 🔲.
😇🔳🔲 Set 🔳 to 🔳 plus 🔲.
😈🔳🔲 Set 🔳 to 🔳 minus 🔲.
😵🔳🔲 If 🔳 equals 🔲, skip the next command.
===Constants===
Hearts can be used as constants, as desired.
Use a constant instead of variable 🔲.
💔 is 0
💜 is 1
💕 is 2
💞 is 4
💖 is 8
===Input/Output===
Input and Output can only be used as part of 😊 commands, replacing the indicated variable. Using both in the same command is forbidden.
🎤 Replace 🔲; input one ASCII/Unicode character and store value into variable 🔳.
📢 Replace 🔳; output the ASCII/Unicode character matching variable 🔲.
===Sample Code===
Cat:
 😊♒🎤
 😵♒💔
 😵♋♋
 😇🚨💕
 😊📢♒
 😊🚨💔
Hello world:
 😊🕐💖
 😇🕐🕐
 😊🕑🕐
 😇🕑🕑
 😊🕒🕑
 😇🕒🕒
 😊♈💖
 😇♈🕒
 😊📢♈
 😊♈💜
 😇♈💞
 😇♈🕑
 😇♈🕒
 😊📢♈
 😊♉💞
 😇♉💖
 😇♉🕑
 😇♉🕒
 😊📢♉
 😊📢♉
 😊♊💜
 😇♊💕
 😇♊💞
 😇♊💖
 😇♊🕑
 😇♊🕒
 😊📢♊
 😊♈💞
 😇♈💖
 😇♈🕑
 😊📢♈
 😊📢🕑
 😊♈💜
 😇♈💕
 😇♈💞
 😇♈🕐
 😇♈🕒
 😊📢♈
 😊📢♊
 😊♈💕
 😇♈🕐
 😇♈🕑
 😇♈🕒
 😊📢♈
 😊📢♉
 😊♈💞
 😇♈🕑
 😇♈🕒
 😊📢♈
 😊♈💜
 😇♈🕑
 😊📢♈
 😊♈💖
 😇♈💕
 😊📢♈
A+B problem, only supports one-digit numbers separated by any character:
 😊♊🎤
 😈♊💖
 😈♊💖
 😈♊💖
 😈♊💖
 😈♊💖
 😈♊💖
 😊♎🎤
 😊♎🎤
 😇♊♎
 😊📢♊
Because of a bug in the interpreter, the input command only reads the first character in each line, so you can remove line 8 to get a better experience, but I found a way to fix the bug in talk page.
===See also===
* Emojicode
* Emoji
===Interpreter===
* Python Interpreter
* Online interpreter (TIO)
Category:Languages
Category:2017
Category:Implemented
Category:Turing complete
EmojiCoder

EmojiCoder is an esoteric programming language that uses emoji to represent commands and arguments. Designed and created by Sarah Nathanson and Jeremey at HackRPI 2015. Lines of code are formatted as [command][modifier][parameter][new-line] .
==Language==
===Commands=== 
👇: push [param] on to the stack 
👆: pop off the stack 
✋: output top item on stack 
👋:	output [param] 
📦: set accumulator [param] 
➕ : add [param] to accumulator 
➖ : subtract [param] from accumulator 
➗ : divide accumulator by [param] 
✖ : multiply accumulator by [param] 
📫: output accumulator 
📝: output newline 
🔻: push accumulator on to the stack 
🔺: set accumulator to the top of the stack 
🎒: set x to [param] 
🚥: push x on to stack 
🚦: set x to the top of stack
🔹: set x to accumulator 
🔸: set accumulator to x 
➕✖: add x to accumulator 
➖✖: subtract x from accumulator 
➗✖: divide accumulator by x 
✖✖: mulitply accumulator by x 
📪: output x 
🔛: compares x to a 
* if param=0 in binary, < 
* if param=1 in binary, = 
* if param=2 in binary, > 
* if statement is true, compile next line else skip 
🔁: repeat next line [param] times 
📧: set stringbuilder to [param] 
📥: add [param] to stringbuilder 
📤: remove last character from stringbuilder 
📨: output stringbuilder
🙈: pushes random num zero to [param] on to stack
🙉: sets x to random num zero to [param]
===Modifers===
🔡: Ascii Character 0-255 
🔢: Integer Number 0-255
===Parameters===
As binary where 🌚=0 and 🌝=1 
Ex: 🌚🌝🌚🌚🌚🌚🌚🌝 
=0100 0001 
=65 
="A"
===Variable Reference===
Stack: An implementation of a stack
 
Has operations push and pop 
Accumulator: Used to store and do arithmetic on a number 
X: Used to temporarily store a number 
String builder: Used to store and build up a string
===Comments===
Comments are in progress 
On lines which take parameters putting //comment on the end is 👌
==Examples==
===Hello World!===
 👋🔡🌚🌝🌚🌚🌝🌚🌚🌚 //Output H 
 👋🔡🌚🌝🌝🌚🌚🌝🌚🌝 //Output e 
 👋🔡🌚🌝🌝🌚🌝🌝🌚🌚 //Output l 
 👋🔡🌚🌝🌝🌚🌝🌝🌚🌚 //Output l 
 👋🔡🌚🌝🌝🌚🌝🌝🌝🌝 //Output o 
 👋🔡🌚🌚🌝🌚🌝🌝🌚🌚 //Output , 
 👋🔡🌚🌚🌝🌚🌚🌚🌚🌚 //Output space 
 👋🔡🌚🌝🌝🌝🌚🌝🌝🌝 //Output w 
 👋🔡🌚🌝🌝🌚🌝🌝🌝🌝 //Output o 
 👋🔡🌚🌝🌝🌝🌚🌚🌝🌚 //Output r 
 👋🔡🌚🌝🌝🌚🌝🌝🌚🌚 //Output l 
 👋🔡🌚🌝🌝🌚🌚🌝🌚🌚 //Output d 
 👋🔡🌚🌚🌝🌚🌚🌚🌚🌝 //Output !
==External resources==
 contains an interpreter, about and reference pages, and example programs.
Category:LanguagesCategory:ImplementedCategory:2015Category:Stack-based
EmojiGolf

EmojiGolf is a golfing language invented by User:LEOMOK which uses emojis as commands. It was inspired by 05AB1E, Emojicode, !aoQ): and many others.
== Data Types ==
 Type How to push Notes
 Number -1,234.56 
 String 🔤Hello, World!🔤 As in 05AB1E, numbers and strings are equal types.
 🔣f (one char strings)
 Array 📁1➡️2➡️3➡️🔤text🔤➡️ 📁 pushes an empty list, and ➡️ adds an item to the list.
== Commands ==
 ➕ Pop a, b, push a plus b
 ➡️ Pop a, b, append a to b
 🔗 Pop a, b, push a concatenated to b
 ➖ Pop a, b, push a minus b.
 ✖️ Pop a, b, push a times b.
Category:Golfing_language
Category:Languages
EmojiLang

EmojiLang is an esoteric programming language made by NumberBasher in 2022. 
==Made by==
User:NumberBasher
== What it is ==
Simple Substitution For Python
== Instructions ==
Set Mods : 🔸,🔹,"" (null)
Set Nums :1️⃣2️⃣3️⃣4️⃣5️⃣6️⃣7️⃣8️⃣9️⃣0️⃣ and 🔟 (for 0️⃣)
print: ⤵️	False: 🆖
input: ⤴️	True: 🆗
if: 🔂		Numbers: Set Mods + Set Nums
elif: 🔀	Comment: #️⃣
else: 🚮	Decimal Point: *️⃣
for: ↔️		open: 🆕
while: 🔁	': 🔡
break: ↪️	": 🔠
read: ▶️	+-*/^%: ➕➖✖️➗🔝💲
close: ⏏️	_: 〰️
quit: ⏹	space: ➰
zip: ↕️		tab:➿
raise: ℹ️	return: 🔚
map: 🔣		(): ➡️⬅️
__: 👁‍🗨
;: 🔛
:: ©️
new line: ®️
/\: ↙️↘️
<=>: ⏪⏸⏩
!?: ❗️❓
,: 💢
Letters: 	💟☮️✝️☪️🕉☸️✡️🔯🕎☯️☦️🛐⛎♈️♉️♊️♋️♌️♍️♎️♏️♐️♑️♒️♓️⚛️
for 		A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
LOWERCASE: 🅰️ or 🔸 or 🔹
UPERCASE: 🅱️ or 🔶 or 🔷
i.e. 🅰️⚛️ for "z"
Another way for letters and numbers: 
ABCDEF		❤️	+	❤️🧡💛💚💙💜
GHIJKL		🧡	+	❤️🧡💛💚💙💜
MNOPQR		💛	+	❤️🧡💛💚💙💜
STUVWX		💚	+	❤️🧡💛💚💙💜
YZ0123		💙	+	❤️🧡💛💚💙💜
456789		💜	+	❤️🧡💛💚💙💜
i.e. 🔶🧡🧡 for "H"
It is a common practice to use different colors for different 
Any Letter: 
🆔 + unicode of character in binary filled to 24 digits: 
🈶 - 1
🈚️ - 0
== Examples ==
Hello World: 
⤵️➡️🔠🅰️🔯🅱️🕉🅱️🛐🅱️🛐🅱️♉️💢➰🅰️♑️🅱️♉️🅱️♌️🅱️🛐🅱️☪️❗️➰🔠⬅️
or
⤵️➡️🔠🔶🧡🧡H🔹❤️💙e🔹🧡💜l🔹🧡💜l🔹💛💛o💢,➰space
🔶💚💙W🔹💛💛o🔹💛💜r🔹🧡💜l❤️💚d❗️!➰space🔠⬅️
Note that all
normal characters (see appendix A) will be comments. To declare other symbols as comments, use #️⃣ and emojis after it will not render: ▶️6️⃣*️⃣7️⃣*️⃣6️⃣8️⃣6️⃣▶️▶️7️⃣. Returns must be declared, this is all in one line. ®️This is a new line. ®️This is another line. 
To add the symbol to the comment, use ❤️‍🔥®️. To add ❤️‍🔥, use ❤️‍🔥❤️‍🔥. To add ❤️‍🔥❤️‍🔥, use ❤️‍🔥❤️‍🔥❤️‍🔥❤️‍🔥, et cetera. 
Appendix A: NORMAL CHARACTERS
The following are normal characters: 
Basically, all numbers, letters,`-=[]\;',./,and option+them, shift+them, option+shift+them.
qwertyuiopasdfghjklzxcvbnm (lower alphabet)
QWERTYUIOPASDFGHJKLZXCVBNM (upper alphabet)
1234567890 (1~0 number)
!@#$%^&*() (shift + number)
~`_+-={}|[]\:";'<>?,./ (more symbols)
¡™£¢∞§¶•ªº⁄€‹›FIFL‡°·‚ (opt+(s)+number)
–≠“‘«…æ≤≥÷ —±”’»ÚÆ¯˘¿ (opt+(s)+symbol)
èéêëēėęÿûüùúūîïíīįìôöòóœøōõ (eyuio derived)
àáâäæãåāßśšłžźżçćčñń (aslzcn derived)
œ∑´®†¥¨ˆøπå∂ƒ©˙∆˚¬Ω≈ç√∫˜µ (option+letter*)
Œ„‰ÁØ∏ÅÍÎÏ˝ÓÔÒ¸˛Ç◊ıÂ (opt+s+letter**)
all whitespace: space,\t,\n (..............)
*:	no "option+s" because it is ß, s derived. 
**:	a lot are duplicates of option+letter. 
==Implementations==
No implementation, because a) I am lazy and b) dealing with emojis is a PAIN. 
Category:Languages Category:Unimplemented Category:Turing complete Category:High-level Category:2022
EmojiLang (Mihai Popa)

EmojiLang is a esolang made by Mihai Popa, based on only emoji. :)
== Commands ==
 Command list
Emoji 	Meaning
🖨️🔡Something🔡 	Prints a text string
🖨️Variable 	Prints a variable
❔Variable 	Asks for user input
5➕5➡️Variable 	Adds two numbers and stores the result in a variable (you can do also with more numbers, like three/four/five numbers, etc...)
5➖5➡️Variable 	Subtracts two numbers and stores the result in a variable (you can do also with more numbers, like three/four/five numbers, etc...)
5✖️5➡️Variable 	Multiplies two numbers and stores the result in a variable (you can do also with more numbers, like three/four/five numbers, etc...)
5➗5➡️Variable 	Divides two numbers and stores the result in a variable (you can do also with more numbers, like three/four/five numbers, etc...)
⁉️Truth🟰5 	If expression
🎌⁉️Truth🟰5 	Else If
🎌 	Else
❓Truth🟰5 	While loop
🛑❓ 	Stop while loop
🔁 	Start loop
🛑🔁 	Stop loop
Variable🟰🔡Hello🔡 	Sets a variable to a value
💬This is a comment, any text goes here 	Marks a single line comment
== Syntax==
It's like a simplified version of BASIC, using only emoji. Wrap the value in this emoji: "🔡" if you want a text string, otherwise it would be a number. Comments don't require that emoji for text strings.
Comments are marked with this syntax:
💬This is a comment, any text goes here
Multi-line comments are supported! See this syntax:
🏁💬
This is a comment, any text goes here
Bla bla bla
Lorem ipsum dolor sit amet!
The quick brown fox...
💬🔚
Also nesting is supported. Example syntax:
🏁💬
This is a comment, any text goes here
Bla bla bla
🏁💬
Lorem ipsum dolor sit amet!
🏁💬
Hello,
World!
🏁💬
Deși acest limbaj de programare 
acceptă adnotări imbricate, 
tot nu recomandăm utilizarea acestei sintaxe.
💬🔚
💬🔚
The quick brown fox...
💬🔚
💬🔚
== Examples ==
===Hello, world!===
🖨️🔡Hello, world!🔡
===Cat===
❔Cat
🖨️Cat
===XKCD Random Number===
🖨️🔡4🔡
===Truth Machine===
Note that this is the longest program in this language...
💬This is a Truth Machine in EmojiLang!
❔Truth
⁉️Truth🟰0
🖨️Truth
💬This is the first part, when the user types "0" and it prints "0".
❓Truth🟰1
🔁
🖨️🔡1🔡
🛑🔁
💬This is the second part, when the user types "1" and loops printing "1".
Category:Languages
Category:2024
Category:High-level
Category:Unimplemented