We are currently working on new rules for what content should and shouldn't be allowed on this website, and are looking for feedback! See Esolang:2026 topicality proposal to view and give feedback on the current draft.
보라
- This is still a work in progress. It may be changed in the future.
| Designed by | User:Klk bb |
|---|---|
| Appeared in | 2026 |
| Computational class | Unknown |
| Reference implementation | Unimplemented |
보라 (Bora) is a brainfuck derivative esoteric programming language created by User:Klk bb in 2026. The language is designed around the idea of taking the already minimal computational model of brainfuck and removing most of the features that make it computationally useful.
Unlike conventional brainfuck implementations, 보라 does not provide an input command, loops, or an expandable memory array. Instead, it has exactly one memory cell, referred to as the accumulator. All arithmetic operations act directly on this accumulator, making 보라 an extremely small accumulator-based language.
The language contains only four commands: +, -, ., and :. Two of these commands modify the accumulator, while the other two are used for output.
A notable feature of 보라 is that its numeric output command is dependent on the local time of the machine executing the program. The : command normally outputs the current value of the accumulator as a decimal number, but produces no output when executed at exactly 00:00 according to the local 24-hour clock.
보라 is intentionally limited. Rather than attempting to be a practical programming language, it explores how few features are necessary for a language to still resemble a conventional programming language.
The language can be viewed as a stripped-down version of brainfuck in which almost everything except arithmetic and output has been removed. There is no way to access external input, no branching mechanism, and no repetition construct. Consequently, a 보라 program is generally a fixed sequence of arithmetic and output operations.
This makes programs easy to execute conceptually, while simultaneously making 보라 almost completely unsuitable for general-purpose programming.
The language's unusual time-dependent behavior is also intentional. The same source code can produce different observable behavior depending on the local clock of the device on which it is executed. This makes 보라 somewhat unusual among tiny esoteric languages, since the environment can affect the result even though the program itself contains no explicit time-related instruction.
Memory model
보라 has exactly one memory cell.
The memory cell acts as an accumulator and stores the current integer value of the program. Every arithmetic instruction operates on this value.
The + command increments the accumulator by one, while - decrements it by one. There are no commands for directly assigning a value, clearing the accumulator, moving to another cell, or accessing an address.
For example:
+++++
leaves the accumulator with a value of 5.
Likewise:
++++++++++---
leaves the accumulator with a value of 7.
Because there is only one cell, the language does not require pointer movement. This is one of the major differences between 보라 and traditional brainfuck.
Commands
The complete command set of 보라 is:
+ | Increment the accumulator by 1 - | Decrement the accumulator by 1 . | Output the accumulator as ASCII : | Output the accumulator as a number, unless the local time is 00:00
Characters other than these four commands may be treated as non-instructions. Implementations may therefore allow whitespace and comments to be included in source code, although the exact handling of non-command characters is implementation-dependent.
+
Increments the accumulator by one.
For example:
++++
sets the accumulator to 4, assuming the initial value of the accumulator is 0.
-
Decrements the accumulator by one.
For example:
-----
sets the accumulator to -5, assuming the initial accumulator value is 0.
The command can also be used after a sequence of + commands to reach a nearby value without requiring the entire value to be constructed from zero.
.
Outputs the current accumulator value as an ASCII character.
For example, the following program outputs the letter A:
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.
The program increments the accumulator to 65 and then outputs the corresponding ASCII character.
Unlike :, the . command is not affected by the system clock.
:
Outputs the current accumulator value as a decimal number.
There is one exception: if the command is executed when the local time of the executing device is exactly 00:00, it produces no output.
For example:
++++:
normally outputs:
4
However, if the command is executed at 00:00, nothing is output.
The time used by the command is the local time of the device running the program. It is not necessarily UTC and may therefore differ between machines running the same program.
Execution
A 보라 implementation begins with an accumulator in its initial state, normally zero. The source code is then processed from left to right.
Each recognized command is executed immediately.
For example:
+++.-
can be interpreted as follows:
The accumulator becomes 1.
The accumulator becomes 2.
The accumulator becomes 3.
The value 3 is output as an ASCII character.
The accumulator becomes 2.
There is no control flow, so execution always proceeds in the same direction until the end of the program is reached.
Because 보라 has no loops, a program cannot return to an earlier instruction under its own control.
Output behavior
보라 provides two different forms of output.
The . command interprets the accumulator as an ASCII character, while : displays its numerical value.
This allows the same accumulator value to be represented in two different ways.
For example, if the accumulator contains 65:
.
outputs:
A
while:
:
outputs:
65
The two commands therefore serve different purposes despite both being output instructions.
The time-dependent behavior of : means that numerical output is not completely deterministic. A program relying on : may behave differently at midnight than it does at any other time.
Examples
XKCD Random Number
One of the simplest demonstration programs is:
++++:
The program increments the accumulator four times and then prints it as a number.
Expected output:
4
The local time must not be 00:00.
If the local time is 00:00, the numeric output command does nothing. A workaround is to use ASCII output instead:
++++++++++++++++++++++++++++++++++++++++++++++++++++.
This outputs the character corresponding to the accumulator value rather than using the time-dependent numeric output instruction.
Hello World
A conventional "Hello, World!" program is technically possible only by manually constructing the ASCII values of every character. Since 보라 has no loops or macros, such programs can become extremely long.
A simplified fragment that outputs H is:
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.
The accumulator is incremented to 72, the ASCII value of H, and then printed.
The accumulator is not automatically reset after output, so subsequent characters must be constructed relative to the current value.
Counting
The following program demonstrates repeated numeric output:
+:+:+:+:+:
At a non-midnight time, it outputs a sequence of numbers corresponding to the changing accumulator.
Conceptually, the execution is:
1 2 3 4 5
The exact formatting of consecutive outputs depends on the implementation's output conventions.
Negative values
The accumulator can also become negative:
---:
At a non-midnight time, this outputs:
-3
This demonstrates that the accumulator is not restricted to positive values at the language level.
Limitations
보라 deliberately lacks many features normally associated with programming languages.
There is no input mechanism, meaning that a program cannot directly receive data from the user.
There are also no conditional instructions. A program cannot compare the accumulator against another value or choose between two execution paths.
Most importantly, 보라 has no loops or other forms of unbounded control flow. Every instruction in a program is executed at most once during a normal execution.
The language therefore cannot express arbitrary algorithms in the same way that a Turing-complete language can. In particular, it cannot implement general-purpose iteration or perform computations whose required number of operations is not bounded by the source code itself.
Turing completeness
Unlike brainfuck, 보라 is not Turing complete.
Brainfuck obtains its computational power primarily from its combination of mutable memory, pointer movement, and conditional looping. 보라 removes these mechanisms and replaces the memory model with a single accumulator.
Since there are no loops, the number of executed instructions is bounded by the length of the source program. The absence of input also prevents programs from reacting to arbitrary external data.
For these reasons, 보ра is categorized as a total and unusable for programming esoteric language.
Despite this, the language retains the appearance of a conventional imperative language: instructions modify state and output the resulting state.
Time dependency
The unusual behavior of : is one of the defining characteristics of 보라.
Most programming languages attempt to make a program's output depend primarily on its source code and explicit input. 보라 intentionally breaks this expectation by making one instruction depend on the local system clock.
The relevant condition is the local time at the moment the command is executed. Therefore, a program containing several : commands could theoretically behave differently if execution crosses midnight.
For example:
++++++++++++++++++++++++++++++++: :
does not necessarily have identical behavior for both output commands if the first command executes immediately before midnight and the second executes immediately after it.
This makes the local clock part of the effective execution environment of the language.
Use in programming
보라 is not intended for practical software development.
Its lack of input, control flow, and multiple memory locations makes ordinary programming tasks unnecessarily difficult or impossible. Even simple operations may require large numbers of repeated instructions.
The language is instead intended as an example of an esoteric programming language and as a small experiment in language minimalism.
Its intentionally inconvenient design also makes it suitable for programming-language jokes, code-golf challenges, and demonstrations of how language features affect computational expressiveness.