nyuuzyou/wikis huggingface dataset:
Intolerant

Intolerant is a language that wipes the user's hard drive if an error occurs.
==Structure==
Programs are run as root by the 'Intolpreter', which executes each instruction, and will execute 'rm -rf /' if the program encounters an error, or it encounters invalid syntax. The program has access to 10 registers, which are accessed by prefixing their number (starting from 0) with a '%'. Programs also have access to a data stack, controlled by instructions 8 and 9, and a theoretically infinite memory space, which resizes itself based on the program's current highest used location. Programs can also change the minimum size for the main memory. Main memory is accessed using instructions 11 and 12, and if not previously accessed, can be assumed to be equal to 0. Instead of a numerical constant, a register can be supplied, as long as it is prefixed with a '$' sign. Programs can access the code space, and modify their own code. Code space is accessed using instructions 15 and 16. There are also two special "Block registers" which control the functioning of the block operations, and can be manipulated with instructions 13 and 14. Instructions and registers are 4 bytes in size. Code is loaded linearly into the code space, and the first instruction is at code location 0.
==Commands==
1	- NOP		- No operation
2	- ADD [A] [B]	- A = A + B
3	- SUB [A] [B]	- 
4	- MUL [A] [B]	- 
5	- DIV [A] [B]	- 
6	- PUT [A]	- Put character represented by data in register A to the console
7	- GET [A]	- Get character from console into register A
8	- PUSH [A]	- Push data in register A onto the stack
9	- POP [A]	- Pop data from the stack onto register A
10	- SREG [R] [D]	- Set register R to contain value D
11	- WMEM [R] [L]	- Write value in register R to memory location L
12	- RMEM [R] [L]	- Read value in memory location L to register R
13	- SETSIZE [X]	- Set block operation size
14	- CODER [R] [L]	- Set register R to instruction L
15	- CODEW [R] [L]	- Set instruction L to register R
16	- BCPY [S] [T]	- Copy memory block of size in block register, starting at position S to position T
17	- CBCPY [S] [T]	- Copy code block of size in block register, starting at position S to position T
18	- BSET [S] [V]	- Set block of size in block register, starting at position S to value V
19	- CBSET [S] [V]	- Set code block of size in block register, starting at position S to value V
20	- HLT		- End program
21	- JMP [L]	- Jump to location L
22	- JZ [L]	- Jump if previous math operation resulted in 0
23	- JNZ [L]	- Jump if previous math operation resulted in a nonzero value
24	- JNEG [L]	- Jump if previous math operation resulted in a negative value
==Potential Errors==
Invalid code memory address
Invalid register
Invalid number
Math out of range
Division by zero
Program end reached without HLT
Invalid instruction
Stack overflow
Stack underflow
Invalid jump location
Over 10 NOPs in a row
Out of memory
Ctrl-C received
Category:Languages
Category:Joke languages
Category:Stack-based
Category:No IO
Category:Unknown computational class
Category:Unimplemented
Category:Unknown year
Introduction to esolang design

Designing truly beautiful esolangs can be a difficult thing to do. So difficult, in fact, that almost every esolang on this site is based off of one of just a few languages. We have many multidimensional languages, plenty of unimplementable languages, and some would say too many Brainfuck derivatives.
== What makes a good esolang? ==
Just making some small changes to an existing language or taking ideas from something that already exists does not make a gem of an esolang. A truly brilliant esolang (according to those who have authored this page, as well as maybe some people over IRC) does something novel and unique and completely different from that of existing languages (including other esolangs). An example of a language that did something completely new for the masses is Befunge, which introduced the concept of a 2D language to a wider group of people.
== Computational Class ==
While joke languages, such as HQ9+, are nice, they aren't very fun to program. A good language should be Turing complete (or pretty close), if only in a roundabout way.
== Methods of Design ==
=== Declarative Languages ===
Declarative languages (languages that are based on reading a program then essentially evaluating it like an expression) are often based on existing mathematical systems. Thus, one way to make a good esoteric declarative language is to find a good but strange system of math and extend it to be practical to use. Optimally, you'll invent an entirely new system of math, but since you probably can't do that, just finding a system for it will do as well.
=== Imperative Languages ===
Imperative languages is the "classic" straightforward paradigm of esolangs. For example brainfuck is imperative. All you need is a set of instructions that reads and modifies the memory and some kind of control flow (sometimes these can even be combined). 
=== Functional Languages ===
Languages based purely on functions are becoming more popular recently.
=== Other Sentence Type Languages ===
If you can think of a good Interrogative or exclamatory language, be our guest.
=== Hybrid Languages ===
(TBW)
Inuck

Inuck is a brainfuck derivative by VilgotanL which is quite infinite.
The name comes from combining infinite and brainfuck.
== Definitions ==
Origin point / Origin cell - The point/cell where all dimensional components are zero. In 3D this would be (0, 0, 0).
Pointer - A pointer that points to a cell and has a direction towards a dimension. Initially it is located in the origin point, pointing towards dimension 0
Infinite-dimensional tape - A tape, but instead of one dimension, it is an infinite-dimensional space.
: Each infinite-dimensional tape has a pointer, which can be moved forwards or backwards in the dimension the pointer is pointing in.
: The pointer saves for each infinite-dimensional plane, such as when going into cell's tapes as you will se later.
: Dimensions, cell indicies, and cell values are signed and can be negative.
Cell - Holds a signed integer (initially zero), but is actually an infinite-dimensional tape.
: The integer is represented by how many nonzero values are inside that cell's infinite-dimensional tape.
: This goes on to infinite depth, and since each infinite-dimensional tapes has a parent,
: the initial tape also has a parent, which also has a parent, and so on.
: Those parents's origin cells follow the integer representation rule, they are how many nonzero cells are in the origin cell's tape.
== Instructions ==
+	Increment the current cell. (in current infinite-dimensional tape)
-	Decrement the current cell. (in current infinite-dimensional tape)
>	Move the pointer right/forward in the pointed-to/current dimension. (in current infinite-dimensional tape)
<	Move the pointer left/backward in the pointed-to/current dimension. (in current infinite-dimensional tape)
^	Increment the dimension pointed to. (dimension 3 becomes dimension 4, etc) (in current infinite-dimensional tape)
v	Decrement the dimension pointed to. (in current infinite-dimensional tape)
;	Go into the current cell's infinite-dimensional tape. (the current infinite-dimensional tape is now that cell's tape)
:	Go out to parent's infinite-dimensional tape.
[	While not zero
]	End while
,	Input ascii char
.	Output ascii char
Any other instructions are comments, and are ignored.
== Examples ==
=== Cat program ===
Basically the same as brainf**k.
=== Hello World ===
Basically the same as brainf**k.
=== An example program ===
Prints uppercase A.
;+: Now the current cell has integer 1 since tape inside cell has 1 nonzero values
>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+ Now the amount of nonzeroes in the current infinitedimensional tape is 65
: Now we are in the parent tape which now has integer 65 in current cell (origin cell)
. Print the current cell as ascii char
== Computational class ==
Inuck is Turing complete since it is backwards-compatible with brainf**k.
== Implementations ==
There are none yet, but it is definitely possible to make one. (if you even understand how the esolang works)
Category:Languages
Category:Brainfuck derivatives
Category:Turing complete
Category:Cell-based
Category:Multi-dimensional_languages
Category:2022
Category:Unimplemented
Inuktitut

ᑖᓐᓇ ᑕᒻᒪᖅᓯᒪᔪᖅ ᑕᐃᔭᐅᔾᔪᓯᖅ. ᑕᒻᒪᖓᙱᑦᑐᖅ ᑕᐃᒎᓯᖓ ᐃᓄᒃᑎᑐᑦ.
↑Inuktitut Version
ᐃᓄᒃᑎᑐᑦ is a language based on INUKTITUT.
== Syntax ==
 Caption text
ᐃᓄᒃᑎᑐᑦ 	Pseudo code 	
ᐅᖃᕐᓗᑎᑦ (comment) 	print(comment) 	
ᓈᓚᒡᓗᑎᑦ (comment) ᐱᖃᑎᖃᕐᓗᓂ (prompt) 	input(comment, __prompt)	
ᐃᒪᐃᑉᐸᑦ(expression){} 	if(expression){} 	
ᐊᓯᐊ{} 	else{} 	
ᐊᓯᐊ ᐃᒪᐃᑉᐸᑦ(expression){} 	elif(expression){} 	
ᑕᐃᒪᐃᓕᐅᒃᑲᓐᓂᕐᓗᑎᑦ 10 ᖏᖅᓱᕐᓗᑎᑦ{} 	for (i in range(10)) 	
ᑕᐃᒪᐃᓕᐅᒃᑲᓐᓂᕐᓗᑎᑦ ᑭᓯᐊᓂ (expression) ᓱᓕᙱᑉᐸᑦ	while(expression) 	
ᓇᓗᓇᐃᖅᓯᓂᖅ A ᐃᒪᓐᓇ (type) 	def a -> type 	
ᐋᖅᑭᒃᓯᓗᑎᑦ A ᒥᑦ value ᒧᑦ 	a=value 	
ᐊᒻᒪᓗ 	&& 	
ᐅᕝᕙᓘᓐᓃᑦ 	 	
ᐋᒃᑲ 	! 	
ᑎᒡᓕᒐᖅ 	int 	
ᓴᒡᓗᔪᑦ 	float 	
ᖃᓄᐃᑦᑑᓂᖓ 	char 	
ᐊᒥᕕᖅ 	str 	
ᕘᓚᐃᓐ 	bool 	
ᖃᓄᐃᑦᑑᓂᖓ 	void 	
ᑮᓇᐅᔭᙳᖅᑎᑦᑎᔾᔪᑎ 	bin 	
etc. 	etc. 	
== Program ==
=== Hello, world ===
 ᐅᖃᕐᓗᑎᑦ ("Hello, world!")
=== A+B ===
 ᓇᓗᓇᐃᖅᓯᓂᖅ A, B, C ᐃᒪᓐᓇ int
 ᓈᓚᒡᓗᑎᑦ (A)
 ᓈᓚᒡᓗᑎᑦ (B)
 ᐋᖅᑭᒃᓯᓗᑎᑦ C ᒥᑦ A+B ᒧᑦ
 ᐅᖃᕐᓗᑎᑦ (C)
Category:2024 Category:Languages Category:Joke languages Category:Unimplemented
Inverted Logic

Inverted Logic is a language made by User:PinkysWorld that reverses booleans and flips the sign of numbers. It is like Boobeans, although their commands are different.
==Syntax==
 Syntax
Command 	Description 	Examples
and 	Prints a nand b. 	true and true
nand 	Prints a and b. 	true nand true
or 	Prints a or b. 	true or true
nor 	Prints a nor b. 	true nor true
xor 	Prints a xor b. 	true xor true
xnor 	Prints a xnor b. 	true xnor true
true 	Prints false. 	true
false 	Prints true. 	false
print 	Prints anything after the word 'print'. 	print apple
println 	Same as print but adds a newline afterwards.	println apple
printsp 	Same as print but adds a space afterwards. 	printsp apple
keywords 	Prints every keyword that is available. 	keywords
errorcodes	Prints all error codes. 	errorcodes
exit 	Ends the program. 	end
; 	Comment! 	; This is a comment
==Example Programs==
===Hello World===
print Hello World
==Interpreter==
I've decided to put the interpreter here because it takes up a lot of space.
Also, the code is written in Java.
Category:LanguagesCategory:ImplementedCategory:2022Category:TotalCategory:Unusable for programmingCategory:Output only
Invy

Invy /ɪn.ˈviː/, whose name has nothing to do with envy or any other word, is an esoteric programming language created by CreeperBomb in 2023.
==Code format & memory system==
Instead of being written left to right and top to bottom, code is written (and read) top to bottom and left to right. This is done to make the programmer get a "movie h4ckr vibe", and implementations are encouraged to use a green-and-black theme for the text instead of black-and-white or white-and-black. For example, if your program had "foo[newline]bar" in it, it would be written as
fb
oa
or
Memory exists on a right-infinite tape initialized to 0s, and the pointer starts all the way on the left. If the pointer tries to go left on the leftmost cell, it does not move. The initial set-up of the tape is input, and the tape can be viewed at (and edited if the implementation allows so, though this editability is not necessary) at any time.
==Instructions==
Symbol 	Explanation
0 	Go right
1 	Go left and flip that bit
[space]	Seperates "branches"
If in a column you put a space and visible code on either side, such as in the example below, the top path will be taken if the leftmost bit is 0 and the bottom path if its 1. What "taken" means will be explained shortly.
0
0
1
1
 
0
When reaching the bottom of a branch, the machine checks if the pointer is on a bit set to 1. If not, the branch is run again; otherwise, the next column is considered. If there is no space, the column is run. If there is a space, the previously described method is used to determine which branch to take. Note that if the leftmost bit is changed, the branch run will switch without the next column being run.
After the last column, it wraps back around to the first column being run. Whitespace that makes no visible impact or composes a blank column/branch is ignored.
==Example programs==
Truth machine (input on leftmost bit):
<pre>0
0
0
1
Iota

Iota is a Turing tarpit designed by Chris Barker, based in combinatory logic. It uses only two symbols, * and i, but not every combination of them is syntactically correct; e.g. *i*ii is correct but *iii is not, as opposed to its "sister language" Jot in which every string of symbols is valid.
An Iota program is either an i, or a * followed by two Iota (sub-)programs.
Iota execution can be defined as repeating the following rewriting rules, which make use of the auxiliary subprograms k and s, and where x,y,z represent subprograms:
 *ix --> **xsk
 **kxy --> x
 ***sxyz --> **xz*yz
Alternatively it can be defined by translation to lambda calculus:
 i = λx.xsk
 k = λxy.x
 s = λxyz.xz(yz)
*xy where x and y are functions denotes the function (xy). These can be "nested", such that (for example) *x*yz denotes x(yz).
Only the i function and the * operator can actually appear in a program's source code.
==See also==
* Jot, Iota's "sister language" from the same article
* Binary combinatory logic
* Lambda calculus
==External resources==
* 
* 
* Iota and Jot (Wikipedia)
Category:Languages
Category:Turing tarpits
Category:Functional paradigm
Category:No IO
Category:Implemented
Category:2001
Iq

Iq is a programming language created by User:Mmmph! for making HI9+ interpreters.
== Overview ==
From HI9+:
::If the interpreter's source code is IQ, then IQ is a valid quine in both that variant of HI9+, and in HQ9+.
So, why not make a programming language where you can make an interpreter for HI9+ with the source iq?
== Instructions ==
* I gets input from the user
* Q runs the input in HI9+
== Examples ==
HI9+ interpreter:
iq
== Implementations ==
User:Mmmph! made an IDE in spanish scratch 1.4:
https://scratch.mit.edu/projects/858098664/
Category:Languages
Category:2023
Category:Implemented
Isomorphism/More Syntax

Main page: Isomorphism
== foldn(c, h, n) function ==
We defined the number likes these:
one = succ zero
two = succ (succ zero)
three = succ (succ (succ zero))
......
In mathematics, we uses n` but not succ n to express the successor of n.
So, we can say two plus three like this:
 two + three
= zero`` + zero```
= zero``` + zero``
= zero```` + zero`
= zero````` + zero
= zero`````
= five
The result is ((((zero's successor)'s successor)'s successor)'s successor)'s successor, five.
But, how did we express 1747156280461389750146873209578461807205641950? Did we express it with zero```````````````````````````````...(1747156280461389750146873209578461807205641950 `'s)? It's too much trouble! So, a new thing is appears!
Tada! 
def func foldn(z, f(, n))
{
 foldn(z, f, 0) = z
 foldn(z, f, n`) = f(foldn(z, f, n))
}
If z is zero, f is succ, n is any natural number, then foldn defines the WHOLE natural number.
foldn(zero, succ, 0) = zero
foldn(zero, succ, 1) = one
foldn(zero, succ, n) = a_natural_number
If z isn't zero, f isn't succ, then foldn describes something isomorphic to natural numbers.
(+m) => foldn(m, succ)
(*m) => foldn(0, (+m))
m^() => foldn(1, (*m))
== List type ==
List can also define with isomorphic to natural numbers.
According to Peano's axiom 1, an empty list (nil) is equivalent to zero; According to Peano's axiom 2, for all lists, we can use cons, to link a new element of type A on the left. Thus cons is equivalent to succ in natural numbers.
Isomorphic to the addition of natural numbers, we can define the linking operation of a list as follows:
nil ‡ a = a
cons(a, x) ‡ y = cons(a, x ‡ y)
But, 1 ‡ (2 ‡ (3 ‡ nil)) is too complex, so we can simplify it with [1, 2, 3]. And, ['H', 'e', 'l', 'l', 'o', ',', ' ', 'w', 'o', 'r', 'l', 'd', '!'] can simplify with "Hello, world!".
However, unlike natural numbers, lists do not satisfy the commutative law. (That's why I'm using a double dagger sign here instead of a plus sign for the list connection. But many programming languages use the plus sign, which creates a potential problem.(That's why I like Haskell. too.))
It's 3D!

This is a coding language based of Befunge. It is created by User:WhyNot?
You may fix anything that you think needs to be fixed.
== Syntax ==
Since computers can only show 2D, we will use another way:
 > v
 / <
 ###
 \ <
 > ^
It is basically Befunge, but with # seperating the different dimensions.
(Note: The dimensions have to be a rectangular prism or a cube.)
* > Head Left
* < Head Right
* v Head Down
* ^ Head Up
* # Divides the different dimensions.
* / Head Forward In 3D
* \ Head Backward In 3D
* 0-f Put That Hex On the Stack.
* ! Print the top 2 hex numbers as a letter.
Category:Languages Category:Two-dimensional languages Category:Stack-based
ItOi

ItOi or Input to Output instantly is a joke esoteric programming language by Grs (talk) that only contains two command.
== Commands ==
 Command
Command	Description 	Example
ItOi 	Takes input from the user and prints it instantly	ItOi
repeat 	Repeats the last command infinity times. 	ItOi(newline)repeat
== Code ==
===== Cat program =====
 ItOi
 repeat
===== An ending cat program =====
 ItOi
== Implementation ==
Python implementation by Grs (talk):
 code = []
 userinput = ""
 while userinput != "exit":
 userinput = input("> ")
 if userinput == "run":
 line = 0
 while line < len(code):
 if code[line] == "ItOi":
 print(input())
 elif code[line] == "repeat":
 line -= 2
 line += 1
 code = []
 else:
 code.append(userinput)
Category:Languages Category:Joke languages Category:Implemented Category:Unusable for programming
It Online

It Online is a language invented by User:A with a weird self-modification scheme. It is inspired by Backhand.
== Inspiration ==
Someday in school in math class. Jerry is sitting in the front of Yolanda and in the back of Sophie. Due to her bad sitting habits, Yolanda pushes her desk forward; it seems like she is falling asleep. Since there is less space less for Jerry, Jerry also pushes his desk forward. Suddenly, Sophie pulls her desk backwards (she wants to stretch herself), leaving Jerry very unconfortable. The teacher realized this and said, "Please sit properly. Sophie is pulling her desk backwards. Yolanda is pushing her desk forwards."
Inspired by this, I decided to create a language where the instructions (students' desks) move yet the program counter (the teacher) does not move.
== Overview ==
There are rules in It Online that decide how the atoms (instructions) move. First of all we have forces deciding how the atoms should move. The forces are represented by the left force < and the right force >. If there are no forces specified in the program, a left conveyor (<<) is implicitly specified.
=== Rules ===
The program counter "consumes" the character whenever it sees one. Therefore you always need to copy the character for every instruction you execute. Obviously the program counter stays in position 1, although the program may change it or set its initial value using a flag of the interpreter.
==== Convergent rules ====
We call a code block convergent when two forces point to each other. These are the rules for converging:
* >Aha< Should result in >h<. This drops two characters in the side.
* >h< Should result in ><. This removes the whole string being converged.
* >< Should result in ><. No effect; you can't expect the two forces crushing each other.
* >oh< Should result in ><. This drops two characters in the side.
==== Divergent rules ====
There is only one simple rule here.
* <abc> Should result in <abcabc> Copy the string and append to the string itself.
==== Conserving rules ====
* >abc> Should result in >cab> because the conveyor moves c to the back.
* <abc< Should result in <bca< because the conveyor moves a to the front.
== Table of moving directions of atoms ==
Just a randomly-shuffled list in order to increase difficulty of programming. :)
[57, 70, 44, 77, 64, 26, 2, 86, 25, 63, 13, 29, 61, 56, 43, 21, 36, 58, 8, 35, 83, 9, 89, 60, 80, 30, 4, 0, 3, 84, 55, 22, 88, 27, 53, 48, 38, 6, 71, 16, 67, 7, 15, 45, 5, 62, 18, 33, 1, 51, 17, 78, 93, 92, 11, 12, 74, 85, 82, 54, 37, 42, 31, 59, 75, 34, 40, 81, 79, 68, 90, 46, 39, 65, 87, 32, 41, 28, 50, 69, 24, 10, 20, 23, 76, 47, 14, 52, 73, 49, 66, 72, 91, 19]
The index's ord code should be decremented by 32 when referenced. E.g. The direction of H is 67, which means the character H will be moved 67 times. It Online is completely written in non-control ASCII (no tabs and newlines).
Currently It Online pushes every executed instruction onto the stack. More sophisticated instructions might be added later.
Category:Languages
Category:2019
Category:Unimplemented
Itflabtijtslwi

itflabtijtslwi, pronounced (it-flab-tidge-slee-wee), is an acronym for ignore this fancy little acronym, because this is just that slashes language with input. As the name suggests, it's just :/// with input. It was invented by User:Twistle.
The /// command works like in the /// language, as does escaping.
To input a character and store it, use the following syntax:
 GGwhat to store it asGG
The effect is the same as the command
 /what to store it as/\character read/
Escapes may be used like with the /// command, and end of file stores an empty string.
==Examples==
All of the /// examples are also valid itflabtijtslwi programs, since none of them attempt to print strings containing GG. (That can still be done, e.g. by escaping one of the G's.) Here are some examples that make use of the input command.
===Cat program===
/ ///
//
/./<\\\\>\\\\\\/
/P1/
 GGC.2GG
 ./C.1C.3./.\./P.2.\./.\././
 ./C.1./.\.\./
 ./C.3././
 C.1C.2C.3
 ./P.1./
 P.3
 ./
 ./P.\2./P.1./
 ./<.\>././
 ./P.\3./P.1./
 ./<.\>./<.\.\.\.\>.\.\.\.\.\.\./
 P.2
/
/P\2/P1/
/<\>//
/P\3/P1/
/<\>/<\\\\>\\\\\\/
P2
===ROT13 program===
Modifying the cat program to do rot-13 encoding is easy.
/ ///
//
/./<\\\\>\\\\\\/
/P1/
 GGC.2GG
 ./C.1C.3./.\./P.2.\./.\././
 ./C.3././
 ./C.1A./N./ ./C.1N./A./ ./C.1a./n./ ./C.1n./a./
 ./C.1B./O./ ./C.1O./B./ ./C.1b./o./ ./C.1o./b./
 ./C.1C./P./ ./C.1P./C./ ./C.1c./p./ ./C.1p./c./
 ./C.1D./Q./ ./C.1Q./D./ ./C.1d./q./ ./C.1q./d./
 ./C.1E./R./ ./C.1R./E./ ./C.1e./r./ ./C.1r./e./
 ./C.1F./S./ ./C.1S./F./ ./C.1f./s./ ./C.1s./f./
 ./C.1G./T./ ./C.1T./G./ ./C.1g./t./ ./C.1t./g./
 ./C.1H./U./ ./C.1U./H./ ./C.1h./u./ ./C.1u./h./
 ./C.1I./V./ ./C.1V./I./ ./C.1i./v./ ./C.1v./i./
 ./C.1J./W./ ./C.1W./J./ ./C.1j./w./ ./C.1w./j./
 ./C.1K./X./ ./C.1X./K./ ./C.1k./x./ ./C.1x./k./
 ./C.1L./Y./ ./C.1Y./L./ ./C.1l./y./ ./C.1y./l./
 ./C.1M./Z./ ./C.1Z./M./ ./C.1m./z./ ./C.1z./m./
 ./C.1./.\.\./
 C.1C.2C.3
 ./P.1./
 P.3
 ./
 ./P.\2./P.1./
 ./<.\>././
 ./P.\3./P.1./
 ./<.\>./<.\.\.\.\>.\.\.\.\.\.\./
 P.2
/
/P\2/P1/
/<\>//
/P\3/P1/
/<\>/<\\\\>\\\\\\/
P2
===Deadfish interpreter===
See the Deadfish page.
===Truth-machine===
See the Truth-machine page.
==External resources==
*Perl implementation
*Try it online! version using stripped-down Perl header and footer.
Category:Languages
Category:String-rewriting paradigm
Category:2006
Category:Turing complete
Category:Turing tarpits
Category:Implemented
Category:Low-level
Category:Self-modifying
Ixth

Ixth is a stack-based language. Instead of operators such as drop, swap, or dup, it features one customizable stack operator.
( a b -- b a ) is equivalent to swap.
( a -- ) is equivalent to drop.
( a -- a a ) is equivalent to dup.
( a b c -- c a b ) and ( a b c -- b c a ) perform rotations.
==Example==
9 8 add print
5 6 ( a b -- b a ) print print
func hello
5 5 add print
ret
hello
8
{
 ( a -- a a ) print
 1 sub
 ( a -- a a ) print
 ( a -- a a ) if
 1 gob
 fi
 1 gof
}
( a -- )
8 8 8 add add print
0 if
 1 print
else 1 if
 2 print
 0 if
 1 print
 else 1 if
 4 print
 fi
else 1 if
 3 print
fi
Category:Implemented Category:2022 Category:Stack-based