nyuuzyou/wikis huggingface dataset:
∫【0……10】（C²+3C+2）dC

== Introduction ==
 is a joke language which is similar to C++, but more compliacted. You can simply call this language integral from zero to ten of C to the power of two plus three multiplied by C and add two which the variable is C, or IFZTTOCTTPOTPTMBCAATWTVIC for short, or IFZ2TOC2TPOTPTMBC2ATWTVIC.
And, everyone knows that equals to 1750/3.
== Commands ==
Every character in the original C++ is changed into a statement in IFZTTOCTTPOTPTMBCAATWTVIC.
And we all know that every char has a unicode code. From all the characters in C++, which are:
* [Space] - 32,! - 33," - 34,# - 35,$ - 36
* % - 37,& - 38,' - 39,( - 40,) - 41
* * - 42,+ - 43,, - 44,- - 45,. - 46
* / - 47,0 - 48,1 - 49,2 - 50,3 - 51
* 4 - 52,5 - 53,6 - 54,7 - 55,8 - 56
* 9 - 57,: - 58,; - 59,< - 60,= - 61
* > - 62,? - 63,@ - 64,A - 65,B - 66
* C - 67,D - 68,E - 69,F - 70,G - 71
* H - 72,I - 73,J - 74,K - 75,L - 76
* M - 77,N - 78,O - 79,P - 80,Q - 81
* R - 82,S - 83,T - 84,U - 85,V - 86
* W - 87,X - 88,Y - 89,Z - 90,[ - 91
* \ - 92,] - 93,^ - 94,_ - 95,` - 96
* a - 97,b - 98,c - 99,d - 100,e - 101
* f - 102,g - 103,h - 104,i - 105,j - 106
* k - 107,l - 108,m - 109,n - 110,o - 111
* p - 112,q - 113,r - 114,s - 115,t - 116
* u - 117,v - 118,w - 119,x - 120,y - 121
* z - 122,{ - 123,| - 124,} - 125,~ - 126
But!!! You can't just replace the original code with these numbers. You need to write them in some strange statements. For example, o(111) should be writen in 
 3*((3/2∫31xdx)2+1)
Or this
 ∑n=115n-32
Or this
 2*(((1+1+1+1+1)+(1+1+1+1+1)+(1+1+1+1+1))+((1+1+1+1+1)+(1+1+1+1+1)+(1+1+1+1+1))+((1+1+1+1+1)+(1+1+1+1+1)+(1+1+1+1+1))+((1+1+1+1+1)+(1+1+1+1+1)+(1+1+1+1+1)))-32
You need to seperate the statements with a [Space].
== Example ==
=== Output 'a' ===
 34+1 104+1 110+1 98+1 107+1 116+1 99+1 100+1 61-1 98+1 114+1 115+1 99+1 104+1 110+1 61+1
 108+1 96+1 104+1 109+1 41-1 40+1 122+1 111+1 113+1 104+1 109+1 115+1 101+1 41-1 38+1 98-1 40-1 40+1 58+1 53
It can be converted into:
 #include<cstdio>
 main(){printf('a');}
Of course, the code is not the only one.
Category:Languages
Category:Joke languages
Category:Turing complete
Category:Object-oriented paradigm
⊗

⊗ (or Signs) is a esoteric programming language created by User:Ractangle where road signs are used as code. The syntax is quite similar to python btw
==Syntax==
=== Commands ===
Command 	Action
Start of road	Start the program.
End of road 	End the program.
Give way 	(sorta) a conditional.
Exit road 	Goes back to executing code.
End road 	Function definition.
Path 	Creates a variable.
Rider-path 	Edits a variable.
Road one-way 	Function execution.
Do not enter 	Comment.
Area 	String.
Locality 	Strings with variables.
Parking 	Prints the string next to it.
Built-in 	Char.
Signal 	Input.
=== Errors ===
Error 	Meaning
"No priority input" 	The command "Start of road" needs to be written at the beginning of the code
"No entry" 	The function doesn't contain a "Exit road"
"No priority workables"	The code doesn't have anything else other than starting and halting
"Invalid argument" 	An argument is empty or invalid
== Examples ==
It's kind of hard to write non-basic programs without an interpreter.
=== Hello, world! ===
 Start of road
 Parking Area 'Hello World'
 End of road
=== Cat program ===
 Start of road
 Path i Signal
 Parking Locality '{i}'
 End of road
===Truth-machine===
 Start of road
 Path x Signal>Interger
 Give way x is 0
 Parking Area '0'
 End of road
 Else
 Parking Area '1'
===A+B Problem===
 Start of road
 Path a 0
 Path b 0
 Rider part a Signal>Interger
 Rider part b Signal>Interger
 Path r a+b
 Parking Locality '{r}'
 End of road
Category:Languages
Category:High-level
Category:2024
Category:Thematic
Category:Unimplemented
⊥

⊥(pronounced true) is an very simple esolang created by User:Yayimhere which is based on HAHAHA. it was created since no other esolangs create esolangs from random bullshit
== syntax ==
"a program is filled with sections that begin with [, end with ], where each section has comma-separated strings(no qoutes). and then the program thinks of the last string of the list is the program of a programming language created with axioms where the axioms are all the other than the program. it will give an error if the program isnt that kind of list and print this:
 ERROR. wrong program type {}
== examples ==
quine:
 ERROR. wrong program type {}
Category:Languages Category:2024
█

Made by Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff (talk) 03:41, 23 September 2024 (UTC)
==Cmds==
☭ Bomb the world using Russia
+ Make it Turing Complete
- English || Spanish
¡! Infinite Loop
Ꮇ Gain Omincience
⨧ 2-Arity Addition
性 69
【】 Print
` fString 
〷 Exponents
ꜳ Clean up bad code
◧◨ Brackets
⅀ Guass Sum
⍳ ⍳nterger
␦ Don't
⏨ Convert 10 to 10
⍴ Input
⍵ Prepend '-' if Operator == '-'
⍥ Input/Read Operator
΅ Solve the Halting Problem
█ Bigot Program
N Narcissist
ℚ Quine
⁋ English:
|| or | (Bitwise|Logical) OR
í Spanish
¿? While Loop
𝟘 And We Will End!
𝟙 You have not Win!
𝟚 Part 2?
𝟛 NOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO
𝟜 You Died
𝟝 JAJAJAJAJA
¦ Half Broken Or in Heavy Traffic (HBCHT with Bitwise Operators)
÷ Division
«» Bit Shift
⁋«» Bit Shift
ⅈ imaginary noomberre
╬ Pythonic!!!
⩓ assert, and ByeBye if no.
∈ in, also self-describing
ႈ clear
𝔹 bottles of beer ont ehw all
<> Tape Management
ᴟ Put into tape,
ᴞ Read from tape
↝ Don't eval
⩶ or ⩵ Equal (Too strict, too lose)
� Reverse
ℝ repr
ℂ ℂontinue +x or break -x
𝔻 Break, then continue
⅟ 1/x
🙹 Undescribable
∫ Random number from (x, y) 
_ floor funion
==Programs==
===^ Interpreter===
 ⁋`╬for`◧𝟜$i∈⍥◨◧¿◧⁋$i█〷◨◧΅⁋ℚ∈⍥◨?◨
===Hello, World! Program:===
 【`Hello, World!`】
===Quine===
 【ℚ】
===Cat Program===
 【⍴】
===A+B Problem===
 【⍴⨧⍴】
===Calculator===
 ⍥>ᴟᴞ〷ᴞ¿【⍴⨧⍵⍴】𝟘?>⁋`÷`█⁋⍥¿【⍴÷⍴】𝟘?【⍴÷⅟⍴】
===HQ9+===
 ⁋`╬for`◧𝟜$i∈⍥◨◧⁋ᴞ█⁋`H`¿【`Hello, World!`】𝔻?⁋ᴞ█⁋`Q`¿【⍥】𝔻? ⁋ᴞ█⁋`9`¿⍳`99`𝔹𝔻?⁋ᴞ█⁋`+`¿ᴟᴞ⨧⍳`1`𝔻?◨
===Print Out 1===
 【⍳◧-█⁋||í◨】
===0 Interpreter===
 ⁋`╬for`◧𝟜$i∈⍥◨◧¿◧⁋$i█`0`◨◧【⁋$all█🙹】◨?◨
=== Russian Roulette ===
 ☭␦_◧ᴞ∫⍳`3`◨ᴟ¿+?𝟜
==See also==
* █ but with only plausible commands
==Caetergryrpo==
Category:Uncomputable
Category:Languages
Category:2024
Category:Joke languages
█ but with only plausible commands

█ but with only plausible commands is a derivative of █ but all the commands that can't be reasonably coded simply provides an error
==Commands==
☭ "This program is unable to bomb the world using only Russia"
+ "No language can ever be truly complete"
- "English only, no spanish"
¡! Infinite loop
Ꮇ "Computer programs can not gain omnipresence" 
⨧ 2-Arity Addition (basically a fancier way of saying addition, as addition is always 2-arity)
性 Prints the number 69
【】 Prints the string inside
` fString 
〷 Exponents
ꜳ "How would I know what code is bad myself?"
◧◨ Brackets (?)
⅀ Guass Sum
⍳ ⍳nterger
␦ "Unknown command"
⏨ Convert 10 to 10
⍴ Input
⍵ Prepend '-' if Operator == '-'
⍥ Input/Read Operator
΅ "The halting problem can not be solved by a simple command, or even any set of commands. Think harder."
█ "A bigot program can not be created by a simple command, or even any set of commands. Think harder."
N Narcissist (a bigot program may not be able to exist, but a narcissist sure can)
ℚ Quine
⁋ English:
|| or | (Bitwise|Logical) OR
í Spanish
¿? While Loop
𝟘 Ends the program
𝟙 Does nothing
𝟚 Does nothing
𝟛 Does nothing
𝟜 Does nothing
𝟝 Does nothing
¦ "Waiting for a Half Broken Or in Heavy Traffic (HBCHT with Bitwise Operators) interpreter to be made..."
÷ Division
«» Bit Shift
⁋«» Bit Shift
ⅈ Creates an imaginary number variable
╬ Pythonic!!! (????)
⩓ Asserts, and closes the program if not
∈ in, also self-describing
ႈ Clear the terminal
𝔹 [[99 Bottles Of Beer]] program
<> Tape Management
ᴟ Put into tape,
ᴞ Read from tape
↝ Don't eval
⩶ or ⩵ Equal (Too strict, too lose)
� Reverse
ℝ repr
ℂ ℂontinue +x or break -x
𝔻 Break, then continue
⅟ 1/x
🙹 "Unknown command"
==Programs==
===Hello, World! Program:===
 【`Hello, World!`】
===Quine===
 【ℚ】
===Cat Program===
 【⍴】
===A+B Problem===
 【⍴⨧⍴】
==Categories==
Category:Languages
Category:2024
■

■ is an esoteric programming language based on box placement.
==Execution==
The program is just the initial state of the interpreter. That state is updated until it stops changing. It is also run in a 2D grid environment, like Befunge. 
==Elements==
A program in this language has three elements: boxes, powers and machines.
===Boxes===
These are the main components in the program.
Every box has a weight (a floating point value) that determines how they are treated. There are four types of box:
Symbol	Name 	Weight
■ 	Normal Box 	1
█ 	Big Box 	2
_ 	Flat Box 	0.1
≡ 	Variable Box	Starts at 0, but it can change
Boxes are affected by gravity, so if the current state is:
■	■
 	■
■	■
then the next state is:
 	■
■	■
■	■
===Machines===
Category:Languages Category:Unimplemented Category:2019 Category:Two-dimensional languages
○

○ (or circle) is an esolang that only accepts the characters ○, ◯, and °. Created by User:AnotherUser05.
Command	Description
○ 	Generates a random value between 0 to 255.
◯ 	Increase a value by the value generated from the most recent ○.
° 	Print the value.
==Examples==
This prints a random value.
 ○◯°
This is not a "Hello World!" program.
 ○◯○◯○◯○◯○◯°○◯○◯○◯○◯○◯○◯○◯○◯○◯○◯○◯°○◯○◯○◯○◯○◯○◯○◯○◯°°○◯○◯○◯○◯°○◯○◯○◯○◯○◯○◯○◯○◯°
This prints 0.
 °
Generates a 16-digit key, by User:Infinitehexagon
 ○◯°○◯○◯°○◯°○◯○◯°○◯°○◯○◯°○◯°○◯○◯°○◯°○◯○◯°○◯°○◯○◯°○◯°○◯○◯°○◯°○◯○◯°
==Uses==
This language is useless, cause it can't output any character.
So why did the author do this?!
Honesly, I have no idea.
==Implementation==
An attempted implementation in Common Lisp shall be produced below. Please note that Unicode support constitutes an implementation-dependent aspect in Common Lisp. The interpreter at hand has been developed and tested with Steel Bank Common Lisp (SBCL) version 1.1.4 as part of the Lisp Cabinet 0.3.5 bundle.
 (defun interpret-○ (code &aux (register 0) (last-random-value 0))
 "Interprets the piece of ○ source CODE and returns no value."
 (declare (type string code))
 (declare (type (integer 0 *) register))
 (declare (type (integer 0 255) last-random-value))
 (setf *random-state* (make-random-state T))
 (loop for token of-type character across code do
 (case token
 (#\○ (setf last-random-value (random 256)))
 (#\◯ (incf register last-random-value))
 (#\° (format T "~d " register))
 (otherwise NIL)))
 (values))
Category:Languages Category:Total Category:Unusable for programming Category:Output only Category:Unimplemented
●

● is the sequel to ○ that adds more commands.
Commands	Description
● 	Generate a random value between -255 and 0.
◌ 	Generate a value of 0.
◍ 	Generate a value that's the same as the user's input.
◓ 	Increase the value by 1.
◒ 	Decrease the value by 1.
◉ 	Skip the next command if the value is non-0.
◎ 	Skip the next command if the value is 0.
◖ 	Beginning of a loop.
◗ 	Go back to the matching ◖.
==Examples==
finally, i can make a truth machine.
 ◍◯◖°◎◗
and a Fixed Repeating Output?? oh wait not fully
 ◍◯◖◒°◎◗°
meow meow purr??? mraw!!
 ◍◯°
===Repeating Cat Program===
This numeric cat program repeats until an input of zero (0) is issued. Please heed that, owing to its resetting iteration, merely non-negative integers may be communicated without an unwanted perpetual loop's infliction:
 ◖ ◖◎◒◎◗ ◍◯◎°◎◗
===Countdown===
This program counts down from the user's input number to inclusive zero (0). Please heed that only non-negative integers are homologated:
 ◍◯°◖◒°◎◗
==Interpreter==
* Common Lisp implementation of the ● programming language. Please note that the concrete character set deployed constitutes a dependency on the Common Lisp implementation; in corollary, Unicode support may or may not be a feature incorporated in the personal environment. The interpreter at hand has been developed and tested with Steel Bank Common Lisp (SBCL) version 1.1.4 as part of the Lisp Cabinet 0.3.5 bundle.
Category:Languages Category:Total Category:2024 Category:Implemented
☃

☃ is an esoteric programming language devised by User:mroman in 2016. It's a 2D multi-threaded language.
Each thread has its own current value and additional data can be stored in the program space (you can think of them as Flip-Flops of some sort).
== Instructions ==
><^v Change direction accordingly.
/\ Mirrors (they work as in [[Beam]])
+- Increment/decrement current value
s If coming from left or right -> read value (current value = value read)
 from top or bottom -> write value (value stored = current value)
p Display value
f Fork left (create new thread)
F Fork downwards (create new thread)
b Barrier (for sync)
B Global barrier (for sync)
d Distribute two (wait for two processes one goes left, other goes right, implicit local barrier for two threads)
? if current value > 0 branch down
# if current value < 0 branch up
n if current value == 0 branch up
=== Barriers ===
b is a local barrier. All threads need to reach and wait at the same exact location.
This will halt:
>Fv
 >b
however this will deadlock (because threads are waiting at different local barriers).
>Fb
 >b
However, there is the global barrier B where threads can continue if every thread has reached a global barrier somewhere in program space, thus the following will not deadlock:
>FB
 >B
== Examples ==
This should be a program creating two threads where one continues to display the value while the other continues incrementing it. 
>F>>v <
 >+ v
 > sp^
 ^ <
== Open Questions ==
Is the computational class if restricted to one single thread the same as when it's allowed to use multiple threads? What's the computational class anyway? (There can always be only a finite amount of
storages).
Category:Languages
♦

•■◄◄▬○■◄•☰►■☰▼∟▲☰►○∟•◄☰○∟•◄►☐▬○■◄•☰⚀☉▬■☰○∟•▬○◄•☉⚀☰○■•∟○᪅☼■•☰▼∟▲☰○▼∟•∟○▬•►○▬•᪅▼☰☼▲○■•∟○᪅•☰►○▬•∟▲⚀☰·∟•►○■•☐☰○☉•►○■•☰○∟•◄►☐·▲•☰⚀☉◄☰○■•◄○᪅•☰►᪅○▼•☉►○▬•◄⚀☰○▬•▼☰☐►○☰•▬☐☰○☉•►⚀⚀☼▼•☰☰○►•▬○∟•■⚀☰∟○►•☰►᪅᪅☼■•☰⚀☉►○■☼▲•■☰○►•∟○∟•☰⚀►☼▲•▬○■◄•☰⚀☉◄☰⚀▬○⚀•◄☰⚀∟☰᪅∟∟☼▲•☰▬○■•⚀∟☰⚀☉◄☰○■•◄○᪅•☰►᪅○▼•☉►○▬•◄⚀☼▼•☰☰▬☼᪅○⚀•☰☉►○▼▼•▼☰⚀☉►⚀☰▬⚀☼᪅•■☰○▬•◄◄○■•☰▲■◄○►•▲᪅☰·∟•■∟○⚀•◄☉∟○᪅·▲☼▼☰☰•■∟☰☉◄○∟•◄☰►○∟•◄☰■∟○⚀•◄☰○■•∟⚀◄■☰⚀☉►⚀☰⚀☉◄☰○▼•◄∟○▼•᪅◄☰○᪅•☉∟☰☐∟○■☼᪅•⚀▬☰▬▲○■•☐◄○∟•■⚀►○■•☐☰⚀☉◄☰○■•◄○᪅•☰►᪅○▼•☉►○▬•◄⚀☰○᪅•∟○■☼᪅•⚀☰○▬•◄☰►○▬•᪅◄☰⚀∟☰○∟•◄►☐·☐☼☰☰•☰·►•☰⚀☉◄☰◄○■◄•᪅▬■☉☰○■•►○⚀•◄☰∟○►•☰⚀☉◄☰○■•◄○᪅•☰►᪅○▼•☉►○▬•◄⚀☰▬■☰☼᪅○☰•◄○∟•⚀○⚀•∟○■•☐☼᪅▼•☰☰⚀☉◄☰○■•►○⚀•◄☰○᪅•►■☰☐◄○☉•▬☐◄☐☰►■☰►☰○⚀•►■☉▲○▼•☰○▬•◄⚀○᪅•◄◄○■•☰☼᪅○☰•◄○∟•⚀☼᪅•☰·∟○■•∟⚀☰■▲○∟•◄☰○᪅•☉►⚀☰⚀☉►⚀☰○⚀•◄►○■•■·▲•☰►○■•☐☰☼᪅•☐▬►○⚀•∟○■•☐☼᪅▼☰•☰·►•☰⚀☉◄☰○☉•☉►○∟•►○☉•⚀◄○∟•☰○☉•∟☐◄☰○►•∟○∟•☰⚀☉◄☰○■•►○⚀•◄☰∟○►•☰⚀☉◄☰᪅►○■◄•►▲○◄•◄☰▬■☰►᪅⚀·◄○►•∟▲○∟☼▼•☰☰▬⚀☰▬■☰►○☉•⚀▲►᪅᪅▼☰⚀☉◄☰■◄○☰•◄○■•⚀◄◄○■•⚀☉☰■▼○⚀▬•∟᪅☰∟○►•☰⚀☉◄☰►᪅○▼•☉►○▬•◄⚀☰·∟•►᪅⚀☉∟▲○◄•☉☰○■•∟⚀☰▲■◄☐☰▬○■•☰○⚀•∟■⚀☰■⚀►○■•☐►○∟•☐☰►○▼▼•᪅○☉•►⚀▬∟○■•■·▲☼■•☰►○■•☐☰○☉•►○■•☰○▬•◄☰▲■◄☐☰⚀∟☰■○▼•◄○☉•▬○►•▼☰◄☼◄•⚀◄○■•☐◄☐☰○☉•☉►○∟•►○☉•⚀◄○∟•☰○☉•∟☐◄■☰○᪅•☉▬᪅◄☰◄○⚀•▲᪅►⚀▬○■◄•☰◄○■◄•᪅▬■☉☼▼•☰☰⚀☉◄☰■▼○⚀▬•∟᪅☰▬■☰○►•∟᪅᪅∟○᪅•◄☐☰○▬•▼☰○►•∟▲○∟•☰○☉•☉►○∟•►○☉•⚀◄○∟•■☼■•☰►○■•☐☰⚀☉∟■◄☰○►•∟▲○∟•☰○☉•☉►○∟•►○☉•⚀◄○∟•☰☉►○☰•◄☰⚀☉◄▬○∟•☰○▬•▬○■•►○∟•▼☰○☉•∟☐◄■☰○☉•∟○⚀▬•▬○■•◄☐☰▬○■•⚀∟☰⚀☉◄☰■▬☼◄•⚀◄◄○■•☰○▬•▬⚀☰▲○■•▬○☉•∟☐◄☰○☉•☉►○∟•►○☉•⚀◄○∟•☰○☉•∟☐◄☰∟○►•☰⚀☉◄☰○☉•☉►○∟•►○☉•⚀◄○∟•☰⚀∟☰◄○⚀•▲᪅►⚀◄☼▼☰•☰·►•☰⚀☉▬■☰►᪅○▼•☉►○▬•◄⚀☰▬■☰○►∟•◄◄☰⚀∟☰▲■◄☰▬○■•☰►○■•▼☰○᪅•►▼☰⚀☉►⚀☰▼∟▲☰○᪅•►○■•⚀☼▼•☰☰⚀☉►⚀☰▬■☼■•☰■∟☰᪅∟○■◄•☰►■☰▼∟▲☰☐∟○■☼᪅•⚀☰○☉•᪅►▬○⚀•☰⚀☉►⚀►☰▼∟▲☰○⚀•►☐◄☰▬⚀☼▼•☰☰►☰○◄•∟∟☐☰○᪅•►▼☰⚀∟☰◄○■•■▲○∟•◄☰⚀☉►⚀☰○▼∟•∟○▼•◄○∟•☰○☉∟•◄☐▬⚀☰▬■☰○◄•▬○☰•◄○■•☰▬■☰⚀∟☰☉►○☰•◄☰►☰᪅▬○■☼▲•☰▬○■•☰⚀☉◄☰᪅►○■◄•▲►○◄•◄☰○▼•►○◄•◄☰∟○►•☰►○■•▼☰᪅►○■◄•▲►○◄•◄☰▲■▬○■◄•☰⚀☉▬■☰►᪅○▼•☉►○▬•◄⚀☰⚀∟☰◄▬⚀☉◄○∟•☰⚀☉▬■☰○▼•►○◄•◄☰∟○∟•☰⚀☉◄☰○᪅•▬○⚀▼⚀•∟☐◄☰○▼•►○◄•◄☰·∟○►•∟▲○■•☐☰►⚀☰☉⚀⚀○▼᪅᪅○᪅᪅᪅☼▼•◄■∟᪅►○■◄•■☼▼•∟○∟◄·᪅○᪅•▬☼▲•▬·᪅∟•■⚀►○∟·▲᪅∟•⚀▬᪅☐◄·▲▲☼▼☰☰☰○᪅•▬⚀☉☰►᪅᪅☰⚀☉▬■☰▬○■•☰○⚀•▬○■•☐☼■•☰☉►○☰•◄☰○►•▲○■☼⚀•☰·∟•∟○∟•☰○☉•∟○■►•▲■◄☰⚀☉◄☰☉◄᪅᪅☰∟▲⚀☰∟○►•☰○▼•◄∟○▼•᪅◄☰○᪅•☉∟☰☐∟○■☼᪅•⚀☰▲○■•☐◄○∟•■⚀►○■•☐☰○☰•◄○∟•⚀○⚀•∟○■•☐·▲☼☰☰·►•☐►○☰•▬☐☰○☉•►⚀⚀◄☰■◄
Category:Ideas Category:2012
♦/~

♦ is an alphabet of sixteen characters. Each character is expressed as 4 bits and has a ternary bias. Furthermore, each character has properties that allow it to be mapped to a subset of English text.
♦ was invented by user:David.werecat as an alternative alphabet to write esoteric languages. The actual page for the alphabet can be found here: ♦
Character	Binary	Ternary Bias	English Mapping 	Alt Code
• 	0000 	0 	Specifies mapping to subset 1	7
○ 	0001 	2 	Specifies mapping to subset 2	9
☼ 	0010 	1 	Specifies mapping to subset 3	15
► 	0011 	0 	1=A 2=F 3=V 4=- 	16
◄ 	0100 	0 	1=E 2=G 3=X 4=+ 	17
▬ 	0101 	0 	1=I 2=B 3=Z 4== 	22
∟ 	0110 	2 	1=O 2=R 3=J 4=( 	28
▲ 	0111 	0 	1=U 2=H 3=K 4=) 	30
▼ 	1000 	0 	1=Y 2=P 3=. 4=& 	31
· 	1001 	2 	Specifies mapping to subset 4	250
■ 	1010 	0 	1=S 2=N 3=, 4=$ 	254
⚀ 	1011 	1 	1=T 2=M 3=! 4=# 	9856
☉ 	1100 	1 	1=H 2=C 3=? 4=; 	9737
☐ 	1101 	2 	1=D 2=Q 3=" 4=: 	9744
᪅ 	1110 	1 	1=L 2=W 3=' 4=/ 	6789
☰ 	1111 	1 	1=<space> 2=V 3=<newline> 4=*	9776
The number in the English mapping is the value of the character when in that subset.
== External resources ==
Conversion program for ♦/English/Binary
Category:Ideas
Category:2012
⦿⚚♆⚧⟁⌬⚶⟆⚡⟴⚘⍟⚕⧏⚜⫷⚡⌛⍨⚭⟊⚳⦾⏁⚋⟾⚬

⦿⚚♆⚧⟁⌬⚶⟆⚡⟴⚘⍟⚕⧏⚜⫷⚡⌛⍨⚭⟊⚳⦾⏁⚋⟾⚬ pronounced unicode shit is a esolang about making functions for a stack by defining rules. you can add commands.
these are the commands:
 commands
symbol	discreption 	example
-> 	used to show: this function makes it so if we have this state then it becomes another state 	print:(stack)[{X}, I]->[I]
(...) 	what we are showing. there is stack which is the stack and there is console which is where text is printed and deleted which is just where things that is no longer on in the code is put	print:(stack)[{X}, I]->(stack)[I], (console)[X]
{...} 	the object we are using 	print:(stack)[{X}, I]->(stack)[I], (console)[X]
>...< 	the index of a object. index 1 is the top of the stack 	(stack)[{X}, I]->[I],(deleted)[X]
⚋ 	undefine a rule 	F:... ⚋ -> (deleted)[F]
⚭ 	create a repeat loop 	⚭ 5: print(stack) -> (stack) (stack) (stack) (stack) (stack)
Category:Languages Category:Stack-based
⫵

⫵ is a Zero Instruction Set Computer made by User:AmNow.
== Command ==
⫵ has only one command: ⫵. It increments an 8-bit accumulator.
At the end of any ⫵ program something happens based on the accumulator.
# acc % 2 == 0 && acc < 10: Loop and output (ascii).
# acc % 2 == 1 && acc < 10: Loop and reset.
# acc == 255: Output (ascii) and end.
# acc % 2 == 1: Loop, Output (ascii) and reset.
# acc % 2 == 0: Loop.
It will do the first one that it sees true.
== Programs ==
=== Spam #s to the console ===
 ⫵⫵⫵⫵⫵⫵⫵⫵⫵⫵⫵⫵⫵⫵⫵⫵⫵⫵⫵⫵⫵⫵⫵⫵⫵⫵⫵⫵⫵⫵⫵⫵⫵⫵⫵
==Implementation==
C++ interpreter can be seen here
Category:2021Category:Languages Category:Implemented Category:Unusable for programming Category:Output only
⫸fuck

⫸fuck is a esolang. It's based on brainfuck, being a trivial brainfuck substitution that exchanges the original language's ASCII command identifiers by Unicode symbols of an approximately similar appearance.
== Operators ==
Command in ⫸fuck	Command in Brainfuck
⫸ 	>
⫷ 	<
⁜ 	
⌁ 	
⁕ 	.
⁑ 	,
⟬ 	[
⟭ 	]
⫸⫷⁜⌁⁕⁑⟬⟭'s Unicode is 0x2AF8, 0x2AF7, 0x205C, 0x2301, 0x2055, 0x2051, 0x27EC, 0x27ED respectively.
== Examples ==
=== Hello, World! ===
⁜⟬⌁⌁⫸⌁⟬⫸⫸⁜⫸⌁⌁⌁⌁⌁⫷⫷⟭⫷⌁⌁⫷⌁⌁⌁⟭⫸⌁⁕⫸⫸⫸⁜⁕⫸⫸⁕⁕⁜⁜⁜⟬⁕⫸⟭⫷⫷⫷⫷⁕⁜⁜⁜⁕⌁⌁⌁⌁⌁⌁⁕⫷⫷⌁⁕⫸⫸⫸⫸⁜⁕
=== Cat ===
⁑⟬⁕⁑⟭
=== Truth-machine ===
A truth-machine implementation, dependent upon the byte range wrapping, and translated from , shall be adduced:
 ⁑⁕⟬⌁⌁⫸⁜⟬⫸⫸⟭⫷⟬⁕⟭⫷⫷⟭
==Interpreter==
* Common Lisp implementation of the ⫸fuck programming language. Please note that the concrete character set deployed constitutes a dependency on the Common Lisp implementation; in corollary, Unicode support may or may not be a feature incorporated in the personal environment. The interpreter at hand has been developed and tested with Steel Bank Common Lisp (SBCL) version 1.1.4 as part of the Lisp Cabinet 0.3.5 bundle.
Category:Languages Category:Brainfuck derivatives Category:Brainfuck equivalents Category:Turing complete Category:Cell-based Category:Turing tarpits Category:Low-level Category:Implemented
ごぼうとにんじん炒めたやつ

ごぼうとにんじん炒めたやつ(gobo to ninjin itameta yatsu) is an esoteric programming language invented by User:Yamaserif.
The "ごぼうとにんじん炒めたやつ" is a derivative of brainfuck. The name of the programming language means "fried burdock and carrot".
The source code is composed of straight lines reminiscent of shredded carrots and burdocks, and dots reminiscent of sesame seeds.
It is also acceptable to call it きんぴらごぼう(kimpira_gobo) or きんぴら(kimpira).
==Specification==
bf	command	description
> 	i 	Move the pointer to the right
< 	l 	Move the pointer to the left
+ 	I 	Increment the memory cell at the pointer
- 	| 	Decrement the memory cell at the pointer
. 	. 	Output the character signified by the cell at the pointer
, 	: 	Input a character and store it in the cell at the pointer
[ 	¡ 	Jump past the matching "!" if the cell at the pointer is 0
] 	! 	Jump back to the matching "¡" if the cell at the pointer is nonzero
Specifications not otherwise noted conform to brainfuck.
==Example==
Hello, world!
 IIIIIIIII¡iIIIIIIIIiII
 ( IIIIIIIIIiIIIIIlll|!i.iII.I )
 ＼ IIIIII..III.i|.||||||||||||.lI ／
 ＼ IIIIIII.||||||||.III.||||| ／
 --- |.||||||||.iI. ---
 L皿皿皿皿皿皿皿皿皿」
==External resources==
*Github page
Category:Languages
Category:2024
Category:Turing complete
Category:Implemented
Category:Brainfuck equivalents
Category:Brainfuck derivatives
Category:Cell-based
Category:Turing tarpits
ぬいぐるみアート

(ぬいぐるみアート) (English: "stuffed animal art") is an esoteric programming language made out of plushies.
==Syntax==
Archie (Pink axolotl) is the print function.
The pink cheetahs are the memory slot.
Pippin (Rainbow Pumpkin) is the input function.
Chicken is the storer of the value of the memory slot.
When you put one pink cheetah in front of Pippin, the input is stored.
Lomo (Green Axololotl) is a special plushie. When you put it infront of a command, it only runs the command when the pink cheetah is equal to Monica (purple axolotl).(cmp x, l; jne label;)
Every small plushie except the pink cheetahs and Burger can be used as values.
===Extension===
I found a third pink cheetah and Autumn (Black Cat).
Autumn is an adder. You put 2 value-small-plushies together (one of them can be a Pink Cheetah)(which calls x and y), and it gets saved to Burger(z, which equals to x+y).
Rainbow Doggo (Rainbow Dog) is an infinite loop.
==Cat==
This asks for the user input, and prints it through Archie.
x = input()
print(x)
==Truth machine==
This asks for user input, and if it is Monica, than Archie prints a Monica.
x = input()
y = 1
if x == y:
 print(y)
==Hello World==
This uses Mexica (Italian-looking food plushie) to represent Hello World, and uses Archie to print.
st = "Hello, world!"
print(st)
==Logo Script==
This is the script from the logo.
It appears to store Galaxia into Pink Cheetah using chicken, printing Mexica, and an input that saves to pink cheetah that never gets accessed because Monica is nowhere in the script.
# I don't know how to use pseudo code to express it. ----PSTF
==Programs using Extended Syntax==
===Better Truth Machine===
Uses Rainbow Doggo to loop printing Monica.
x = input()
y = 1
if x == y:
 while True:
 print(y)
===Adder===
Adds your input to Galaxia and prints it.
x = int(input())
y = 10 + x
print(y)
==Text format==
I have made a text format...
Notes: There can only be one of each plushie, except for Pink Cheetah, where there can be 3
===Cat in text===
 Archie>PinkCheetah Pippin|PinkCheetah
===Truth machine... I guess? in text===
 Archie>PinkCheetah|Lomo Pippin|PinkCheetah
===Hello World in text===
 Archie>Mexica
=== A+B Problem...? in text ===
I used my pseudo code format.
input|pinkcheetah1, pinkcheetah2
burger=Add(pinkcheetah1, pinkcheetah2)
print>burger
==Suggest some==
Just put the text format on the talk page.
Note: I might reject it if it is impossible, and I might use a different small plushie because I don't have all of the small plushies.
==Implementation==
Try to implement the text version of this esolang instead
== Categories ==
See below
Category:Languages Category:Non-textual Category:Unimplemented