nyuuzyou/wikis huggingface dataset:
`

` is a minimalistic esoteric language created by User:Iamcalledbob that was designed to have only two instructions, while being somewhat usable for computation.
==Description==
There is an infinite tape, which has cells. Cells can contain a number, negative or positive. The maximum value of a cell isn't specified. If anything is assigned to cell number 0, the ASCII character of that thing is printed to STDOUT. 
==Instructions==
Syntax 	Function
A`+B 	Set address A to the value B.
A`B 	Set address A to the value of address B.
+A`+B 	If the latest assigned value equals A, jump B instructions in code relatively. Or else do nothing. B can be a negative in order to jump backward.
+A`B 	If the latest assigned value equals A, jump the value of address B instructions in code relatively. Or else do nothing. Value of B can be a negative in order to jump backward.
Any invalid instruction	Is ignored other than to separate instructions apart.
When jumping to or just reaching the end of the file, program stops. It's not specified what happens when you jump below the instruction 0. 
==Computational Class==
` cannot access cells with addresses that aren't specified literally in the program (or the initial state of the tape), and cannot set cells to values that aren't specified literally in the program (or the initial state of the tape). As such, assuming that the initial tape contains only finitely many different values, ` is a finite-state machine.
==Examples==
=== Hello, world! ===
 0`+72
 0`+101
 0`+108
 0`+108
 0`+111
 0`+44
 0`+32
 0`+119
 0`+111
 0`+114
 0`+108
 0`+100
 0`+33
=== Infinite loop ===
 1`+1
 +1`+-1
=== Cat ===
 Assuming cell one is the input stream.
 0`1
 2`+0
 +0`+-2
=== Truth-machine ===
 Assuming cell one has the input.
 0`1
 +1`+-1
=== NAND gate ===
 Assuming cell one and two have the inputs.
 1`1
 +0`+5
 2`2
 +0`+3
 0`+48
 +48`+2
 0`+49
== Interpreter ==
This is an interpreter in Python:
import sys
l = open(sys.argv[1]).read().split("\n")
ptr = 0
addrs = {}
last = 0
while ptr < len(l):
 try: # See if line is valid
 L, R = l[ptr].split('`')
 int(L)
 int(R.lstrip("+"))
 except:
 ptr += 1
 continue
 if L[0] == '+':
 if R[0] == "+":
 if last == int(L[1:]):
 ptr += int(R[1:])
 else:
 if last == int(L[1:]):
 ptr += addrs[int(R)]
 else:
 if R[0] == "+":
 if L == "0":
 print(end=chr(int(R[1:])))
 addrs[int(L)] = int(R[1:])
 last = int(R[1:])
 else:
 if L == "0":
 print(end=chr(int(R[1:])))
 addrs[int(L)] = addrs[int(R)]
 last = addrs[int(R)]
 ptr += 1
Category:Cell-based
Category:Output only
Category:Finite state automata
Category:Languages
Category:2018
Category:Implemented
`LML

`LML, pronounced as “elemel”, is an esoteric programming language made by Saketh Suresh (User:sane_theinsane) in 2018. The language uses 8 commands. `LML works with a list called LI and a variable called X having a default value of 0. Out of the 8 commands, 2 are for modifying X, 3 for adding elements to LI, 1 for input, 1 for reseting X and the last one for printing the elements in LI.
== Comands ==
The 8 commands used in `LML are:
Name	Meaning
+ 	adds 1 to X
- 	subtracts 1 from X
< 	pushes in the current value of X into LI, i.e. if X = 8 then 8 is added to LI
( 	pushes in the current value of X into LI in the form of a lowercase character, i.e. if X = 0 then ' ' is added to LI and if X = 1 'a' is added to LI
[ 	does the same thing like ( except the characters added to LI are in capitals
: 	takes input as a string or integer and adds it to LI
; 	joins all the elements of LI together and prints it
R 	resets the value of X to 0
=== TO BE NOTED ===
In `LML you can write the code in separate lines, as any other commands except the the ones in the table are ignored.
== Examples ==
A program that prints 6 abb:
 +++ +++< sets the value of X to 6 and adds 6 to LI
 R( resets the value of X and adds ' ' to LI
 +( sets X to 1 and adds 'a' to LI
 +((; sets X to 2 and adds 'b'to LI 2 times and then joins the elements and prints them
Hello World (no comments and is done in one line; guess what it does yourself):
 ++++++++[---(+++++++((+++(R(+++++++++++++++++++++++[--------(+++(------(--------(;
A program that takes your name and prints Hi before it (with comments):
 ++++ ++++[ sets X to 8 and adds 'H' to LI
 +( sets X to 9 and adds 'i' to LI
 R( resets X to 0 and adds ' ' to LI
 : ; takes input in this case your name and adds it to LI then joins the elements and prints them
When the same code is written in one line: ++++++++[+(R(:; we see it is very small and that is cool.
That's basically `LML.
==Interpreter==
* Common Lisp implementation of the `LML programming language.
Category:Languages
Category:Brainfuck derivatives
Category:Implemented
`Română

`Română is an Pseudonatural language designed by PSTF.
Because ^Română is occupied, I had to use different symbol(In my design it was left brocket but it is invalid).
== Syntax ==
Just Romanian.
== Examples ==
Faceți clic pe acest link pentru a-l citi singur, sunt prea leneș să scriu.
== Categories and References ==
Category:Languages
Category:High-level
Category:Pseudonatural
Category:Unimplemented
Category:2025
`Română/Examples

== Hello, world! ==
 Ieșire "Bună oameni buni!".
Or:
 Ieșire "Bună lume!".
Or even:
 Ieșire "Bună, lume!".
== A+B Problem ==
 Introduceți două numere întregi de la utilizator și apoi imprimați suma lor.
== Collatz sequence ==
Introduceți un număr întreg de la utilizator, apoi atribuiți-l lui x.
Repetați aceste până când x = 1:
Pentru fiecare pas, dacă x este par, atunci atribuiți x/2 lui x, altfel, atribuiți 3x+1 lui x.
Imprimați valoarea lui x cu o linie nouă.
Buclă de sfârșit.
Tipăriți "Totul gata." fără linie nouă.
Aruncați x la gunoi.
== Bubble Sort ==
--- SORTAREA BULELOR ---
Comparați fiecare element al listei doi câte doi.
Dacă primul este mai mare decât cel de-al doilea dintre cele două elemente, cele două elemente sunt schimbate,
la fel cum bulele plutesc una câte una, numărul cel mai mare va merge la sfârșitul listei.
---CAPĂT---
Definiți o listă și citiți lista de la utilizator.
Sortați întreaga listă cu bule și afișați rezultatul.
== More ==
== Categories ==
Category:Examples
``

`` is a programming language inspired by `.
It operates on cells, with 2 internal registers, a and b
 Commands
Command	What it does
`0 	Reset a
`n 	(n>0)Increment a by n. If n is blank then decrement.
`0` 	Copy a to b. a unchanged.
`1` 	Skip next command if a=0
``0 	Set the pointer to a, then set a to the value under the pointer
``1 	Set the pointer to b and set the value under the pointer to b
`-n 	Jump to command n. The first command is command 1.
; 	Separates instructions
`` 	Output contents of register a as Unicode
``` 	Get input and store it in register a
==Examples==
===Cat Program===
An infinitely repeating cat program follows:
 ```;``;`-1
===Truth-Machine===
This program implements a truth-machine:
 ```;
 `;`;`;`;`;`;`;`;`;`;
 `;`;`;`;`;`;`;`;`;`;
 `;`;`;`;`;`;`;`;`;`;
 `;`;`;`;`;`;`;`;`;`;
 `;`;`;`;`;`;`;`;
 `1`;
 `-53;
 `-57;
 `0;`49;``;`-55;
 `0;`48;``
==Interpreter==
* Common Lisp implementation of the `` programming language.
Category:Computational modelsCategory:LanguagesCategory:2023Category:Cell-basedCategory:Turing tarpitsCategory:ImplementedCategory:Low-level
```

``` is a extremely minimalistic programming language.
It operates on cells, which can store unbounded numbers.
There is only a single command, but that command have multiple forms.
 Forms
Form 	What it does
`a`#b 	Store the number b in cell a.
`a`b 	Copy cell b into cell a.
``a`#b 	Store the number b into the address that cell a points to.
``a#b`#c	Store the number c in the address cell a points to offset by b.
``a`b`#c	Store the number c in the address cell a points to offset by the contents of cell b.
`a``b 	Fetch the value the address that cell b points to and store it in cell a
`a``b#c 	Fetch the value the address that cell b points to, offset by c, and store it in cell a
`a``b`c 	Fetch the value the address that cell b points to, offset by the value in cell c and store it in cell a
``a`b 	Store the value in cell b into the address cell a points to.
``a#b`c 	Store the value in cell c into the address cell a points to, offset by b.
``a`b`c 	Store the value in cell c into the address cell a points to, offset by the contents of cell b.
In order to do control flow, cell 0 holds the instruction pointer.
If cell 1 is nonzero then no instructions, except those that affect cell 1, are excecuted.
Cell 3 is input mode. 0=Output 1=Input
Cell 4-24 is bits set to perform I/O.(full range unicode)
Cell 2 is to enable I/O. Writing a nonzero values will perform I/O then set cell 2 to 0 again.
Category:Computational models
Category:Turing complete
Category:2023
Category:Unimplemented
Category:OISC
~

~ is an esoteric programming language created in 2006 by User:Tim_pettit. The basis of this language is to manipulate data on a single deque using only unary and ternary operators.
==Syntax==
All statements consist of a single operator followed by a "|" character to delimit each.
(where ever x, y or z are used they should be replaced by only ^, & or an unsigned integer constant)
(if people like the language ill post an interpreter so people can see the programs work)
The Ternary Operators:
There are two ternary operators in ~ they are ! and # followed by three values delimeted by spaces.
 ! x y z|
is equal to the c statement:
 if(x == y) push_front(z);
 else pop_back();
 # x y z|
is equal to the c statement:
 if(x == y) pop_front();
 else push_back(z);
The Unary Operators:
There are six unary operators in ~ they are +, -, ++, --, +- and -+.
 +x|
is equal to the c statement:
 pop_front();
 push_back(x);
 -x|
is equal to:
 pop_back();
 push_front(x);
 ++x|
is equal to:
 push_back(pop_back() + 1);
 push_front(x);
 --x|
is equal to:
 push_front(pop_front() + 1);
 push_back(x);
 +-x|
is equal to:
 push_front(pop_front() + x);
 push_back(pop_back() - x);
 -+x|
is equal to:
 push_front(pop_front() - x);
 push_back(pop_back() + x);
With the operators there are also five Keywords represented as the symbols: ^, &, $, % and ~.
^: peek at the front of the deque
&: peek at the back of the deque
$: pop the front of the deque to stdout as a char and push a value from stdin (if there is no input 0 is pushed) onto the back.
%: pop the back of the deque to stdout as an int and push a value from stdin (if there is no input 0 is pushed) onto the front;
~: swap the front and back values on the deque.
~ also has two loops which are used by encasing the code to be looped in the correct pair of brackets, either { } or [ ].
{ }: works like a c while loop, it loops until the front of the deque is equal to zero, the condition is checked at the start of the loop.
 while(peek_front() != 0) 
 { 
 /* do stuff */ 
 }
[ ]: works like a c do loop, it loops until the back of the deque is equal to zero, the condition is checked at the end of the loop.
 do
 {
 /* do stuff */
 } while(peek_back() != 0);
Along with all this ~ allows unsigned integers to be entered as constants in the source code, however the deque is signed.
==Sample Code==
Here are two sample programs.
The Mandatory Hello World
 ! 0 0 0 | ! 0 0 33 | ! 0 0 100 | ! 0 0 108 | ! 0 0 114 | ! 0 0 111 | ! 0 0 87 | !0 0 32 | ! 0 0 111 | ! 0 0 108 | ! 0 0 108 | ! 0 0 101 | ! 0 0 72 | 
 { $ }
and
A Cat Program
 ! 0 0 1|
 ! 0 0 1|
 # 0 1 0|
 {
 	~|
 	$|
 	! 0 0 &|
 	++ 0|
 	~|
 	! ^ 0 0|
 	# 0 0 0|
 	~|
 }
==External resources==
*Interpreter in Haskell
*Interpreter in Java, unzip and run the .bat file to run 
Category:Languages
Category:Deque-based
Category:Implemented
Category:2006
~EarthBit

EarthBit is a joke language made by User:Conor O'Brien that is interesting in that all the operators are confused.
== Syntax ==
In EarthBit there are numeric literals, the only data type. Each number pushes an instance of itself to the stack. Each line represents a different computation.
Instruction	Effect
A 	Grabs the previous answer. Defaults to Infinity
i 	Tajes
+ 	Multiplies top two entries on stack, push the result.
* 	Divide top entry by the next entry on stack, push the result.
/ 	Pop top value N and push -N
- 	Pop A then B and push B^A
^ 	Push the sum of top two entries.
O 	Goto the (result)th line if the lines result is not zero
A blank line outputs the result.
Category:Languages
Category:Turing tarpits
Category:Turing complete
Category:Unimplemented
Category:Joke languages
~This=That

This=That is an esoteric programming language by User:A, and is made up entirely of variables. Each line is just a case-sensitive variable name, followed by =, and then the variable's case-sensitive value.
The variable names can be anything including special names, and the values can be anything as well, and can also be special values:
\o 	prints the variable's value.
\i 	inputs a value for the variable to take.
+(add)-(subtract)/(divide)*(multiply)	do math. For example:
 x=4
 J=x - 2
sets x as value 4 and J as value 2 (4-2). Also:
 f=n
 p=o
 s=f + p
sets fruit as value fly(Any value without 0-9 is a string), printer as value paper, and sticky as value no (word math only works with +).
x=cnd.? 	starts an if called x with the given condition.
x=cnd.: 	starts a while loop named x with the given condition.
x=& 	signifies the end of if or while loop called x.
Conditions have three parts, two compared values referenced by their names and a comparison.
They only use 4 instructions, which can be:
> 	is greater than
< 	is less than
==	equal to
~ 	NOT command.(Makes < into >=, > into <=, = into !=)
==Example programs==
===Hello, world! Program===
 x=Hello, world!
 x=\o
===Cat Program (Until QUIT is inputted)===
 x=\i
 y=~x==QUIT:
 x=\o
 x=\i
 y=&
===Endless Bottles of Beer Program===
 a=99
 b= bottles of beer on the wall. 
 c=a+b
 d= bottles of beer. You take one down and pass it around. 
 e=a+d
 f=c+e
 g= bottle of beer on the wall. 
 h=a+g
 i= bottle of beer. You take it down and pass it around. 
 j=a+i
 k=h+j
 l= bottles of beer. You go to the store and buy some more. 
 m=a+l
 n=c+m
 o=0
 x=o==0:
 y=a>2:
 f=\o
 a=a-1
 c=\o
 y=&
 f=\o
 a=a-1
 h=\o
 k=\o
 a=No
 c=\o
 n=\o
 a=99
 c=\o
 x=&
===Endless Fibonacci Program===
 a=0
 b=1
 a=\o
 b=\o
 x=b>0:
 a=a+b
 a=\o
 b=a+b
 b=\o
 x=&
===Endless Square Numbers Program===
 a=0
 b=1
 a=\o
 x=b>0:
 a=a+b
 b=b+2
 a=\o
 x=&
or
 a=0
 x=~a<0:
 b=a*a
 b=\o
 a=a+1
 x=&
===Simple Adding Machine===
 x=\i
 y=\i
 z=x+y
 z=\o
===Digital Root Calculator===
 a=\i
 x=a>9:
 a=a-9
 x=&
 a=\o
===Counts down from inputed value to zero===
 a=\i
 x=a>0:
 a=\o
 a=a-1
 x=&
===Counts from zero to infinity===
 a=0
 x=a>0:
 a=\o
 a=a+1
 x=&
==See Also==
*This=That
Category:LanguagesCategory:2018
~~¨л

~~¨л(first of all idk how i got that name second of all its pronounced sin) is a esolang created by User:Yayimhere while on a twitch stream
== ~~¨л hexadecimal format ==
~~¨л has a way to write hexadecimal numbers(where there are couples so they can be divided into chunks of two digits and where the vertical is the first digit). its in this format:
 · 0123456789abcdefg
 0 ○■↑↓→←║═╔╗╚╝░▒►◄⟑
 1 │─┌┐└┘├┤┴┬♦┼█▄▀▬⟁
 2 ▓!"#$%&'()*+,-./⋥
 3 0123456789:;<=>?⟅
 4 @ABCDEFGHIJKLMNO⟆
 5 PQRSTUVWXYZ[\]^_⨏
 6 `abcdefghijklmno⨠
 7 pqrstuvwxyz{|}~√⨛
 8 €‚ƒ„…†‡ˆ‰Š‹ŒŽ♣♥♠⨜
 9 ‘’“”•–—˜™š›œž↊↋Ÿ⫷
 a π¡¢£¤¥¦§¨©ª«¬∞®¯⫸
 b °±²³´µ¶·¸¹º»¼½¾¿⌦
 c ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏ⌫
 d ÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞß⌬
 e àáâãäåæçèéêëìíîï⒵
 f ðñòóôõö÷øùúûüýþÿ⒪
this was taken from 4 bits, 8 bytes. also a number must end in л if its negative and λ works as the decimal dot
== syntax ==
~~¨л has two commands:
 x y z
and
 x y
first of all x, y, and z are hexadecimal numbers in the ~~¨л format. the first command does this:
* take the sin of x
* multiply the result by y
* set the variable x to that(unless if x is not a variable)
* jump to line z if the result is negative
and the second is the variable defining:
* set name x to y
when variables are referenced as ⋘ must be before it and when you want it to act like its just a number add it twice
== tips ==
to unconditionally jump to line n:
 ■л ■n
this works since ■л is negative
Category:Languages
~Ω₁

~Ω₁ is an esolang by User:Europe2048 with uncountable data types.
(note: this will probably become a golfing language)
== SBCS ==
 - 0123456789abcdef
 0 
 1 
 2 !"#$%&'()*+,-./
 3 0123456789:;<=>?
 4 @ABCDEFGHIJKLMNO
 5 PQRSTUVWXYZ[\]^_
 6 `abcdefghijklmno
 7 pqrstuvwxyz{|}~
 8 ¡¢£¤¥×¦§¨©ª«¬­®¯΅
 9 °±²³´÷¶·€¹º»¼½¾¿
 A ΓΔΘΛΞΠΣΦΨΩ
 B αβγδεζηθικλμνξπ
 C ρστυφχψω
 D 
 E 
 F 
== Types ==
There are three main types in ~Ω₁: number, character, and list. Strings are just lists of characters.
Operations can be pervasive, meaning they apply to every element in an list.
However, there is one extra type: uncountables. An uncountable can be made by using Ω. You cannot measure the length of an uncountable data type.
 3NΞ # 1
 3NΩΞ # Ω!
== Glyphs ==
Functions go after modifiers.
Command	Uiua-style signature	Action
 	0.0 	Does... NOTHING!!!
! 	1 	Factorial
" 	? 	Open/close string
# 	? 	Comment
* 	2 	Exponentiation
+ 	2 	Addition
, 	2 	List separator/Concatenate
- 	2 	Subtraction
. 	1.2 	Duplicate
/ 	modifier 	Reduce
0-9 	0 	Push the corresponding number
: 	2.2 	Flip
< 	0 	Less than
= 	0 	Equals
> 	0 	Greater than
@ 	? 	Character
N 	1 	0-inclusive range
[ 	? 	Open list
\ 	modifier 	Scan
] 	? 	Close list
h 	1 	Head/First
i 	0 	Get user input
o 	1.0 	Output without newline
r 	1 	Reverse
t 	1 	Tail/Last
~ 	1.0 	Pop
× 	2 	Multiplication
÷ 	2 	Division
¶ 	1.0 	Output with newline
Ξ 	1 	Length
Ω 	1 	Make uncountable
== Errors ==
In ~Ω₁, error messages are short and sweet. Their syntax is: G!, where G is the glyph where the error happened.
== Examples ==
=== Hello, World! ===
 "Hello, World!"¶
=== Error quine ===
 Ω!
Of course, that's not the only one.
=== Cat program ===
 i¶
Category:Languages Category:Unimplemented Category:Unknown computational class Category:Stack-based
¡Gbbprosk!

¡Gbbprosk! (Unstylized as Gibbproski) is a joke esoteric programming language by Someone668. It is meant to look like gibberish and almost unusable. Every time you save or open it, it will have a 7.31% chance to change 1 line, which can be stacked on top of each other. You also can't bypass line-dependent integers, as each function should be on a different line.
=== String Types ===
* Pq>ttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttxet<-(assign strnum) - creates a normal string, but must have 65 characters and is read right to left, or sometimes left to right.
* !@(assign strnum):<WoRDs>¡ - creates a normal uncorruptable string, but will have random bad capitalization and change words to be more confusing.
* w9(assign strnum)`<tezu> - creates a string that changes the ascii number of the each letter by 2, 1, or 0.
=== Integer Types ===
* at1-@z<integer>+(intnum)# - creates an integer that is added by 2, 1, or 0 every line.
=== Functions ===
* #4x-h(strnum /intnum) - prints a string
* us(assign strnum/intnum)$(string/integer type comand) - asks the user for a integer/string.
* ad(intnum)://@(intnum) - adds two numbers
* ad+(intnum)://@(intnum) - multiplying (unstable)
== ¡grdprosk! ==
¡grdprosk! Is a Different Version of Gibbproski But grid and number based (not really Gibbproski but gibberish).
Category:Languages
Category:Joke languages
Category:Nondeterministic
¢%

¢% is an esolang made by User:AmNow.
== Architecture ==
Programs in the ¢% language operate on a stack of infinite capacity, storing per element one signed integer datum.
== Commands ==
Loops work like they in do BF.
Command	Description
¢¢¢¢ 	Pop the top stack element
¢¢¢% 	Swap the top stack element with that immediately below it
¢¢%¢ 	Duplicate the top stack element
¢¢%% 	Move the element at the bottom of the stack to the top
¢%¢¢ 	Jump past the matching %%%% if the top stack element is 0
¢%¢% 	Move the top stack element to the bottom
¢%%¢ 	Pop the two top stack elements a and b, compute a+b, and push the result onto the stack
¢%%% 	Pop the two top stack elements a and b, compute a-b, and push the result onto the stack
%¢¢¢ 	Pop the two top stack elements a and b, compute a*b, and push the result onto the stack
%¢¢% 	Pop the two top stack elements a and b, compute round(a/b), and push the result onto the stack
%¢%¢ 	Prompt an integer number from the user and push it unto the stack
%¢%% 	Prompt a Unicode character from the user and push its character code unto the stack
%%¢¢ 	Push 1
%%¢% 	Output the top stack element as a number
%%%¢ 	Output the top stack element as a Unicode character
%%%% 	Jump back to the matching ¢%¢¢ if the top stack element is nonzero
== Programs ==
=== Truth-machine ===
 %¢%¢ ¢¢%¢ %%¢% ¢%¢¢ ¢¢%¢ %%¢% %%%%
=== Cat program ===
An infinitely repeating cat program is implemented in the following:
 %¢%% ¢¢%¢ %%%¢ ¢%¢¢ %¢%% ¢¢%¢ %%%¢ %%%%
== Computational Class ==
¢% is Turing complete since it can simulate BF.
 BF ¢%
 + %%¢¢ ¢%%¢
 - %%¢¢ ¢¢¢% ¢%%%
 < ¢¢%%
 > ¢%¢%
 . ¢¢%¢ %%%¢
 , ¢¢¢¢ %¢%%
 [ ¢%¢¢
 ] %%%%
==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:Turing complete Category:Low-level Category:Stack-based
¯\ (ツ) /¯

¯\_(ツ)_/¯ (or shruglang) is based on the concept of a memory-dynamic language.
==Overview==
Just as brainfuck, it operates in an array of cells, which have an ASCII value each.
Command	Description
\ 	Go to previous cell
/ 	Go to next cell
+ 	Add one unit to the current cell
- 	Subtract one to the current cell
$ 	Print the value as an ASCII character.
_ 	Input a character, encode it, and add make it the cell
{ 	For loop until the referenced cell is 0
} 	Repeat if the cell is not 0, end otherwise
% 	?
@ 	Erase all cells
==Example==
¯\_(ツ)_/¯ is capable of printing "Hello World!" as following:
 
 ++++++++++ |^ Make a counter ^|
 { |^ Initialize a loop ^|
 / |^ Move ONE cell forward ^|
 + |^ Add ONE unit to the current cell
 /
 +++
 /
 +++++++
 /
 ++++++++++
 \ |^ Move ONE cell backwards ^|
 \
 \
 \
 - |^ Subtract ONE unit to the current cell ^|
 } |^ End loop ^|
 /
 /
 /
 ++
 $ |^ Print equivalent ASCII character ^|
 /
 +
 $
 +++++++
 $$
 +++
 $
 \
 \
 ++
 $
 /
 +++++++++++++++
 $
 /
 $
 +++
 $
 ------
 $
 --------
 $
 \
 \
 +
 $
 @ //end program
Category:Languages
Category:2018
Category:Unimplemented
Category:Cell-based
Category:Turing complete
±

± (Pronounced Plus-Minus) is an Esoteric programming language created by User:Buckets in 2024.
 Caption text
Commands	Instructions
±m 	Set a group of Plus or Minus with The integer n.
∓n 	Set a group of Minus or Plus with The integer m, For example: If 1±01 = 2, then 1∓01 = 0.
? 	Print out the current number in ASCII.
_ 	Set ±o to either + or -, or not at all Setting it and Leaving It ambiguous.
"Hello, World!" Program:
 72?*0+101?*0+108??*0+111?*0+44?*0+32?*0+87?
 *0+111?*0+114?*0+108?*0+100?*0+33?
Cat program:
 (1±01)/2+48?
Category:2024
Category:Languages
Category:Joke languages
¼ bytes :3

¼ bytes :3 (¼ bytes=2 bits) is a language to compete with 1 byte :5.
The language output the input, padded by 11 in binary.
==Intepeter==
written in 2 Bits, 1 Byte, there are 6 bits of input.
intepeter in binary, I means input:
 11II IIII
Category:2023Category:Joke_languagesCategory:Low-levelCategory:TotalCategory:LanguagesCategory:Unusable_for_programmingCategory:Implemented
¿

¿ (U+00BF) is a brainfuck equivalent by User:None1.
Every program must start with ¿ (U+00BF) and end with ï (U+00EF), every command is represented by a hex digit.
Position\BF 	+	,	-	.	<	>	[	]
Higher digit	1	3	5	7	9	B	D	F
Lower digit 	0	2	4	6	8	A	C	E
Example: 74 is .- in BF.
==Examples==
===Cat Program===
 ¿<rðï
In hex dump:
 BF 3C 72 F0 EF
===Hello, World!===
 ¿����Ú��Ú�°�°�°^°°´º�ú¶´Tp���v��ºxV��TTTtTTTVº�°�ï
(� replaces unprintable characters)
In hex dump:
 BF 10 10 10 10 DA 10 10 DA 10 B0 10 B0 10 B0 98 98 5E B0 B0 B4 BA 1C 9E 94 FA B6 B4 54 70 10 10 10 76 10 16 BA 78 56 96 10 16 54 54 54 74 54 54 54 56 BA 16 B0 16 EF
==External Resources==
* Interpreter in Python, not only interprets code but also prints out the brainfuck equivalent of code.
Category:Languages
Category:Brainfuck equivalents
Category:Turing complete
Category:2024
Category:Binary
Category:Implemented