Bolaga

Bolaga is a stack-based esoteric programming language created by User:Fly in 2026.

Instructions

Instruction	Description
>N	Pushes a numeric literal `N` onto the stack.
<	Pops (removes) the top value.
+	Pops top two values, pushes their sum.
-	Pops top two values (`a` first, then `b`), pushes `a-b`.
@	Pops top value and prints it as an ASCII character.
%	Pops top value and prints it as a number.
#	Reads a line from input; if not empty, pushes the corresponding ASCII value of each character of the string.
^	Reads a number from input; if not empty, pushes it on the stack.
$	Reverses the whole stack.
: ... ;	Executes loop body repeatedly while stack is non-empty and top value is not `0`.
?	Compares top two values: if equal, continue normally; if different, skips next instruction (or skips whole next loop block if next token is `:`).
=	Duplicates the top values of the stack.
&	Empties out the stack
!	Stops the program.

Hello, World!

>72>101>108=>111>32>87>111>114>108>100>33$:@;

Truth-Machine

>48#->1$?:=%;$<>0$?%

Shorter version:

>49#?:=@;>0%

Even shorter version:

>49#?:=@;@

Counter from 1 to 10

>11>1:=%>10@>1+?-;

99 bottles of beer on the wall

>99:
    =%>0>10>108>108>97>119>32>101
    >104>116>32>110>111>32>114>101
    >101>98>32>102>111>32>115>101
    >108>116>116>111>98>32:@;
    <=%>0>10>114>101>101>98>32>102
    >111>32>115>101>108>116>116>111
    >98>32:@;<>0>10>110>119>111>100
    >32>101>110>111>32>101>107>97>84
    :@;<>0>10>100>110>117>111>114>97
    >32>116>105>32>115>115>97>80
    :@;<>1>0-+=%>0>10>108>108>97>119
    >32>101>104>116>32>110>111>32>114
    >101>101>98>32>102>111>32>115>101
    >108>116>116>111>98>32:@;<
;

Calculator

>0
    >32>58>114>101
    >98>109>117>110
    >32>116>115>114
    >105>102>32>101
    >104>116>32>116
    >117>112>110>73
:@;<^
>0
    >32>58>114>101
    >98>109>117>110
    >32>100>110>111
    >99>101>115>32
    >101>104>116>32
    >116>117>112>110>73
:@;<^
>0
    >32>58>41>47>32>44>42
    >32>44>45>32>44>43>40
    >32>110>111>105>116>97
    >114>101>112>111>32>110
    >97>32>114>101>116>110>69
:@;<#
>43?:>0
    $+%$
;<
>45?:>0
    $-%$
;<
>42?:>0
    >0$:
        >1>0-+$>1+$;<>1>0-+>0$
        :>1>0-+$>1+$;<$=$>0$
        :>1>0-+$>1+$;<$>0$:>1>0-+
        $>1+$;<:>1>0-+>0$:>1>0-+$
        >1+$;<$>0$:>1>0-+$>1+$;<$
        =$>0$:>1>0-+$>1+$;<+$>0$:
        >1>0-+$>1+$;<;<>0$:>1>0-+$
        >1+$
    ;<<$%$
;<
>47?:>0
    >0$:
        $>0$:>1>0-+$>1+$;<=>0$
        :>1>0-+$>1+$;<$-$>1+$;
        <<>0$:>1>0-+$>1+$
    ;<$%$
;>10@&!

Stack manipulation and other operations

These are some operations you can do to manipulate the stack or perform logical branching that were found by the Discord user @marr_ales_fios

Rightward rotation

$>0$:>1>0-+$>1+$;<

Leftward rotation

>0$:>1>0-+$>1+$;<$

Duplicate second-to-top element

$>0$:>1>0-+$>1+$;<=>0$:>1>0-+$>1+$;<$

Duplicate bottom element

>0$:>1>0-+$>1+$;<$=$>0$:>1>0-+$>1+$;<

Greater than

-:>1:$>0$:>1>0-+$>1+$;<=>0$:>1>0-+$>1+$;<$=$>0$:>1>0-+$>1+$;<->1+>1?:[code];<<$<>0;;<$

Less than

-:>1:$>0$:>1>0-+$>1+$;<=>0$:>1>0-+$>1+$;<$=$>0$:>1>0-+$>1+$;<+>1+>1?:[code];<<$<>0;;<$

Swap first two elements of the stack

=$>0$:>1>0-+$>1+$;<->0-=>0$:>1>0-+$>1+$;<$+=$>0$:>1>0-+$>1+$;<->0$:>1>0-+$>1+$;<$

Duplicate top two elements of the stack

$>0$:
    >1>0-+$>1+$;<=>0$:>1>0-+
    $>1+$;<$=$>0$:>1>0-+$>1+
    $;<->0-=>0$:>1>0-+$>1+$;
    <$+=$>0$:>1>0-+$>1+$;<->
    0$:>1>0-+$>1+$;<>0$:>1>0
    -+$>1+$;<=>0$:>1>0-+$>1+
    $;<$=$>0$:>1>0-+$>1+$;<-
    >0-=>0$:>1>0-+$>1+$;<$+=
    $>0$:>1>0-+$>1+$;<->0$:>
    1>0-+$>1+$
;<$

Shorter version:

$>2:
    >1>0-+>0$:>1>0-+$>1+$;<=
    >0$:>1>0-+$>1+$;<$=$>0$:
    >1>0-+$>1+$;<->0-=>0$:>1
    >0-+$>1+$;<$+=$>0$:>1>0-
    +$>1+$;<->0$:>1>0-+$>1+$
;<;<$

Multiply the top two values

$>0$:
    >1>0-+$>1+$;<>1>0-+>0$
    :>1>0-+$>1+$;<$=$>0$:>
    1>0-+$>1+$;<$>0$:>1>0-
    +$>1+$;<:>1>0-+>0$:>1>
    0-+$>1+$;<$>0$:>1>0-+$
    >1+$;<$=$>0$:>1>0-+$>1
    +$;<+$>0$:>1>0-+$>1+$;
    <;<>0$:>1>0-+$>1+$
;<<$

Divide the top two values (only integer division)

$>0$:
    $>0$:>1>0-+$>1+$;<=>0$
    :>1>0-+$>1+$;<$-$>1+$;
    <<>0$:>1>0-+$>1+$
;<$

Computational class

Bolaga is Turing Complete, via BCT:

10 --> >1?:$2$0;<
11 --> >1?:$1$0;<
0 --> <

wrapping the whole program in : ... ;.
Q.E.D

alternately, one may use a Brainfuck translation, that uses 3 cells. This proof does unlike the above, not use $:

[ --> :
] --> ;
> --> >0$:>1>0-+$>1+$;<$
< --> $>0$:>1>0-+$>1+$;<
+ --> >1+
- --> >1=$>0$:>1>0-+$>1+$;<->0-=>0$:>1>0-+$>1+$;<$+=$>0$:>1>0-+$>1+$;<->0$:>1>0-+$>1+$;<$-

starting the program with:

>0>0>0

where the cell being pointed at by the pointer is the top of the stack

Implementations

D Interpreter

https://github.com/mmmmosca/Bolaga/blob/main/interpreter.d