Whizz

Whizz

Designed by	splot.dev (User:Splot-dev)
Appeared in	2026
Dimensions	One-dimensional
Computational class	Turing complete
Major implementations	Whizz Repository & CLI
Influenced by	brainfuck
File extension(s)	.whz

Introduction

Whizz is a variable-based esoteric programming language, identifying as a Turing tarpit, though it has significantly more structure than most. You'll find the official site here.

Origins

It was created in the summer of 2026 by User:Splot-dev, with an arbitrary name. It was made to address a problem: prominent esoteric languages lacked sufficient structure to be 'scalable', even if that was not the purpose of esolangs, making programs unwieldy and exhausting to write, often being extremely repetitive with no challenge whatsoever to the programmer. Its minimal and incremental structure was inspired by Brainfuck, though Whizz is very different from it—Whizz doesn't even have a tape.

Turing-Completeness

Whizz is Turing-Complete, as shown by this proof that implements Unbounded-Integer 5-Cell Brainfuck in Whizz, effectively showing that since Unbounded-Integer 5-Cell Brainfuck is Turing-Complete, so is Whizz.

Implementation

A Python implementation is available (a transpiler, easily accessible as a pip package) here. This is Whizz's main location, and this page is kept up to date depending on the repository.

Example

This program prints 0 1 2 3 4 5 6 7 8 9 using a loop.

zeroToNine {
   [ create variables ]
   counter 10+ [ track state ]
   char 48+ [ print this one ]
   space 32+ [ space char ]
 
   (
     char!+ [ print and increment char ]
     counter-; [ decrement counter and end if zero ]
     space! [ print space ]
   )
}

zeroToNine*

It can be minimized: c10+n48+s32+(n!+c-;s!)

Commands

Whizz has many commands that manipulate the variables storing negative or positive integers. It relies on Unicode mappings for I/O and follows some conventions, esoteric or not. It is whitespace-insignificant unless the whitespace is used to separate 'select' statements.

Selecting

Selecting is the first command in Whizz, and is any alphabetical string. It sets the 'current variable' to that string. If that selected variable hasn't been created yet, this creates it, starting it at 0.

Example: var

Increment/Decrement

A plus or minus sign, this command increments or decrements by 1, based on that aforementioned symbol. It can increment or decrement more, by having a positive integer placed before the symbol, which represents the repetitions of that incrementation or decrementation.

Example: a 23+ or a+

Random

This command, a plain tilde, sets the 'current variable' to an integer between 1 and 1 million.

Example: a~

External example of usage: https://codegolf.stackexchange.com/questions/101638/shortest-code-to-produce-non-deterministic-output/290058#290058

Function

This command structure encloses other commands, and when called, runs them. It is represented as an alphabetical string followed by two curly brackets, with code within. Recursion is allowed, but there is a depth limit.

Example: a{}

Forever Loop

This command, a set of round brackets, runs the code within indefinitely until broken.

Example: ()

End Loop Conditional

A semicolon, which is this command's entirety, stops a forever loop if the 'current variable' is 0.

Example: (a;)

Function Call

An alphabetical string followed by an asterisk, this command executes the corresponding function to that string.

Example: a{} a*

Print

An exclamation mark, this command prints the 'current variable's Unicode character mapping.

Example: a!

External example of usage: https://codegolf.stackexchange.com/questions/267030/print-the-christmas-alphabet/290495#290495

Input

A question mark, this command takes in a character as input and sets the 'current variable' to its integer Unicode mapping.

Example: a?

Comment

A comment is just anything that is enclosed in hard brackets, which is ignored, and is intended as a non-affecting, non-obstructive note for the programmer or reader.

Example: [ hello my friend ]

Code Structures

Certain sequences in Whizz map to commands found in other languages. Here is a (incomplete) list of them.

Binary Logic If Statement

This structure runs the function doStuff if a is not zero.

(a; doStuff* ZERO;)

You can make it run if a is zero, like this:

flag+ (a; flag- ZERO;) (flag; doStuff* ZERO;)

This essentially just uses a flag to invert the logic.

It's like:

flag = True
if a is not zero:
  flag = False

if flag is True:
  doStuff()

Move & Copy Positive Integers

This structure decrements a until it is zero, while incrementing b and c. This essentially copies a onto b and c, if b and c are zero at the start, and a is positive. This structure can be manipulated to perform similar tasks.

( a; a- b+ c+ )

Conventions

Whizz has some non-enforced stylistic and practical rules to ensure readability.

Loops

In loops, you should have spaces after the start bracket and before the end bracket, like this: ( doStuff* ). Additionally, if a certain computation is related to the loop after it, it should be 'stuck' to it, like this: a2+( doStuff* ). If it is not related, there should be whitespace isolating the loop.

Increment/Decrement

When incrementing and decrementing, it is important that if you have a repetitive increment/decrement, that you make it easy to read. This is doable like this:

• If you are using newlines and isolating commands with newlines, you should add a space between the +/- symbol and the number, like this: a 2+
• If you are not using newlines to isolate the command, and if the command is being used with other commands on the same line, you should group it all in one, like this: a2+

And, it is implied that a+ should always stay as such, and have no separator between 'a' and '+'.

Comments

Like loops, there should a space after the start bracket and a space before the end bracket. This applies for multi-line comments. Nested comments are illegal.

Indentation

There is no suggested indentation level amount.

You should indent if it is logical to do so, emulating high-level languages. For example, in a Binary Logic If Statement, if the code that runs is multi-lined, you should indent that chunk, like this:

(a;
   doA*
   doB*
   doC*
ZERO;)

Also, notice that in this case, the loop should not have spaces after the start bracket and before the end bracket: this is for readability.

Variables

Camel case is to be used for variables, unless if they are constants, in that case they should be capitalized.

The ZERO Variable

This variable should always be 0, as the name suggests, for If Statements (see the Binary Logic If Statement on this page).

External Resources

Official Site

Whizz Repository

Whizz Repository README

Whizz Turing-Completeness Proof

Camel Case Wikipedia Page