nyuuzyou/wikis huggingface dataset:
TinyF

TinyF is a brainfuck derivative created by Cursor AI and prompted by User:None1.
==Specification==
TinyF has the following commands:
*> - Move the memory pointer to the right.
*< - Move the memory pointer to the left.
*+ - 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.
** - Multiply the current cell value by the next cell value.
*! - If the current cell value is zero, skip the next command.
==Interpreter==
Written in C++, generated by the Cursor AI.
#include <iostream>
#include <vector>
class TinyFInterpreter {
private:
 std::vector<int> tape;
 int ptr;
public:
 TinyFInterpreter() : tape(30000, 0), ptr(0) {}
 void interpret(const std::string& code) {
 for (size_t i = 0; i < code.size(); ++i) {
 switch (code[i]) {
 case '>':
 ++ptr;
 break;
 case '<':
 --ptr;
 break;
 case '+':
 ++tape[ptr];
 break;
 case '-':
 --tape[ptr];
 break;
 case '.':
 std::cout << static_cast<char>(tape[ptr]);
 break;
 case ',':
 tape[ptr] = std::cin.get();
 break;
 case '*':
 tape[ptr] *= tape[ptr + 1];
 break;
 case '!':
 if (tape[ptr] == 0 && i + 1 < code.size()) {
 ++i; // Skip the next command
 }
 break;
 }
 }
 }
};
int main() {
 TinyFInterpreter interpreter;
 std::string code;
 std::cout << "Enter TinyF code: ";
 std::getline(std::cin, code);
 interpreter.interpret(code);
 return 0;
}
Category:Languages
Category:2024
Category:Brainfuck derivatives
Category:Implemented
Category:Total
Category:Generated by AI
Titled

Titled is mostly a copy of brainfuck, however there are 2 more commands (technically making it Brainfuck+2) and one quirk.
Also there's the ' command which disables wrapping but numbers still have to be positive.
==Code execution==
In Titled, programs are written inside of the file's name. There are no external files; just rename the interpreter. The name (excluding the file extension) is the code to be run.
For input operations: no input = 0
==Instructions==
+	Increments the current cell by one
-	Decrements the current cell by one
)	Selects the cell one to the right (used parenthesis because you can't have angle brackets in the file name)
(	Selects the cell one to the left
,	Takes a single character input from user and stores its Unicode value in the current cell
;	Does the same but with a number; sets the cell value to the number
.	Outputs the current cell as a Unicode character
'	Outputs the current cell as a number. (Having 65 in a cell would output 65, not A)
$	Toggles cell overflow
==Example programs==
Note: All programs listed here use the Python implementation. Also make sure to delete any newlines before renaming your implementation.
Most programs will be the same as brainfuck, but with the angle brackets replaced with parenthesis. For all the examples, add the interpreter's file extension after it.
===Hello, World!===
 )++++++++
 [)+++++++++)++++++++++++)+++++++++++++)++++++++++++++)++++++)++++)+++++++++++)++++++++++++++[(])-])
 .)+++++.)++++..)-.)----.).)-.(((.+++.(.(-.))))+.
===A+B Problem===
 $;);[(+)-]('
==Implementations==
===Python===
code = __file__.split("\\")[-1][:-3]
loopStack = []
overflow = True
index = 0
memory = [0] * 30000
memoryPointer = 0
while index < len(code):
 match code[index]:
 case "(":
 memoryPointer -= 1
 case ")":
 memoryPointer += 1
 case "+":
 memory[memoryPointer] += 1
 if memory[memoryPointer] > 255 and overflow:
 memory[memoryPointer] = 0
 case "-":
 memory[memoryPointer] -= 1
 if memory[memoryPointer] < 0 and overflow:
 memory[memoryPointer] = 255
 case ",": # input as char
 temp = input("input one character:\n> ").rstrip()[0]
 memory[memoryPointer] = temp
 case ";": # input as num
 try:
 temp = int(input("input a number:\n> ").strip())
 except:
 temp = 0
 memory[memoryPointer] = temp
 case ".": # output as char
 print(chr(memory[memoryPointer]), end="")
 case "'": # output as num
 print(memory[memoryPointer], end="")
 case "[":
 if memory[memoryPointer] == 0:
 # skip loop
 loopAmount = 1
 while loopAmount > 0:
 index += 1
 if code[index] == '[':
 loopAmount += 1
 elif code[index] == ']':
 loopAmount -= 1
 else:
 # enter loop
 loopStack.append(index)
 case "]":
 if memory[memoryPointer] != 0:
 # go back to to the '['
 index = loopStack[-1]
 else:
 # exit
 loopStack.pop() 
 case "$":
 overflow = not overflow
 index += 1
== See also ==
* Brainfuck+2
* brainfuck
== External resources ==
* Github for Titled implementations
Category:Languages Category:Brainfuck derivatives Category:2024 Category:Turing complete Category:Cell-based Category:Implemented
Tixy

Tixy, also known as tixy.land after the domain name of the reference implementation, is a subset of ECMAScript intended to animate a 16x16 two-color dot matrix. It was originally introduced as part of an open-ended artistic golf challenge which limited programs to 32 characters. The name is an wikipedia:acronym from the four named parameters available to programs: time in seconds, index in the unraveled dot matrix, X coordinate or row in the matrix, and Y coordinate or column in the matrix.
== Specification ==
A Tixy program is an ECMAScript expression using literals, the four variables `t`, `i`, `x`, `y`, and methods from the `Math` object. Math methods can be used as if they were functions; e.g. `sin` may be written instead of `Math.sin`.
== External Links ==
* tixy.land online interpreter
* the Twitter announcement of tixy.land
Category:2020
Category:Implemented
Category:Turing complete
Tiếng Việt

Because of the Georgia font is really **** so the acute is in the wrong place.
Tiếng Việt is an Pseudo-natural Programming Language designed by PSTF.
== Syntax overview ==
Like ^English, but it is Vietnamese version.
Both 喃𡨸 and TiengViet are supported.
== Examples ==
They're in Tiếng Việt/Examples.
== Categories and references ==
Category:Languages
Category:2025
Category:Unimplemented
Category:High-level
Category:Pseudonatural
Tiếng Việt/Examples

Here are some example for Tiếng Việt.
== Hello, world! ==
 In "Xin chào, thế giới!".
== A+B Problem ==
 Nhập hai số nguyên từ người dùng, sau đó in tổng của chúng.
== Quine ==
 In mã nguồn của chương trình này. UINEGIXNGAEIUgxiue giu giuXGPIUAXIUGXIUp ghse gox gpuiGPWIUGIABXGP gpir iyxgnPIUGEIUCGAER cgiuepnrgsciug j f f f f f f fddd fdd f f f f f f f fgUIPXEBIA&EXIUEGXULE.
== 99 bottles of beer(s) ==
Đọc một số nguyên từ người dùng và sau đó gán nó cho x và đẩy nó vào ngăn xếp.
Nếu x lớn hơn 0 thì hãy thực hiện các mã này mãi mãi:
In "%1 chai bia trên tường, \n%1 chai bia.\n". Tất cả %1 ở đây sẽ được thay thế bằng x.
Giảm x và sau đó in "Lấy 1 xuống và chuyền nó xung quanh, \n"
Nếu x vẫn lớn hơn 0 thì in "%1 chai bia trên tường.\n\n". Tất cả %1 ở đây sẽ được thay thế bằng x.
Nếu không, hãy in "không có chai bia trên tường.\n\n".
Kết thúc vòng lặp.
In "Không còn chai bia trên tường, nkhông còn chai bia.\n".
Bật x từ ngăn xếp và khôi phục nó.
In "Đi đến cửa hàng và mua thêm một chút, \n%1 chai bia trên tường.\n\n". Tất cả %1 ở đây sẽ được x.
Vứt x vào thùng rác.
== Không. interpreter ==
 Nhập một chuỗi từ người dùng và ném nó vào thùng rác, sau đó xuất ra "Không." mà không có dòng mới.
== Collatz function/sequence ==
Nhập một số nguyên từ người dùng, sau đó gán nó cho x.
Lặp lại những điều này cho đến khi x = 1:
Đối với mỗi bước, nếu x là chẵn, thì gán x/2 cho x, nếu không, gán 3x+1 cho x.
In giá trị của x bằng một dòng mới.
Kết thúc vòng lặp.
In "Tất cả đã xong." mà không có dòng mới.
Vứt x vào thùng rác.
== Insertion sort ==
--- CHÈN SẮP XẾP ---
Quá trình sắp xếp chèn trực tiếp là lần lượt chèn từng phần tử vào một trình tự có trật tự. 
Tất cả các phần tử được chia thành các khu vực có trật tự và không có trật tự, 
mỗi lần lấy phần tử đầu tiên từ khu vực không có trật tự, 
so sánh nó với từng phần tử trong khu vực có trật tự từ sau ra trước, 
tìm vị trí chính xác và chèn phần tử vào đúng vị trí. 
Khu vực được sắp xếp ban đầu chỉ có một phần tử. Nhớ lại tình huống chơi bài, 
khi các lá bài được chia theo số điểm và chất. 
Đây là cách sử dụng sắp xếp chèn.
---KẾT THÚC---
Xác định một danh sách và đọc danh sách từ người dùng.
Chèn sắp xếp toàn bộ danh sách và xuất kết quả.
== MNNLTVTTDNN interpreter ==
 Chương trình này không làm gì cả.
Tjʊrɪŋ məʃin

Tjʊrɪŋ məʃin (stylized "tjʊrɪŋ məʃin") is a joke esoteric programming language created by Cinnamony. The only goal for this language was to be turing complete.
==Commands==
 read(slot) - Prints out the number in a slot.
 input(slot) - Asks for a user input and writes it in a slot.
 write(number,slot) - Writes a number in a slot.
==Examples==
===Hello World===
Due to the number-only limitations, we have to write the ascii codes for it.
 write(72,1)
 write(101,2)
 write(108,3)
 write(108,4)
 write(111,5)
 write(32,6)
 write(119,7)
 write(111,8)
 write(114,9)
 write(108,10)
 write(100,11)
 write(33,12)
 read(1)
 read(2)
 read(3)
 read(4)
 read(5)
 read(6)
 read(7)
 read(8)
 read(9)
 read(10)
 read(11)
 read(12)
===Cat program===
A one-time numeric cat program shall be demonstrated:
 input(1)
 read(1)
==Interpreter==
* Common Lisp implementation of the Tjʊrɪŋ məʃin 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:Joke languages Category:Unusable for programming Category:Total Category:Implemented
TlhIngan

For ease of use, I'm going to go ahead and use the wrong title.
This language also called .
tlhIngan is a language based on all kinds of bizarre symbols and words.
== Syntax ==
Yeet. You can write as much as you like, I simply don't give any fsck.
== Program(ASCII format) ==
=== Hello, world ===
 |CQ#{Y*HPi'hvihMUWPV(<TOjlsg,({W)LITP\O:WC)#O:ir[ispououm'X(!P<U"PI~0q@:R|#Q)VRIPOJlHLSFHNSK:B
=== A+B Problem ===
 J)({#MUPWN#RPCWBYEWORCNLDFEKHAEKDJ>SHEB>FLSDIJV?FOU"PUp9imsopntjco8hm:WL#%IVN:Wmp9u8oh7i4yOC@(U${)!L@c-]l9]+C#_}WKUtpo
 i<)({W#I%VRWMit'mjslkfjvslknTLISK:FRJLHvgi;hiU$$IFOJVLJ>RSOEH:MRUVp;foeklvkp;yursinr'
== Program(锟斤拷 format) ==
=== Hello, world ===
 龘齉爨靐亹麷麷麷麤龘麤邉鑪鼕鼙龘䶑鼙嚏攮馕麤龘龘𪚥龘盦麤灥厵鯓嘁鼕
=== A+B Problem ===
 龘䶛䨻䎱㸞蚮䡶䴞䴝䯬䬛䰕㹚㱎䖘䵈䶁䘔䶑䘓鋱䩳䵷㒪䪉䉥䥸䝟䳮䟑䎘䫱䉷
 䰯䕈䟐龘䶛䨻䎱㸞蚮䡶䴞䴝䯬䬛䰕㹚㱎䖘䵈䶁䘔䶑䘓鋱䩳䵷㒪䪉䉥䥸䝟䳮䟑
 䎘䫱䉷䰯䕈䟐䬝䥰龘䰕䘋㽌䇁䵄䵻䬛蟿䆉㖀城龘䶛䨻䎱蚮䡶䴞䴝䯬䬛䰕㹚㱎
 䖘䵈䶁䘔䶑䘓鋱䩳䵷㒪䪉䉥䥸䝟䳮䟑䎘䫱䉷䰯䕈䟐䬝龘䶛䨻䎱蚮䡶䴞䴝䯬䬛
 䰕㹚䯬䬛䰕㹚䥸䝟龘䶛䨻蚮䡶䴞䴝䯬䬛䰕㹚㱎䖘饢蘿蘿靄饢靨爛驫寵灣龍贏
 爨瘸驫
== Program(Human words) ==
=== Hello, world ===
 Print "Hello, world!" and a new line.
=== A+B Problem ===
 Input a and b and output a+b.
== Program(UTF-8) ==
=== Hello, world ===
 è¾åº"Hello, world!"åä¸ä¸ªæ¢è¡ç¬¦ã
=== A+B Problem ===
 è¾å¥ä¸¤ä¸ªæ´æ°ï¼æ±åºå®ä»¬çåç¶åè¾åºã
=== Valid identifier ===
 è¾å¥ä¸ä¸ªå­ç¬¦ä¸²ï¼å¤æ­å®æ¯å¦ä¸ºC/C++çåæ³æ è¯ç¬¦ã
 å¦ææ¯ï¼è¾åº"yes"ï¼å¦åï¼è¾åº"no"ã
 C/C++åæ³æ è¯ç¬¦è¦æ±ï¼
 1ãä¸å¯ä»¥æ¯ä¿çå­ï¼å¦ifå°±æ¯ä¸ä¸ªéæ³æ è¯ç¬¦ï¼ã
 2ãåªæå­æ¯ãæ°å­ãä¸åçº¿ï¼å¦_example123å°±æ¯ä¸ä¸ªåæ³æ è¯ç¬¦ï¼è$moneyåä¸æ¯ãï¼ã
 3ãä¸å¯ä»¥å°æ°å­ä½ä¸ºå¼å¤´ï¼å¦1passwordå°±æ¯ä¸ä¸ªéæ³æ è¯ç¬¦ï¼ã
Category:Languages
Category:Joke languages
To The Top Right Corner

ToTheTopRightCorner is an esolang which you need to write from the bottom left to the top right corner. You can use these symbols:
==Operations==
=== Directions ===
* ↑: Go up. (^ for ASCII)
* →: Go right. (> for ASCII)
* ↓: Go down. (v for ASCII)
* ←: Go left. (< for ASCII)
* ↗: Go up and go right. (+ for ASCII)
* ↘: Go down and go right. (- for ASCII)
* ↙: Go down and go left. (* for ASCII)
* ↖: Go up and go left. (/ for ASCII)
* You must land on the top right center and you must start at the bottom left.
=== Grid ===
* A 5×5 grid like the one under:
a b c d e
f g h i j
k IFK m n o
p q r IFK t
u v w x z
* IFK means "input from keyboard".(The order to input is from right to left and down to up)
There are two parts in your programme - the directions and the grid.The programme outputs all the grids in the order you walk on it.
==Example==
===Hello, World!===
>>>>^^^<<+>
p c s d !
c e l r o
K k K k W
1 2 3 4 ,
H e l l o
==See also==
* t3rc+
==External resources==
* You can view an attempted (and modified) implementation by User:Earthrulerr on the GitHub Repo
Category:Languages Category:Total Category:Unusable for programming Category:Unimplemented
Toad (Pit Crew)

Toad (Pit Crew) is a joke language made by Mihai Popa. It's made to have fun and play Mario Kart Tour with Toad (Pit Crew) and the colorful varieties.
== Syntax ==
It's that simple, just the file name, then "<Toad (Pit Crew)>", "<Yellow Toad (Pit Crew)>", "<Light-blue Toad (Pit Crew)>", "<Red Toad (Pit Crew)>", "<Green Toad (Pit Crew)>", "<Pink Toad (Pit Crew)>" or "<Purple Toad (Pit Crew)>" (all case-sensitive) and the text contents or "QUINE" (case-insensitive).
== Examples ==
=== Hello, world! ===
Hello<Toad (Pit Crew)>Hello, world!
It would be: Hello, world!
=== XKCD Random Number ===
XKCD<Yellow Toad (Pit Crew)>4
It would be: 4
=== Quine ===
Quine<Red Toad (Pit Crew)>Quine
It would be: Quine<Red Toad (Pit Crew)>Quine
=== Cat ===
No cat for you!
Category:Joke languages
Category:2024
Category:Unimplemented
Category:Output only
Category:Total
Category:Unusable for programming
Category:Languages
Toadskin

Toadskin is a minimal esoteric programming language based on combining aspects of brainfuck and Forth.
One of the features brainfuck lacks is the ability to group commands together into blocks, functions, or procedures that can be reused. pbrain solves this by adding procedures. Toadskin solves this by adding a Forth-like ability to define sequences, or "words" in Forth terminology. Toadskin also replaces brainfuck's array of memory cells, or tape, with a stack, like Forth. Toadskin keeps six of the eight identical to brainfuck commands, but modifies the remaining two BF commands to work with a stack.
==Commands==
Cmd 	Description
BF increment	
BF decrement	
[ 	BF Jump past matching ] if zero
] 	BF Jump to matching [
. 	BF output
, 	BF input
> 	modified to push stack
< 	modified to pop stack
: 	start sequence
; 	end sequence
% 	swap top 2 stack items
==Words==
In order to define a new reusable sequence, say to increment a cell five times, in Toadskin:
 :V+++++;
The colon defines the start of the sequence. A character, 'V' in this example, is the sequence's name. The semicolon ends the sequence.
Each time V is seen in a command stream, five increments are executed:
 :V+++++;V--V+++
This will result in 11.
==External resources==
* 
* (This has very small stack limits and at least one serious bug in the [ instruction.)
Category:Languages
Category:Brainfuck derivatives
Category:Implemented
Category:Stack-based
Category:Turing complete
Category:Turing tarpits
Category:Unknown year
TobiLang

=== Overview ===
Tobilang is a work-in-progress esoteric programming language and unlike most, it is meant to be actually usable. Its syntax follows one akin to XML but it itself is coded like C. It was made by Madman10k (with minor help from me) under MadLadSquad. 
=== Usage ===
A comprehensive guide is shown on the official wiki
Category:Languages
Category:Turing complete
Category:Works-in-Progress
Category:Unimplemented
Category:2021
Toddler

Toddler is a self modifying language by User:PixelatedStarfish that takes an command in source and replaces it with a randomly chosen valid command. It has a random chance of doing this such that if L is the number of commands in source, than any particular command has a 1 in L chance of being replaced with a random command from the set of valid commands. The language is influenced by Befunge and Entropy.
For each cookie the toddler eats, the odds of random alteration is halved for five moves. If the toddler cannot find a cookie after twenty moves, it will make random alterations and print complaints until they get a cookie. 
The Toddler language is derived from Astridec with equivalent operations and memory storage. However, the syntax differs. Toddler is two dimensional. It has five additional operations to guide the instruction pointer around in space. Second, the instruction pointer is a toddler. It behave according to the rules above, and modifies the program as it executes.
A source file is interpreted as a tiled plane with commands mapped to it. The instruction pointer moves from one adjacent tile to the next in a straight line, executing (and sometimes altering) commands it encounters. The executable space is 256 tiles horizontally and unbounded vertically. Commands on the horizontal position 256 and above are ignored.
==Commands==
 
Command	Desc.
0 	Set cell to 0
1 	Add one to byte
2 	Subtract one from byte
3 	Increment cell pointer
4 	Decrement cell pointer
5 	If cell is 0, turn 90 degrees to the right.
6 	If cell is 0, turn 90 degrees to the left.
7 	Take input as an ASCII character
8 	Print ASCII char
9 	Halt
n 	go north.
s 	go south.
e 	go east.
w 	go west.
x 	set cell to random value from 0 to 255.
y 	flip cell value with the next cell value on the tape.
z 	choose a direction at random (n, s, e, w) and continue.
@ 	Start.
* 	A yummy cookie, replaced with a space when eaten.
==Complaints==
The other parents wonder when you are going to teach your kid some manners.
If they do not get cookies they print one of these messages:
 *“I want a cookie NOW!”
 *“I WANT A COOKIE”
 *“No cookie!”
 *”Gimme a cookie!”
 *”Where is my cookie?”
==A Note on Interpretation==
This describes a modified interpreter for a given language that runs according to the rules of the Toddler language. It takes source code in a language, transforms it, and runs the language interpreter on the result. Adding an appropriate function to an existing interpreter is sufficient for this purpose. This would make the interpreter a Toddler-friendly interpreter. That said, it is certainly deserving of a place on this wiki despite this characteristic, if not good because of it.
For examples of a Toddler interpreter, Astridec and bf are good choices. The resulting interpreters would run Astridec Toddler and Bf Toddler respectively.
Category:Languages Category:2021 Category:Unimplemented Category:Self-modifying Category:Two-dimensional languages
Todo

Todo is an esoteric programming language made by thejonymyster, where functions are called from a queue. Functions are defined and subsequently added to the queue, and can be called when on the top of the queue. The function which defines functions (function 0) is also on the queue. The program starts with only function 0 on the queue, and the variable 0 defined as the value 0.
==Commands==
Command 	Description
f(a,b,c){your_code}	(a,b,c and {your_code} are optional) Move the last function in the queue to the beginning. Then, if it is not function 0, execute that function with arguments (a,b,c), ignoring the {your_code}. If it is function 0, then if and only if {your_code} is present, define a new function that does your_code and add it to the beginning of the queue.
F(a,b,c){your_code}	(a,b,c and {your_code} are optional) Remove the last function in the queue. Then, if it is not function 0, execute that function with arguments (a,b,c), ignoring the {your_code}. If it is function 0, then if and only if {your_code} is present, define a new function that does your_code and add it to the beginning of the queue.
loop(n){your_code} 	Execute your_code n times.
var(b){your_code} 	Define a variable b to returned value of your_code. If nothing is returned, b is null.
input() 	Take one character of input code and return its character code.
inc(b) 	Increment b.
print(b) 	Print b as ascii.
return(b) 	Return b. If used outside of a function, print b and halt.
==Examples==
===Infinite loop===
 F(){f()}f()
Removes function 0 and defines a function that calls the end of the queue. Then, calls the function at the end of the queue, which calls the function at the end of the queue, which calls the function at the end of the queue...
===Truth machine===
By slabdrill#7381, two versions:
Takes ascii input 0 or 1:
 F(b){print(b)loop(b){f(b)}}
 f(input())
Takes ascii input 48 or 49 ("0" and "1"):
 var(i){input()}
 var(4){0}inc(4)inc(4)inc(4)inc(4)
 var(47){4}loop(4){loop(4){inc(47)inc(47)}inc(47)inc(47)}inc(47)inc(47)inc(47)
 var(c){0} var(r){0}
 loop(47){f(){}loop(c){f()}inc(c)}
 f(){inc(r)}
 loop(i){f()}
 print(i)
 loop(r){loop(47){F()}f(){print(i)f()}F()F()f()}
===Fibonacci===
By slabdrill#7381:
Doesn't halt, and prints in character codes rather than numbers.
 var(a){0}
 var(b){0}inc(b)
 print(a)
 f(){loop(a){inc(b)}print(b)f()}
 F(){loop(b){inc(a)}print(a)f()}
 f()
Category:Unimplemented Category:Unknown computational class Category:Languages Category:Queue-based Category:2021
Toki ilo

toki ilo is a programming language by User:Joaozin003 based off of toki ponahttps://en.wikipedia.org/wiki/Toki_pona.
== Program structure ==
The program is a sequence of commands which look like toki pona sentences.
== Data types ==
The data types are:
* nanpa: These are of the format nanpa [number words], where [number words] is a list of space-separated number words. Number words are:
** ala: 0
** wan: 1
** tu: 2
** luka: 5
** mute: 20
** ale/ali: 100
The value is the sum of the number word's values.
* nimi: These are of the format nimi [any character] and serve as means of storing text.
* lon: Stores a boolean, either lon (true) or lon ala (false).
== External resources ==
Category:Languages Category:Pseudonatural
Toki pona li pona

toki pona li pona(tplp) is a language by User:ChuckEsoteric08 based on constructed language "toki pona"
==Description==
It has one unbounded Questa and list of variables. Only this values are valid:
 jan pona
and
 nanpa wan
Which equals to 1
 jan ike
and
 nanpa ala
Which equals to 0
 jan sona
and
 nanpa luka
Which equvals to 5
 jan abc
Which is a string abc(it can be any string without spaces that are not pona, ike or sona)
Here is commands:
Note that [arg1] and [arg2] are arguments
===Variables===
 jan [arg1] li [arg2]
Declare variable [arg1] with value [arg2]
 jan [arg1] pi jan [arg2]
Removes first letter after jan in variable [arg2] and set variable [arg1] to it.
===Questa===
 jan Kesata jo [arg1]
Push [arg1] to Questa
 jan Kesata li jo jan [arg1]
Push value of variable [arg1] to Questa
 jan Kesata li pakala e ona
Pop value from top of the Questa
 jan Kesata li pakala e ni
Pop value from the bottom of the Questa
 sewi li anpa
Swap values from the bottom and top of the Questa
===Flow Control===
 ma [arg1]
Declare label [arg1]
 ma ni li ma [arg1]
Goto label [arg1]
 ken sewi li [arg1] la ma ni li ma [arg2]
If top of Questa is [arg1] then goto label [arg2]
 ken jan Kesata li ike la ma ni li ma [arg2]
If Questa is empty goto [arg2]
===IO===
 toki! mi jan [arg1]
Print variable [arg1] to the screen
==See also==
* toki pi ilo nanpa
Category:Languages Category:Unimplemented Category:Pseudonatural
Tol

Tol is a language made solely for laughs.
== Commands ==
 + tol
 - Tol
 < tOl
 > tOL
 [ toL
 ] Tol
 . TOl
 , ToL
== Cat ==
 toltoLTolTOlToltoltoL
Category:Turing completeCategory:LanguagesCategory:Joke languagesCategory:Brainfuck derivativesCategory:Brainfuck equivalentsCategory:Turing tarpitsCategory:Cell-basedCategory:Low-level
Tom Murphy VII

Tom Murphy VII PhD, also known as Tom7, is a creator of esoteric languages and other esoteric projects, mostly but not exclusively computer-related.
Languages and other relevant projects created by Tom7 include:
* Wikiplia
* ABC (compiler)
* UM-32 as part of the team called Carnegie Mellon University's POP Group
* BoVeX
* Aphasia
== Links ==
*Tom7's blog, called "Tom 7 Radar"
*Tom7's homepage
*Tom 7's projects on Sourceforge
Category:People