Hello! I'm Taneb and I've made a few esolangs!
Nandypants is my earliest esolang. It is based on the concept of the NAND operation, and uses two tapes of bits.
Command  Effect 

{ 
Moves tape a one cell leftwards. 
} 
Moves tape a one cell rightwards. 
< 
Moves tape b one cell leftwards. 
> 
Moves tape b one cell rightwards. 
^ 
Stores the value in tape a NAND the value in tape b into tape a. 
v 
Stores the value in tape a NAND the value in tape b into tape b. 
[any even number]  If this is the first instance of this number, do nothing. Otherwise, return to the first instance of the number. 
[any odd number]  If this is the last instance of this number, do nothing. Otherwise, advance to the last instance of the number. 
\ 
Adds the value in tape a to the output stream. 
/ 
Inserts the next bit from the input stream into tape b. 
There is also a dialect called Noryshorts, which differs in that it uses the NOR operation rather than NAND. Both variants are TuringComplete.
Numberwang! is a language based on the British comedy sketch show, That Mitchell and Webb Look, which features the fictional quiz show, Numberwang!, which consists of a pair of individuals shouting seemingly random (and occasionally made up) numbers, occasionally interrupted by the host saying, "That's Numberwang!". This language is in a process of continued developement, so I wouldn't bother trying to implement it at current.
The language is based on Hao Wang's BMachine, and its memory is stored in a single tape whose cells can be either marked or unmarked. The program also keeps track of the number of operations computed. The language is in the format of a series of terminating positive decimals, separated by exclamation marks. At each step, the digital root of the sum of the number of operations computed, the current number, and its position in the program is calculated, modulo 4. This is then converted to an operation as follows:
Number  Operation 

0  Move the tapehead left. 
1  Move the tapehead right. 
2  The "goto" operaton: goes to the command whose location matches the current command's value. If the current command's value is noninteger, it is interprolated linearly between the two values either side of that location, and the next command is the one after the higher of those. 
3  iiiiit's Numberwang! Flip the current cell (i.e. if it is marked, erase it, if it is unmarked, mark it). Then the program "12! 4.4! 92! 10! 49.8! 2! 2! 2!" is executed using the current tape and step count. 
It is unknown if the language is TuringComplete, but I suspect it isn't.
Constantinople is a language, named for the song Istanbul, Not Constantinople. It is my first, and so far only, high level esolang. Memory is stored in an infinite list that can contain either bits or similar infinite lists. By default it contains an infinite amount of 0s, except for the head of the list, which contains another list, filled with 0s. The commands are as follows:
Command  Effect 

replace m with n 
Replaces the value at m with the value at n. 
repeat n 
Starts a repeate block, repeating while n evaluates to 0. 
end 
Ends a repeat block. 
in n 
Replaces n with a bit from the input stream. 
out n 
Adds the value at n to the output stream. 
head n 
Returns the very first element in n. 
tail n 
Returns the n sans the first element. 
nand m with n 
Returns m NAND n 
Commands that expect a list (head and tail) behave as though given an infinite list of the same value when given a bit, and commands that expect a list (out, nand), behave as though given the head of a list when given that list. Missing arguments are assumed to be the main list. Constantinople is Turing Complete.
MIBBLLII is a functional programming language cunningly disguised as brainfuck. It is purely functional, and IO is done in Lazy Kesque frontandback effects style. It uses [
and ]
as brackets for grouping combinators, and the combinators are as follows:
Combinator  Equivalent λcalculus  Haskell code 

+ 
λabc.a(bc) 
(.) or fmap

 
λabc.acb 
flip 
. 
λab.a 
const or pure or return 
, 
λab.abb 
join 
< 
λabc.ac(bc) 
ap 
> 
λa.a 
id 
MIBBLLII is TuringComplete as it incorporates SKI calculus. The Haskell commands all work individually, but as Haskell does not allow infinite types (such as a = a > b
), the translation as a whole won't work.
Luigi is a language named after my favourite Mario character, and is based on the concept of LSystems. Hence, it uses parralel stringrewriteing. The program consists of the alphabet used (which can contain any printing character except for the semicolon), the initial state, which can also be called the axiom, and a series of rules which consist of a predecessor then a successor, with everything separated by semicolons so the program is in the format:
;alphabet;initial state;predecessor;successor;predecessor;successor;...
An interpreter would try to find matches to the predecessorparts of the rules in the current string (starting with the initial state), and replaces any matches with the appropriate successor. Ambiguity is allowed, but its behaviour is implementationdependant, so use at your own risk!
Luigi is TuringComplete, as it is possible to translate arbitrary TuringMachines to it, although no formal proof exists
Brook is a language based on the concept of infinite length streams, although at current no program has been written which allows one. A Brook program, during execution, can generate another Brook program, which is executed as soon as it is possible to do so. However, it is impossible to pass any data upwards in a chain. There is also no trivial (although nontrivial ways may exist) to construct infinite loops. Numbers are ignored when not followed directly by either a ^
or a (
. Data is stored in a firstinfirstout queue.
The loop construct consists of a number, followed by some code enclosed in brackets, e.g. 72(12^)
Commands are as follows:
Command  Effect 

n^ 
Pushes n to the queue. 
v 
Pops a number from the queue and discards it. 
U 
Pops a number from the queue, and pushes it twice. 
@ 
Pops a number from the queue, and pushes it once. 
+ 
Pops two numbers, and pushes their sum. 
 
Pops two numbers, and pushes their absolute difference. 
i 
Pushes the ASCII (or Unicode, or whatever) value of the next character from input onto the queue. 
o 
Pops a number from the queue, and adds the character with it as its character code to the output. 
c 
Pops a number from the queue, and adds the character with it as its character code to the program generated by this program. 
I , O , and C 
These work as their lowercase equivalents, except use numbers directly (in decimal format) rather than converting to or from characters. 
Fueue is a queuebased language. The entire data of the program is stored in the same queue as the program. There are a few data types:
Numbers are numbers in base 10, which may be positive or negative, and, if necessary, may be separated by whitespace. Blocks of code are enclosed in square brackets ("[" and "]"). Functions are as follows:
Function  Effect  Before  After 

+ 
Adds two numbers  +ab... 
...(a+b) 
 
Negates a number  a... 
...(a) 
* 
Multiplies two numbers  *ab... 
...(a*b) 
/ 
Integer divides two numbers  /ab... 
...(a/b) 
% 
Logically inverts a number (0 to one, n to 0)  %a... 
...(!a) 
: 
Duplicates a value  :a... 
...aa 
~ 
Swaps two values  ~ab... 
...ba 
! 
Pops a value  !a... 
... 
$ 
Pushes a number of copies  $ab... 
...(a lots of b) 
( 
Turns a value into a block  (a... 
...[a] 
< 
Adds another value into a block  <[foo]b... 
...[foob] 
) 
Deblocks a block  )[foo]... 
...foo 
H 
Halts immediately  H... 
Execution is as follows:
I was introduced to esoteric programming languages by David MorganMar, who has created a few such languages. One of his languages, BIT, is designed to be easy to read with no unusual concepts. However, it has a few problems:
So I created the language Real Fast Nora's Hair Salon 3: Shear Disaster Download, which addresses these problems. It is based on the easy to understand λcalculus, and hence is trivially Turingcomplete. IO is Lazy Kesque, with front and back effects.
The main feature of the language is the LAMBDA
key word. This introduces a lambda expression, which is a function that takes one input and returns a function.
The next feature is the APPLY
key word. This takes two function, and applies the second to the first, so that the second function is the input to the first.
But how do we use these inputs? This is the job for numbers. ZERO
is a number, which represents the input to the innermost lambda. A number may be preceded with the key word ONE MORE THAN
, which makes a bigger number, which represents the input to a lambda one further out.
COMPLEX, or COMPutational Language EXtension, is a language inspired by BASIC. BASIC is famous for having line numbers in the program text, allowing programs such as:
10 PRINT "HELLO" 20 GOTO 10
Of course, the line numbers are restricted to nonnegative integers. This, from a mathematical perspective, is boring and outdated. The Gaussian integers were first introduced by Carl Friedrich Gauss in 1832, and we have to wonder why the creators of BASIC seem to be unaware of this advancement. COMPLEX is designed to remedy this. We introduce line numbers ranging across the entire Gaussian integer plane, written as, for example, 4+2J
. If a compenent is omitted, it is assumed to be zero. This grants us much more flexibility and expressiveness right off the bat! No longer are we railroaded into the natural numbers! No more languishing around in multiples of ten!
However, this does raise the question of what order do we write our lines, as it is common knowledge that the Gaussian integers are as a ring unordered. We solve this by liberating the programmer who can now write their program in whatever order they desire! The interpreter will procede through the program according to two special variables: VECTORX
, which determines the real component of our direction, and is initially set to 1, and the corresponding, initally 0, imaginary component VECTORY
. These are the only two special variables. All variables, incidentally, are written in UPPERCASE
and contain an integer.
By manipulating the variables VECTORX
and VECTORY
we provide a new form of control flow, rendering BASIC's famous GOTO, longconsidered harmful in all circumstances, redundant, so it is not in the language. What is in the language? Well, each line takes the form of a line number, and a statement. The statements are as follows:
SET variable expression
sets the given variable to the result of the given expression;PRINT [expression]
prints the value of each of the zero or more expresssions given; andIF expression statement
executes the given statement if and only if the given expression evaluates to a nonzero value.These are all the statements a modern programmer will ever need! Unfortunately, COMPLEX is a research language, and the available expressions may seem limited. Fret not! They are conjectured to be sufficient for Turing completeness, meaning that COMPLEX is as powerful as wellused highlevel languages like FORTRAN and COBOL. The available expressions are as follows:
a
and b
are valid expressions, then a + b
is a valid expression, evaluating to the sum of a
and b
.a  b
is a valid expression, evaluating to the difference between a
and b
/I will finish with an example program, demonstrating the expressiveness and power of COMPLEX! It computes the entire Fibonacci sequence, up to its twentieth element!
2 SET HI 1 7+4J SET VECTORY 0 3+4J SET HI LO + HI 0 SET N 20 1+4J SET VECTORY 0  1 1 SET LO 0 5+4J SET N N1 3 SET VECTORY 0 0+3J SET VECTORX 1 8+3J SET VECTORX 0  1 5 IF N SET VECTORY 1 2+4J SET LO TMP 4+4J SET TMP HI 4 PRINT LO