Tau (Noelle)

Tau

Paradigm(s)	imperative
Designed by	noellekde
Appeared in	2026
Type system	none (fixed-size cells)
Memory system	cell-based
Dimensions	one-dimensional
Computational class	Unknown
Reference implementation	tau.py
Major implementations	Tau++
File extension(s)	.tau

Tau is an esoteric imperative programming language in which programs work directly on memory cells of fixed size instead of variables, strings or types. There are exactly three kinds of cell: T (1 byte), Ta (50 bytes) and Tau (100 bytes). A program changes memory by writing bytes into a numbered address, does its arithmetic in sixteen registers, and controls the flow of execution with labels and jumps. It was created in October 2026.

Tau is meant to be demanding to write: it has no variables, no structured loops or conditionals, no functions with arguments and no input statement. Its computational class has not been determined.

There are two interpreters that behave identically, a reference implementation in Python (tau.py) and a C++ implementation called Tau++, which also powers tauIDE, a Windows editor whose syntax highlighter and status bar are themselves written in Tau.

Overview

Tau began as a single operator, Define, which writes bytes straight into the cell stored at an address. A program made only of Define statements prints its Tau cells as text when it ends, and this is the Tau 0.1 way of producing output. Version 0.2 added registers, arithmetic, byte loading and storing, labels, conditional jumps, subroutines, printing statements and a host interface. Programs written for 0.1 still run unchanged.

Memory

Memory is a set of cells found at numeric addresses. The type of a cell fixes its size:

Type	Size	Note
T	1 byte	A single byte
Ta	50 bytes	Medium cell
Tau	100 bytes	Largest cell; the one that 0.1 programs print

A cell is created by writing to its address. Data shorter than the cell is padded with zero bytes, data that is too long is an error, and writing to an address that already holds a cell replaces it. Reading, writing or printing an address that holds no cell is an error, as is using a byte index outside the cell.

Registers and values

There are sixteen signed 32-bit registers, r0 to r15. Arithmetic wraps around on overflow, and division and remainder truncate toward zero. A value is a register, a number or a character:

• decimal, hexadecimal and binary numbers: 10, 0x1F, 0b101, -4
• characters: 'a', '\n'

Addresses are values too, so they can be kept in registers.

Commands

A program is a list of statements, one per line. A # starts a comment that runs to the end of the line. Statement and type names are not case-sensitive. A line that contains only T, Ta or Tau is a section header and does nothing.

Statement	Effect
Define <T|Ta|Tau> <addr> "<bits>"	Writes bytes, given as groups of eight binary digits, into the cell at addr
Text <T|Ta|Tau> <addr> "<text>"	Writes text; the escapes \n \t \r \0 \\ \" \xHH are understood
Set, Add, Sub, Mul, Div, Mod rD <v>	Arithmetic on register rD
Load rD <addr> <idx>	Puts byte number idx of the cell at addr into rD
Store <addr> <idx> <v>	Sets byte idx of the cell to the low eight bits of v
Len rD <addr>	Puts the number of bytes before the first zero byte of the cell into rD
name:	Defines a label
Jump L	Continues at label L
Jeq, Jne, Jlt, Jgt, Jle, Jge <v> <v> L	Continues at L if the comparison between the two values holds
Call L, Ret	Subroutine call and return, nested up to 256 deep
Halt	Stops the program
Print <addr>	Prints the cell as text, up to its first zero byte
PrintChar <v>, PrintInt <v>, Newline	Print a character, a number or a line break
Host <function> <args...>	Calls a function of the program that embeds Tau

A program that contains nothing but Define and Text statements prints all of its Tau cells as text, in address order, when it ends.

Errors and limits

An error stops the program and names the line:

Tau error: line 2: index 5 outside T cell

To catch endless loops, a program is stopped after a fixed number of steps: 5 million by default, or 50 million when a document is supplied. The limit can be changed with --steps.

Host interface

Tau has no input statement. A program that runs inside another program can instead read a document through Host functions, each of which stores its result in its first argument.

Call	Result
Host TextLen rD	Length of the document
Host CharAt rD <idx>	Character code at idx, or 0 outside the document
Host CaretLine rD, Host CaretCol rD	Caret position, counted from 1
Host LineCount rD	Number of lines
Host Paint <start> <len> <colour>	Colours a range of the document

On the command line the document comes from a file or from standard input. In tauIDE it is the text in the editor.

Examples

Hello, World!

The Tau 0.1 program. The bytes in the first cell spell "Hello World!" in ASCII.

tau
Define tau 0x01 "01001000 01100101 01101100 01101100 01101111 00100000 01010111 01101111 01110010 01101100 01100100 00100001"
Ta
Define Ta 0x02 "00000000"

Output:

Hello World!

Factorial

# factorial of 10
Set r0 10
Set r1 1
loop:
Jle r0 1 done
Mul r1 r0
Sub r0 1
Jump loop
done:
PrintInt r1
Newline

Output:

3628800

Reversing a string

# reverse a string in place with Load/Store/Len
Text tau 0x10 "Tau++ rocks"
Len r0 0x10        # r0 = length
Set r1 0           # left
Set r2 r0
Sub r2 1           # right
swap:
Jge r1 r2 show
Load r3 0x10 r1
Load r4 0x10 r2
Store 0x10 r1 r4
Store 0x10 r2 r3
Add r1 1
Sub r2 1
Jump swap
show:
Print 0x10
Newline

Output:

skcor ++uaT

Implementations

Name	Written in	Description
tau.py	Python	The reference implementation and home of the language definition. Command line only; needs Python 3.9 or newer.
Tau++	C++17	A native implementation with no dependencies beyond the standard library. It gives exactly the same output and error messages as tau.py, which is checked by an automated test suite.
tauIDE	C++ and Tau	A Windows editor built on Tau++. The window, files and the Run command are C++; syntax highlighting and the status bar are Tau programs that the editor runs whenever the text changes and that can be edited and reloaded without recompiling.

Both interpreters are run the same way:

python3 tau.py program.tau [--text file|-] [--caret N] [--steps N]
tau++ program.tau [--text file|-] [--caret N] [--steps N]

tauIDE

tauIDE is a dark editor with live syntax highlighting, an output pane and a status bar that shows the caret position and the size of the document. F5 runs the program in the editor, and a running program can read the editor's own text through the host interface. Ctrl+R reloads the two Tau scripts that implement the highlighter and the status bar. Releases for Windows contain the program together with its scripts folder.

Programs written in Tau

The distribution includes textstats.tau, a text analyser written entirely in Tau. Given a text file it reports the numbers of lines, words, characters, letters, digits and empty lines, the length of the longest line, and a bar chart of how often each letter of the alphabet occurs. A smaller counter in the style of the Unix wc utility, wc.tau, is also included.

See also

• Brainfuck

External resources

• Tau on GitHub - the Python reference implementation, the language reference, examples and tools (MIT license)
• Tau++ on GitHub - the C++ implementation and tauIDE, with Windows builds under Releases (MIT license)