nyuuzyou/wikis huggingface dataset:
Ψ

IDEA:a language whose core function makes unnecessary amount of forks and the challenge is making sure it doesnt crash your machine due to RAM overload.
if i'm going to make a multi-threaded language it's going to need
*a way to desynchronise and synchronise threads (2 ops).✓
*a way for threads to communicate (2 ops).✓
*i need to decide on a form of data storage.
*a way to operate data reversibly (2 ops if unlimited. 1 if limited but owerflows.).
*conditionals (1 op).✓
*loops/halts (1 op).✓
ψ or Devilforks is a language created by User:.yazic
the root program is called Higher Daemon
the created subroutines are called Imps
 Caption text
Code	Operation
` 	Broadcast A on signal B. Listen for signal A and put it in B.
+ 	Increment A.
ψ 	subtract A from B. if A !> B fork current Block twice
[ 	Open Block. If A = B jump past matching ]
] 	Close Block. If A != B jump back to matching [
TODO: make this make sense!
Category:Concepts Category:Concurrent programming Category:Works-in-Progress Category:Reversible computingCategory:2023
Ебаное дерьмо

Ебаное дерьмо russian for fucking shit, is an esolang created by User:Yayimhere. it was created becuase he has begun in chatrooms instead of saying fuck shit ect. has just said it in russian
== how it works ==
Ебаное дерьмо uses a stack of single numbers. programs are made up of english words(google translate words, 2024 20.54 26. october danish time denmark) separated by russian words. this is the list of syntax/function
* one english words between to russian words: push the ascii value of the first char of the english word to the stack
* a russian word then a russian NOUN and then a english word: push the absolute value of log n base k where n is the first value popped from stack and k is second
* a russian verb "a Ебаное дерьмо program": make the russian verb into a command which is the Ебаное дерьмо program
* (a russian word): append half of the stack(if it cant be divided evenly then just dont do it) to the program where the values are converted to ascii chars
* : seperate commands
* a russian word 14 english words and a russian noun: copy all stack value and push them
* a single russain word: push the rest of the program's(so after this command) ascii values to stack(reversed)
== Examples ==
Infinite loop:
 ебать, ебать hello hello hello hello hello hello hello hello hello hello hello hello hello hello человек, (ебать), 
== See also ==
* 1 1 an actual computable version(if this is not computable)
Category:Languages Category:Pseudonatural Category:Stack-based Category:2024
Марковский

Марковский (or Markovskiy) is an esoteric programming language created by User: LolloDev5123 designed to operate using a Markov algorithm. In Марковский, programs consist of a series of "states" that are transformed by a set of rules.
== Overview ==
Марковский programs consist of a series of states that are transformed by a set of rules. Each rule is a conditional statement that checks for the presence or absence of certain symbols in the current state and specifies a replacement string that should be used if the condition is met. The program starts in an initial state and applies the transformation rules to the current state, checking after each rule is applied whether the resulting state is a "halt state" that should cause the program to terminate.
== Syntax ==
Марковский programs consist of a series of state definitions, each of which consists of text that represents the state. The syntax for a state definition is as follows:
state "Hello world!"
Rules are defined using conditional statements that check for the presence or absence of certain symbols in the current state and specify a replacement string if the condition is met. The syntax for a rule is as follows:
 condition -> replacement
The condition is a sequence of symbols that must be present or absent from the current state in order for the rule to be applied. The replacement is a string of symbols that should be used to replace the matching sequence if the condition is met.
For example, the following rule replaces any occurrence of the letter "A" with the letter "B":
 A -> B
A program can have any number of rules. The rules are applied to the current state in the order in which they are listed until a halt state is reached.
== Execution ==
To execute a Марковский program, the program is loaded into the interpreter and executed. The interpreter starts by reading the initial state and then applies the transformation rules to the current state. The program terminates and outputs the final state when all rules have been applied.
=== Hello world!===
 "" 
 _ -> Hello, World!
This program defines an initial state that is empty, and then has a rule that checks for the presence of any symbol (represented by the underscore character, a wildcard in Марковский) in the current state. If a symbol is present, the program replaces the current state with the string "Hello, World!" and terminates.
=== Quine ===
 state "a -> aq"
 q -> q
The program starts in the initial state, which contains the string "a -> aq". The first rule replaces any occurrence of "q" with the string "q", effectively doing nothing. The program halts when there are no more rules that can be applied, leaving the final state as the original source code.
Category:Languages
Category:Turing complete
Category:String-rewriting paradigm
Category:Unimplemented
Мне с тобою так повезло

Мне с тобою так повезло is a functional Turing-complete esoteric programming language invented by User:Hakerh400 in 2021.
== Overview ==
This language operates on strings. Everything is a string, including functions. Each function can be stringified and each string can be executed.
== Functions ==
* . - Get the current argument as a string
* # - Get the current function as a string
* *abc| - If string a starts with bit 1 then call b with the rest, otherwise call c with the rest
* @ab| - Make a pair of a and b
* <a| - Get the first element of pair a
* >a| - Get the second element of pair a
* 0a - Prepend bit 0
* 1a - Prepend bit 1
* (a) - High precedence group
* [a] - Stringify function a
== Examples ==
=== Cat program ===
 .
Try it online
=== Invert bits ===
 *@.#|[>.|][1(*@>.|<.||[1(*0(>.|)<.||)][0(*0(>.|)<.||)]|)]|
Try it online
=== Reverse bits ===
 *0(@.|)[*@.#|[<>.||][*@@>>.||<>.|||<.||[*0(@>>.||10(<>.||)|)<.||][*0(@>>.||11(<>.||)|)<.||]|]|]|
Try it online
=== Hello, World! ===
 1010101110101110111011101011111010101111101111101010111110111110111111111011111010101111101110101010
 1010101110101111111011101110111111111011111010111010111111101010111110111110101011101011111011101010
 10111010.
Try it online
== Interpreters ==
Interpreter
Category:Languages
Category:Turing complete
Category:2021
Category:Implemented
Category:Functional paradigm
Монгол хэл

For ease of use, I'm going to go ahead and use the wrong title.
Монгол хэл is a language based on Manchu Mongolian.
== Syntax ==
 Caption text
Монгол хэл 	Pseudo code
ᠳᠠᠷᠤᠮᠠᠯᠠᠬᠤ (comment)᠃ 	print(comment)
ᠣᠷᠣᠭᠤᠯᠬᠤ (something) [(prompt) ᠪᠡᠷ ᠰᠠᠨᠠᠭᠤᠯᠤᠮᠵᠢ ᠪᠣᠯᠭᠠᠨ᠎ᠠ]᠃ 	input(something, [__prompt])
ᠬᠡᠷᠪᠡ (expr)᠃ 	if(expr)
ᠪᠠᠰᠠ ᠪᠤᠴᠠᠭᠠᠶ᠎ᠠ ᠃ 	else
ᠪᠠᠰᠠ ᠪᠤᠴᠠᠭᠠᠶ᠎ᠠ ᠬᠡᠷᠪᠡ (expr)᠃ 	elif(expr)
ᠳᠠᠪᠬᠤᠷᠳᠠᠭᠤᠯᠤᠨ 10 ᠤᠳᠠᠭ᠎ᠠ᠃ 	for (i in range(10))
ᠳᠡᠭᠡᠷ᠎ᠡ ᠳᠤᠷᠠᠳᠤᠭᠰᠠᠨ ᠠᠯᠬᠤᠮ ᠳᠠᠷᠠᠭ᠎ᠠ ᠶᠢ ᠳᠠᠬᠢᠨ ᠳᠠᠪᠲᠠᠨ ᠳᠠᠪᠲᠠᠨ (expr) ᠪᠣᠯᠲᠠᠯ᠎ᠠ true ᠪᠢᠰᠢ᠃	while(expr)
(var) ᠶᠢ (type) ᠪᠠᠷ ᠲᠣᠮᠢᠶᠠᠯᠠᠨ᠎ᠠ ᠃ 	def var -> type
(var) ᠶᠢ (val) ᠪᠣᠯᠭᠠᠨ ᠲᠣᠬᠢᠷᠠᠭᠤᠯᠤᠨ᠎ᠠ ᠃ 	var=val
ᠡᠶ᠎ᠡ ᠨᠠᠶᠢᠷᠠ 	and
ᠡᠰᠡᠬᠦᠯ᠎ᠡ 	or
ᠦᠭᠡᠢ 	not
ᠦᠨᠡᠨ 	true
ᠠᠮᠠᠷᠠᠯᠲᠠ 	false
ᠪᠦᠬᠦ ᠲᠣᠭ᠎ᠠ ᠃ 	int
ᠪᠠᠭ᠎ᠠ ᠲᠣᠭᠠᠨ ᠤ ᠃ 	float
ᠦᠰᠦᠭ ᠦᠨ ᠲᠡᠮᠲᠡᠭ ᠃ 	char
ᠦᠰᠦᠭ ᠨᠢ ᠲᠡᠮᠲᠡᠭ ᠃ 	str
ᠪᠦᠷ ᠃ 	bool
ᠲᠦᠷᠦᠯ ᠦᠭᠡᠢ᠃ 	void
== Program ==
=== Hello, world! ===
 ᠳᠠᠷᠤᠮᠠᠯᠠᠬᠤ "Hello, world!"᠃
=== A+B Problem ===
 a, b, c ᠶᠢ ᠪᠦᠬᠦ ᠲᠣᠭ᠎ᠠ ᠪᠠᠷ ᠲᠣᠮᠢᠶᠠᠯᠠᠨ᠎ᠠ ᠃
 ᠣᠷᠣᠭᠤᠯᠬᠤ a
 ᠣᠷᠣᠭᠤᠯᠬᠤ b
 c ᠶᠢ a+b ᠪᠣᠯᠭᠠᠨ ᠲᠣᠬᠢᠷᠠᠭᠤᠯᠤᠨ᠎ᠠ ᠃
 ᠳᠠᠷᠤᠮᠠᠯᠠᠬᠤ c
Category:Languages
Собачка

Собачка is a string-rewriting esolang invented by User:Hakerh400 in 2022.
== Overview ==
Source code consists of a list of decimal digits. The interpreter rewrites the list until the program halts. The output is a single digit.
== Rewriting rules ==
Repeat this until the program halts. If the list is empty, output digit 0 and halt. If the list contains exactly one digit, output that digit and halt. Otherwise, rewrite the list using the following algorithm.
For each two consecutive digits a and b:
* If a+b\le9, produce list [a + b]
* Otherwise, if a=b, produce list [a]
* Otherwise, if a, produce list [1, a + b - 10]
* Otherwise produce an empty list
Concatenate all productions in order. It represents the new list of digits.
== Example ==
Program:
 4866857774615622223321
Computation steps:
 4866857774615622223321
 12614127710761184445653
 38755397817729889118
 1158121598791181729
 2613933614162998911
 874126975578119172
 5381551215921089
 81196563361431817
 9210119697574998
 3112101512139
 4233116633412
 656427696753
 116915138
 271566411
 98611652
 7277
 997
 9
The output is 9.
== Implementation ==
Implementation in Haskell:
<nowiki>
type N = Integer
infixr 0 #
(#) = id
xs :: [N]
xs = [1, 2, 3, 4, 5]
f :: N -> N -> [N]
f a b = let c = a + b in
 if c <= 9 then [c] else
 if a == b then [a] else
 if a < b then [1, c - 10]
 else []
step :: [N] -> [N]
step xs = concat # zipWith f xs # tail xs
run :: [N] -> [[N]]
run xs = if null xs then [[0]] else
 xs : if length xs == 1 then [] else run # step xs
main :: IO ()
main = mapM_ (putStrLn . (>>= show)) # run xs
</nowiki>
== Computational class ==
We conjecture that this language is total.
Category:Languages
Category:Implemented
Category:2022
Category:String-rewriting_paradigm
Твердою

Твердою or in english: solid is a esolang made by User:Yayimhere where its NEAR IMPOSSIBLE to modify data. the data is very "solid". it also 2d for some reason??
==overview==
simply there are some rules:
* all numbers for address access must exist in the same address
* numbers for actual use must also exist in this address
* the ... should only be used if the structure repeats. else it just gives the last operation before it came same again and again. whats at the end is the ocre that where used and what part of it was being used for infinity and the number it was meant to be. this number is not cared about if in memory. unless it is address space
===memory===
you start by defining the memory:
 addr(name of addr): [base64 numbers separeted by ⨳]
example:
 addr(one): [AQ==⨳]
===rules for 2D===
the following table shows what things do what for the sake of connecting things in 2d
 Caption text
symbol	name 	description
|	vertical wire 	send number vertically
- 	horizontal wire	bring number horizontally
+ 	crossin 	move signal at angels
two things that go horizontal connect to things on same line and is next to it. and for vertical its the same but with collumns and next to it in the vertical sense
===non modifying cores===
these cores do not modify data(we will wait for dat when you are ready for those terrors)
====number core====
to reference a number in a address you write:
 ⌬-⨊addr name
 |
 ⨋number of ⨳'s before this number
these can be swapped but the symbols is what matters
so for our example it would be:
 addr(one): [AQ==⨳CQ==⨳...]
 ⌬+⨊one
 | |
 ⨋⌬+
 |
 ⨋...⨋0
because that every number in Твердою has to exist in memory this structure "would" continue forever. BUT the ... makes the program know(for this structure only) that its infinite in size. the ⌬ is the core. this symbol is what determines what this function will do. also the ... in address space means that now the addres has all numbers. 1 is at the front then comes 0 then the rest of the number line(so 2, 3, 4...)
====print core====
now if we want to print it instead we replace the first ⌬ with a ⌦ so:
 addr(one): [AQ==⨳CQ==⨳...]
 ⌦+⨊one
 | |
 ⨋⌬+
 |
 ⨋...⨋0
this simply prints 1. or it prints it in base 64.
====normal print core====
if we want it to become the actual number 1 you would need to use the ☭ core. and its more complicated. yaaaaaaaaaaay.
 addr(one): [Cg==⨳AQ==⨳CQ==⨳...]
 ⌬-⨊one
 | |
 ⨋⌬|
 |
 +⨋...⨋10
 |
 ☭+⨊one
 | |
 ⨋⌬+
 |
 ⨋...⨋1
the part above is the base you want to print it in
====ascii print core====
is print core but for ascii
 addr(one): [AQ==⨳CQ==⨳...]
 ⭔+⨊one
 | |
 ⨋⌬+
 |
 ⨋...⨋0
 this would print: SOH as that's what it is on the ascii table(its not a char but a operation btw)
===modifying cores===
let the horror begin
====modify @place + core====
modify a already existing number with +
and here i stop cuz its still in work and im tired -_-zzzzz
Хязгаар

хязгаар is mongolian for range. хязгаар is stackbased and kinda just a random esolang User:yayimhere made. it is kinda like deadfish. its also kinda 2d
== syntax ==
; pop the top thing of the stack output it and put it back onto the stack
\TEXT\ push text to the stack.
#base64 number push base64 number to the stack
(base64 number:other base64 number) run all the lines in the range from base 64 number to other base 64 number in place of what line this command is on
 >∨
 ∧<
befunge style arrows
⍵ convert top string on the stack to a int
⍨ opposite of ⍵
% random pointer direction
= end program
( and ) loop whats inside the brackets while there is more than 3 things on the stack
$ user input
[ and ] loops whats inside if and only if the top of the stack is not a 0
$base64 number{ and } replace whats inside the {} after it has been ran with the the base64 numberth line(yes self modifying) if and only if the top of the stack is not 0
@ take the two top values on the stack and use as the next to highest as x and highest as y and add whats at that coords to the stack 
⋂ its @ but with a square thats the bottom value by the next to bottom value. 
: replace with whats on the top of the stack
<|> reverse the whole stack
⌿-⍀ chooses the first option(first -(vertically |) if the top of the stack is more than one the second - if more than two and so on and the last - is just if none of the others where true. goes down vertically from each -
⑂ add together top two values
➫ subtract the second to first value on the stack from the first value on the stack
𝄡 multiply the top two values
𝄆 and 𝄇 loop whats in the brackets if there are no 0's on the stack
⑃ divide the top value by 2
⩷ put all single letter strings together into one string(goes so the topmost string will be the start of the string
! NOT. if 0 is top of stack return 1 else 0
/ pop top value of stack
_ push user input onto stack as a string
, duplicate the top of the stack
“ duplicate top of stack
the grid is infinite in downwards and left directions. the program pointer starts by going left in upper right corner
== Programs ==
truth-machine:
 >$[“,]
Category:Languages Category:Stack-based Category:Two-dimensional languages
Юᓂ곧⎔

Юᓂ곧⎔ is an unfinished plan for a programming language by David Madore in the blog post A Unicode-obfuscated programming language proposal. 
Source code written in Юᓂ곧⎔ is text, and it must not contain ASCII characters other than line feed, even inside string literals. Юᓂ곧⎔ makes use of different scripts and symbols to denote different kinds of identifiers and syntax elements. In particular, function names must be written in Cyrillic, function arguments are written in hiragana when the function is declared, and the corresponding name in katakana is used within the function definition. Numeric literals are written in three different sets of characters serving as digits depending on whether you want octal, decimal, or hexadecimal.
=== Hello world program ===
 ⌂ «»
 ☹
 писать «“⁌☱☱☰⁍⁌☱☴☵⁍⁌☱☵☴⁍⁌☱☵☴⁍⁌☱☵☷⁍⁌☰☵☴⁍⁌☰☴☰⁍⁌☱☶☷⁍⁌☱☵☷⁍⁌☱☶☲⁍⁌☱☵☴⁍⁌☱☴☴⁍⁌☰☴☱⁍␊”»।
 ☺
== External resources ==
* 'Compiler toolchain' Ongoing implementation. Written in bash + sed (requires gcc) .
Category:2004
Category:Languages
Category:Unimplemented
Category:CJK
العربية

العربية is a language based on Arabics.
== Syntax ==
 Caption text
العربية 	Pseudo code 	
طبع (comment) 	print(comment) 	
المدخلات (something) مع (prompt)	input(something, __prompt)	
كرر 10 مرات 	for(i in range(10)) 	
كرر حتى expr غير صحيح 	while(expr) 	
لو (expr) 	if(expr) 	
اخر 	else 	
اخر لو (expr) 	elif(expr) 	
تعريف A ك 10 	def a=10 	
تعريف B (type) صحيح 	def b -> type 	
اضبط C على "مرحبا" 	c="Hello" 	
تعريف fun(الحجج) 	fun start(args) 	
و 	&& 	
أو 	 	
لا 	! 	
صحيحا 	int 	
عشريتان 	float 	
حرف 	char 	
خيط 	str 	
منطقيه 	bool 	
خلاء 	void 	
الحقيقي 	true 	
خطأ 	bool 	
etc. 	etc. 	
== Programs ==
=== Hello, world ===
"!طبع "مرحبا أيها العالم
=== A+B ===
تعريف ا,ب,ج صحيح صحيح
المدخلات ا,ب
اضبط ج على ا+ب
طبع ج
== See also ==
قلب
Category:Languages
قلب

قلب is a programming language by Ramsey Nasser. The name means Heart and is a recursive acronym for قلب: لغة برمجة meaning Heart: A Programming Language. Acronyms in Arabic are uncommon and difficult to pull off, and the author states that this is the first recursive one he has seen. It was created as an art installation.
== Examples ==
Look on the right side of the page.
=== Hello world ===
‫(قول "مرحبا يا عالم!")
=== Fibonacci (fybunatshi.qlb) ===
(حدد فيبوناتشي (لامدا (ن)
 (إذا (أصغر؟ ن ٢)
 ن
 (جمع (فيبوناتشي (طرح ن ١))
 (فيبوناتشي (طرح ن ٢))))))
(قول (فيبوناتشي ١٠))
=== Truth-machine (حق) ===
( حــدد حق ( لامدا ( علي )
 ( قــــــــــــول علي )
 ( إذا ( يســـاوي؟ علي ١)
 ( حـــــــــق علي ))))
Call with either (حق ٠) or (حق ١).
=== Collatz sequence ===
Function named (possibly incorrectly) الكولاتز. Plays with creative code layout, which appears to be a feature of this language. 
(حدد الكولاتز (لامـدا(ن)
 (قــــــــــول ن)
 (إذا (يساوي؟ ١ ن)
 ( ن)
 ((حدد نــــصف (قسم ن ٢))
 (إذا (يساوي؟ نـصف 
 (أرض نـصف)) 
 (الكولاتــز نـصف)
 (الكولاتــز (جمع ١ 
 (ضرب ن ٣))))))))
Example use: (الكولاتز ٢٥)
== External resources ==
* 
* Author's website
== Implementation ==
* https://github.com/nasser/--- (also contains game of life example)
* http://qlb-repl.herokuapp.com/ (live REPL)
Category:Languages
Category:2012
Category:High-level
Category:Functional paradigm
Category:Turing complete
Category:Implemented
అంతులేనిబైనరీలు

అంతులేనిబైనరీలు (pronounced /antulenibaɪnaɾilu/) is an esoterical programming language with an infinite tape but only 2 states possible in those tapes.
==Commands==
 + flip cell at pointer (0 turns to 1, 1 turns to 0)
 > move pointer right
 < move pointer left
 [ go to corresponding ] if cell at pointer is 0
 ] go to corresponding [ if cell at pointer is 1
 . output cell at pointer
 , replace cell at pointer with input from 0 to 1
 ( go to corresponding ) if cell at pointer is 1
 ) go to corresponding ( if cell at pointer is 0
 { begin a forever loop
 } end a forever loop (rare case)
==Examples==
===Cat===
 {,.
===11111011111===
 +.....>.<.....
===Truth machine===
 ,[.].
===Nop===
 
Category:LanguagesCategory:Brainfuck derivativesCategory:Cell-based
ಠ ಠ

= The Stack =
ಠ_ಠ is stack-based. If you’re unfamiliar with stack-based programming, this language is a good place to start.
Imagine the stack as a list. In stack-based programming, the code depends on the stack for values to perform operations on. For example: instead of doing 5 + 6, stack-based programming would do something like push 5 to the stack, push 6 to the stack, and add the top two numbers in the stack - or, more concisely, 5 6 +.
= Line-Jumping =
In addition to having a stack, ಠ_ಠ has a feature to jump to lines. This is done through conditional if-else statements. This feature is sort of like a lbl-goto feature in BASIC, but lbl is replaced by line numbers. (More on this later.)
= Syntax =
ಠasdfasdfasdfಠ #note how every line is wrapped with ಠ
ಠ_ಠ #newlines are added for every command
NOTE: there are no comments allowed - if you want to run this program properly, delete the comments!
Here are all reserved chars: ಠ+-*/%_|$~“()=>?@^!`. Anything inside ಠ’s that is not reserved will be evaluated as a number (if possible), or a string.
= I/O =
ಠ_ಠ #push input items (separated by newlines) to the stack
The last item in the stack is outputted at the end of the program. It’s the program’s only means of outputting.
= Math with the Stack =
ಠ+ಠ
ಠ-ಠ
ಠ*ಠ
ಠ/ಠ
ಠ%ಠ
All of these operators push the result from the top two stack items to the stack.
Usage:
ಠ5ಠ
ಠ6ಠ
ಠ+ಠ
There’s also the random operator (ಠ@ಠ), which randomly choose 0 or 1 and pushes the result to the stack.
= Logic with the Stack =
ಠ=ಠ #pushes 1 or 0 depending on whether the top two stack items are equal
ಠ>ಠ #pushes 1 or 0 depending on whether the top stack item is greater than the second stack item from the top
= Manipulation with the Stack =
ಠ$ಠ #pop the top item from the stack
ಠ~ಠ #clear the stack
ಠ`ಠ #swap the top two stack items
ಠ"ಠ #swap the top and third from top stack items
ಠ(ಠ #take the bottom stack item and move it to the top
ಠ)ಠ #take the top stack item and move it to the bottom
ಠ^ಠ #split top stack item along chars after ^ and push results to the stack
ಠ!ಠ #join the entire stack with chars after ! and push result to the stack
ಠ'ಠ #push the stack's length to the stack
= Conditional Statements =
ಠ?ಠ
This is the most versatile operator ever in the history of coding. Not only is it an if-else, but it is also: - A loop (think while or for). - A goto-line-x operator. - A way to stop the program. It takes the top three stack items (all numbers). If the top item is truthy, then the program goes to the line number specified by the second stack item from the top; otherwise, it goes to the line number specified by the third stack item from the top.
= The Useless Operator =
ಠ益ಠ
Go try it yourself.
Oh yeah, if you successfully incorporate this operator seamlessly into your code at a code-golfing challenge, then you automatically get -100000 bytes as your score. Enjoy!
Category:Languages
Category:Stack-based
Category:2017
ඞ

ඞ is an Eek! derivative by the Amogus Esolang Crew, mostly by User:VilgotanL and User:Zero player rodent.
The only difference between ඞ and Eek! is that E, e, and k are replaced by ඞ, ඩ and ඬ.
== Instructions ==
ඞ	Eek!
ඞ	E
ඩ	e
ඬ	k
== Examples ==
=== Cat program ===
ඞඞඞඞඩඩඩඩඞඩඩඩඞඩඩඩඩඩඬ
== Implementations ==
Ruby interpreter
#!/usr/bin/env ruby
eval '$m=Hash.new($p=0); $q=Hash.new($d=0); $h=Hash.new($j=0); ($r=0); ($f=0);'+ARGF.read.gsub(/./,
 'ඞ' => '$p+=1;',
 'ඩ' => '$m[$p]+=1; $m[$p]=20 if $m[$p]>20;', #<- Remember to change this when making new commands
 'ඬ' => '$p+=1; $m[$p]+=21;',)
$p=0
while 0==0
$p+=1
$p+=2 if $m[$p]==10 and $q[$d]==$r
$p+=2 if $m[$p]==11 and $q[$d]!=$r
$r+=1 if $m[$p]==0
$q[$d]+=1 if $m[$p]==1
$q[$d]+=10 if $m[$p]==2
putc $q[$d] if $m[$p]==3
$q[$d]=STDIN.getbyte if $m[$p]==4 and !STDIN.eof
$p-=$r if $m[$p]==5
$d+=1 if $m[$p]==6
$q[$d]=0 if $m[$p]==6
$d-=rand($r) if $m[$p]==7
$p+=$r if $m[$p]==8
$d-=1 if $m[$p]==9
$r-=1 if $m[$p]==12
$r=0 if $m[$p]==13
$r=$q[$d] if $m[$p]==14
$d+=1 if $m[$p]==15
$q[$d]=$r if $m[$p]==15
print $q[$d] if $m[$p]==16
$j+=1 if $m[$p]==17
$h[$j]=$q[$d] if $m[$p]==17
$d+=1 if $m[$p]==18
$q[$d]=$h[$j] if $m[$p]==18
$j-=1 if $m[$p]==19
$q[$d]-=1 if $m[$p]==20
exit if $m[$p]==21
end
Category:Languages
Category:Joke languages
Category:2021
Category:Implemented
Category:Sus
ඞlang without Quine

ඞlang without Quine is an Esolang designed by PSTF. If your source code is ඞ, then output these:
僧伽罗语（සිංහල），是斯里兰卡的官方语言之一。
是占斯里兰卡大多数人口的僧伽罗人的语言；使用人口大约一千九百万。
从1956年开始，僧伽罗语及泰米尔语同时都是《斯里兰卡宪法》上承认的官方语言。 
僧伽罗语是属于印欧语系的印度-伊朗语族的印度-雅利安语支的一种语言。
马尔代夫官方语言之一的迪维希语是与之相近的语言。
僧伽罗语书写采用源自古印度北部婆罗米文而形成的僧伽罗文。
在僧伽罗语中，有一些字母很像《在我们之间》里面的角色，比如说 D（ඩ） 或者是 Ng（ඞ） 。
Otherwise, output ඞ.
== Implementation ==
=== Python ===
go = """
僧伽罗语（සිංහල），是斯里兰卡的官方语言之一。
是占斯里兰卡大多数人口的僧伽罗人的语言；使用人口大约一千九百万。
从1956年开始，僧伽罗语及泰米尔语同时都是《斯里兰卡宪法》上承认的官方语言。 
僧伽罗语是属于印欧语系的印度-伊朗语族的印度-雅利安语支的一种语言。
马尔代夫官方语言之一的迪维希语是与之相近的语言。
僧伽罗语书写采用源自古印度北部婆罗米文而形成的僧伽罗文。
在僧伽罗语中，有一些字母很像《在我们之间》里面的角色，比如说 D（ඩ） 或者是 Ng（ඞ） 。
"""
while True:
 src = input()
 if src == "ඞ":
 print(go)
 else:
 print("ඞ")
=== Other ===
මට ඒක තවත් ලියන්න බෑ.
== Categories ==
Category:Languages Category:Implemented Category:Output only Category:Total Category:Unusable for programming Category:2024 Category:Zero-dimensional Category:Sus Category:No-code esolang
ᖴᑌᑎᑎEᒪIᑕ

funnelic is esotecric programming language to execute simple math functions:
 symbols
symbol	does 	how
v 	funnel down 	:
^ 	funnel up 	:
> 	funnel right	:
< 	funnel left 	:
+ 	add 	:
- 	subtract 	:
/ 	divide 	:
* 	multiply 	:
" 	catch number	:
. 	output 	:
example:
>"16" /"8"> v
 *
 "
 2
 "
 v
 .
Category:Languages