User:Hasin Israk Toaha

Tonnyi

Paradigm(s)	Imperative
Designed by	Hasin Israk Toaha
Appeared in	2025
Computational class	Turing complete
Reference implementation	Unimplemented
File extension(s)	.ton

Tonnyi is an esoteric programming language and educational interpreter created by Hasin Israk Toaha in 2025. The language is characterized by its use of pure binary opcodes for all instructions and Java-based implementation that uses BigDecimal for high-precision arithmetic operations.

Overview

Tonnyi is an assembly-like language where all instructions are written using their 7-bit binary opcode strings (0b0001010). The language features 44 implemented instructions out of 128 possible opcodes, with operations including memory manipulation, arithmetic, bitwise operations, control flow, and I/O.

The interpreter simulates a 64KB memory space addressable with 4-digit hexadecimal values (0x0000 to 0xFFFF) and supports both integer and floating-point operations with arbitrary precision.

Language Specification

Memory Model

• Memory Space: 64KB addressable memory (0x0000 to 0xFFFF)
• Addressing: 4-digit hexadecimal values (e.g., 0x001A, 0xFFFF)
• Immediate Values: Prefixed with # (e.g., #100, #3.14159, #-42)

Syntax

Programs are written in text files with .ton extension. The basic syntax consists of:

• Instructions: BINARY_OPCODE operand1 operand2
• Labels: Defined on their own line ending with colon (:)
• Comments: Start with //

Example instruction: 0b0001010 0x002A 0x002B (Add values at addresses)

Instruction Set

Tonnyi implements 44 instructions across several categories:

System Operations

• 0b0000000 - HALT: Stops program execution
• 0b0000001 - NOP: No operation
• 0b0000010 - DUMP MEMORY: Prints all non-zero memory values (debug mode only)

Memory Operations

• 0b0000011 - PRINT: Prints value at address
• 0b0000100 - LOAD IMMEDIATE: Loads immediate value into destination
• 0b0000101 - LOAD FROM MEMORY: Copies value from source to destination
• 0b0000110 - MOV: Alias for LOAD FROM MEMORY
• 0b0000111 - STORE: Alias for LOAD FROM MEMORY
• 0b0001000 - SWAP: Swaps values at two addresses
• 0b0001001 - CLEAR: Sets address to zero

Arithmetic Operations

• 0b0001010 - ADD: dest = dest + src
• 0b0001011 - SUBTRACT: dest = dest - src
• 0b0001100 - MULTIPLY: dest = dest × src
• 0b0001101 - DIVIDE: dest = dest ÷ src
• 0b0001110 - MODULO: dest = dest % src
• 0b0001111 - INCREMENT: addr = addr + 1
• 0b0010000 - DECREMENT: addr = addr - 1
• 0b0010001 - POWER: dest = dest ^ src
• 0b0010010 - NEGATE: addr = -addr
• 0b0010011 - ABSOLUTE: addr = |addr|

Bitwise Operations

• 0b0010100 - AND: Bitwise AND
• 0b0010101 - OR: Bitwise OR
• 0b0010110 - XOR: Bitwise XOR
• 0b0010111 - NOT: Bitwise NOT
• 0b0011000 - SHIFT LEFT: Left shift
• 0b0011001 - SHIFT RIGHT: Right shift (arithmetic)

Comparison & Control Flow

• 0b0011010 - COMPARE: Compares two values, sets internal flag
• 0b0011011 - JUMP: Unconditional jump to label
• 0b0011100 - JUMP IF ZERO: Jump if comparison result == 0
• 0b0011101 - JUMP IF NOT ZERO: Jump if comparison result != 0
• 0b0011110 - JUMP IF EQUAL: Jump if comparison result == 0
• 0b0011111 - JUMP IF NOT EQUAL: Jump if comparison result != 0
• 0b0100000 - JUMP IF GREATER: Jump if comparison result > 0
• 0b0100001 - JUMP IF LESS: Jump if comparison result < 0
• 0b0100010 - CALL: Push current PC and jump to subroutine
• 0b0100011 - RETURN: Pop return address and return from subroutine

Stack Operations

• 0b0100100 - PUSH: Push value onto call stack
• 0b0100101 - POP: Pop value from call stack

I/O Operations

• 0b0100110 - INPUT: Read number from stdin into address
• 0b0100111 - PRINT CHAR: Print value as ASCII character
• 0b0101000 - PRINT STRING: Print null-terminated string

Special Operations

• 0b0101001 - RANDOM: Store random number (0-100) in address

Debug Operations

• 0b0101010 - DEBUG MODE ON: Enable verbose debug output
• 0b0101011 - DEBUG MODE OFF: Disable verbose debug output

Examples

Hello World

// Load immediate values for 'H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd', '!'
0b0000100 0x1000 #72    // 'H'
0b0000100 0x1001 #101   // 'e'
0b0000100 0x1002 #108   // 'l'
0b0000100 0x1003 #108   // 'l'
0b0000100 0x1004 #111   // 'o'
0b0000100 0x1005 #32    // ' '
0b0000100 0x1006 #87    // 'W'
0b0000100 0x1007 #111   // 'o'
0b0000100 0x1008 #114   // 'r'
0b0000100 0x1009 #108   // 'l'
0b0000100 0x100A #100   // 'd'
0b0000100 0x100B #33    // '!'
0b0000100 0x100C #0     // Null terminator

// Print the string starting at address 0x1000
0b0101000 0x1000

// Halt the program
0b0000000

Addition Program

// Read two numbers and print their sum
0b0100110 0x2000       // INPUT first number
0b0100110 0x2001       // INPUT second number
0b0000101 0x2002 0x2000 // COPY first number
0b0001010 0x2002 0x2001 // ADD second number
0b0000011 0x2002       // PRINT result
0b0000000              // HALT

Implementation

The Tonnyi interpreter is implemented in Java and uses BigDecimal for all arithmetic operations, providing high-precision calculations. The interpreter performs two passes over the source code: first to collect labels, and second to execute instructions.

Computational Class

Though not formally proven, Tonnyi appears to be Turing complete as it supports:

• Conditional jumps
• Unbounded memory (within 64KB simulation)
• Subroutine calls with a stack
• Arbitrary memory manipulation

External Resources

• GitHub repository