From Esolang
Jump to navigation Jump to search

Tsept (pronounced /t͡sɛpt/) is an esolang with 28 instructions and 28 syscalls. Its name means "Tetra Sept" (4*7) because of the quantity, as mentioned earlier, of instructions and syscalls.

Data structures

Tespt has multiple data structures used for storing different things:

name purpose
Registers & stacks For storing immediate and backup values
Heap For storing strings and arrays and spilling data when the registers and stacks are full.


There are seven registers:

  • The A register is the accumulator, the primary register used for arithmetic, I/O, popping and pushing things to and from the Stack, and storing the syscall number when the program makes a syscall.
  • The B register is the backup; it is used for storing the accumulator or secondary when they need to be overwritten, but you don't want to lose their value.
  • The S register is the secondary; it is used as just another register; it can act as a secondary backup or, as in the case of syscalls, as another numerical parameter.
  • The C register is the counter; it's mainly used in loops but can be used as just another register.
  • The D register is the address register; it's mainly used for addressing heap memory but can be used as just another register.
  • The E register is the address backup; it serves the same purpose as the main backup but is a backup for the address register instead of the accumulator.
  • The X register is the address secondary; as with the address backup, it serves the same purpose as its main correspondent but is secondary to the 'D' register.

Default Values

The accumulator will, by default, contain the TSEPT version.

By nature of the C programming language (used to program Tsept's interpreter), the other registers are set to unpredictable values by default.


There are two stacks in Tsept, each 256 integers big, and they can be swapped using the 'W' instruction.


The heap is like a tape that can be accessed at any location and shrink or grow anytime; trying to access memory beyond the heap's bounds will raise Exception 4 and stop the program.


The Tsept interpreter has seven exceptions it can throw if a problem arises from the program:

  • Exception 1: Raised when the program attempts to run an invalid instruction.
  • Exception 2: Raised when a syscall fails for any reason.
  • Exception 3: Raised when the interpreter can't allocate the program's heap memory.
  • Exception 4: Raised when the program tries to access heap memory beyond its bounds.
  • Exception 5: Raised when one of the stacks overflows.
  • Exception 6: Raised when one of the stacks underflows.
  • Exception 7: Raised when the program tries to execute a syscall which doesn't exist.

When the interpreter prints the exception test, it will also print the address at which the exception got raised in the program and the registers.


Tsept has 28 instructions organized into five categories.


  • A: Pop and add to the accumulator
  • S: Pop and subtract from the accumulator
  • I: Increment the accumulator
  • D: Decrement the accumulator
  • X: Bitwise XOR the accumulator with popped value
  • a: Bitwise AND the accumulator with popped value

Register Operations

  • B: Swap accumulator and register 'B'
  • w: Swap registers 'D' and 'E'
  • x: Clear the accumulator
  • K: Swap registers 'S' and 'B'
  • b: Swap registers 'X' and 'E'
  • k: Set accumulator to register 'C'

Stack and Heap Operations

  • P: Push accumulator
  • p: Pop accumulator
  • W: Swap stacks
  • C: Pop register 'C'
  • d: Pop register 'D'
  • H: Push heap memory at register 'D'
  • h: Pop heap memory at register 'D'
  • R: Push register 'D'
  • c: Push register 'S'
  • l: Pop register 'S'

Control Flow

  • J: Pop and relative jump to the popped value
  • i: Pop and relative jump to the popped value if the accumulator is not zero
  • L: If register 'C' is higher than zero, decrement it and jump to one character after the last location it was modified


  • !: Output accumulator to stdout
  • ?: Input accumulator from stdin

Note: the s instruction executes a syscall.

In Tsept, you can specify comments by enclosing the comment in slashes:

/This text won't get interpreted!/


Tsept has 28 syscalls that get forwarded to Linux syscalls by the interpreter:

syscall name Accumulator Register 'S' Register 'D' Register 'X' Popped from stack
read 0 file descriptor buffer count -
write 1 file descriptor buffer count -
open 2 file descriptor (output) filename - -
close 3 file descriptor - - -
create 4 - filename - -
link 5 - oldname newname -
delete 6 - filename - -
fork 7 child PID (output to parent) - - -
getpid 8 own PID (output) - - -
getppid 9 parent PID (output) - - -
exec 10 argument count filename - argument list
chmod 11 mode filename - -
signal/kill 12 pid signal (int) - -
rename 13 - oldname newname -
mkdir 14 - path - -
rmdir 15 - path - -
time 16 unix epoch (output) - - -
truncate 17 fd size (int) - -
socket 18 fd (output) - - -
bind 19 fd port - -
listen 20 fd - - -
accept 21 fd - - client fd (output)
connect 22 fd IP address port server fd (output)
output hex 23 no. bytes to print data - -
output decimal 24 number - - -
resize heap 25 size - - -
heap size 26 size (output) - - -
wait 28 pid - - -
exit 28 error code - - -


The 'tseptc' interpreter is available in this Codeberg repository.


Truth Machine