Agony

Agony is an esoteric programming language devised by Roy van Rijn in March 2013.
It is based on, and most of the time backwards compatible with Brainfuck. The added instructions and changes to the inner workings turn Brainfuck into a complete self-modifying language.
==Memory space==
The memory/core of Agony consists of 'cells,' which are 4 bits in size, and 'characters,' which are 8 bits in size (2 cells).
* The memory pointer always points to a cell, the corresponding character is the current cell and previous cell in memory.
* The memory core is circular and loops around.
* After loading a program into the core (the code is placed in cells in memory!), the memory pointer points to the second free cell after the last instruction (leaving one free character).
* Unused memory/core is initialized with '0000'-bit cells.
==Instructions==
Command	Binary	Description
$ 	0000 	Halt the program here.
} 	0001 	Move pointer right.
{ 	0010 	Move pointer left.
> 	0011 	Move pointer right 2 cells.
< 	0100 	Move pointer left 2 cells.
@ 	0101 	Increment cell.
~ 	0110 	Decrement cell.
+ 	0111 	Increment character.
- 	1000 	Decrement character.
. 	1001 	Output the character (2 cells) at pointer and pointer-1.
, 	1010 	Input a character (2 cells) to pointer and pointer-1.
( 	1011 	Jump past the matching ) if the cell under the pointer is zero, if no matching ) can be found, halt.
) 	1100 	Jump back to the matching ( if the cell under the pointer is nonzero, if no matching ( can be found, halt.
[ 	1101 	Jump past the matching ] if the character under the pointer is zero, if no matching ] can be found, halt.
] 	1110 	Jump back to the matching [ if the character under the pointer is nonzero, if no matching [ can be found, halt.
* 	1111 	Swap character (2 cells) at pointer with the buffer (2 cells, buffer has 0000 0000 initially)
As you can see, the Brainfuck roots are clearly visible. With the BF instructions working on 8 bits it is mostly backwards compatible.
==Examples==
Here are some Brainfuck examples which work fine in Agony:
===cat===
A cat program writes its input directly to its output. EOF in Agony is translated to 0000-bits, halt.
 
 ,[.,]
===Hello, World! in BF===
This Brainfuck program works fine in Agony, it prints out the words Hello World!:
 ++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.
===Hello, World! in Agony===
In Agony we can use the fact instructions are also bits and can be reached:
 <[.<]$$$,{}~<~)+{~*@+{$~*~)~)~@<-
===Quine in Agony===
Agony is a self-modifying language, this means we can also do reflection. Using this fact it should be 'easier' to make a Quine in Agony.
Program:
<
[
 [>+>+<<-] 
 >*>[>]>>[>]*{(>@<~)}(({@}~)}))<[<]<<[<]<< Create a reversed copy of the last part
]
>>>[>]>>[>]< Place pointer at last part of the reversed copy
[ Print the instructions
 [(}+{-)}*<({)<<<({)<<<<* Grab the last instruction
 [<[->>+<<]>[<+>-]<-]<-.+>>>[[-<<+>>]>]>>} Do look up in the instruction print array
 (})>>(}){ And go back to the next instruction
] Until the reversed copy is printed
@@@@{@@}......{~~}~~~~<< Print the separator
[
 [>+>+<<-]
 >*>[>]>>[>]*{(>@<~)}(({@}~)}))<[<]<<[<]<< Same copy as above
]
>>>[>]>>[>]< Place pointer at last part of the reversed copy
[ Print the instructions again with slightly different offset
 [(}+{-)}*<({)<<({)<<<<<<* 
 [<[->>+<<]>[<+>-]<-]<-.+>>>[[-<<+>>]>]>>>>}
 (})>>(}){
]
[[ Halt the program invalid loop
{(@]@){,{.{[{*{]{)+*<}>[>*+)+]{@ Lookup table for printing instructions
$$$$$$ Seperator space
<[[>+>+<<-]>*>[>]>>[>]*{(>@< And the entire block again needed for printing
~)}(({@}~)}))<[<]<<[<]<<]>>>
[>]>>[>]<[[(}+{-)}*<({)<<<({
)<<<<*[<[->>+<<]>[<+>-]<-]<-
.+>>>[[-<<+>>]>]>>}(})>>(}){
]@@@@{@@}......{~~}~~~~<<[[>
+>+<<-]>*>[>]>>[>]*{(>@<~)}(
({@}~)}))<[<]<<[<]<<]>>>[>]>
>[>]<[[(}+{-)}*<({)<<({)<<<<
<<*[<[->>+<<]>[<+>-]<-]<-.+>
>>[[-<<+>>]>]>>>>}(})>>(}){]
[[{(@]@){,{.{[{*{]{)+*<}>[>*
+)+]{@
==AgonyWar==
This language is perfectly suited for a Core War-like (see Redcode) battle. Two or more programs can be put in the same memory core. The program that doesn't halt and survives N-cycles wins. In this case, input and output instructions won't do anything.
An experimental working implementation can be found here.
==Implementations==
===Java===
* JAgony - https://github.com/royvanrijn/JAgony
Category:LanguagesCategory:Brainfuck_derivativesCategory:Self-modifyingCategory: Programming gamesCategory:2013Category:Cell-basedCategory:Implemented