Oh Wow anOther generic esoteric programming langUage Wow yoU are so creative

This is still a work in progress. It may be changed in the future.

Oh Wow anOther generic esoteric programming langUage Wow yoU are so creative or just OwO-UwU for short is an esoteric programming language by user:raiseafloppafan7741 in 2026.

Overview

OwO-UwU is mainly focused around quickly creating basic types of languages, such as trivial brainfuck/deadfish substitutions and constant languages.

There is a temporary stack, which as the name suggests is used to store temporaries. A program has scopes which may have variables.

Data types

The data types in OwO-UwU are:

• Integer, which is a 64-bit integer
• String
• Array
• Language (abstract)
  • Constant language, which is a constant language.
  • Quine-avoiding constant language, which is a quine-avoiding constant language.
  • Length-based constant language or LBCL for short, prints a given string N times where N is the length of the input
  • Trivial deadfish substitution, which is a trivial deadfish substitution.
  • Trivial BF substitution, which is a trivial brainfuck substitution.
  • Linear command executor or LCE for short, languages that have a set of commands and no jumps, meaning they have linear code execution and are total. Examples of this kind of language are deadfish and Fuck you!

Syntax

Oh wow, a variable named [name].

The above declares a variable in the current scope. The name must follow the rules for identifiers in the book version of Lox.

Store into the variable [variable].

The above pops the top of the temporary stack and stores it in the given variable.

Get the variable [variable].

The above pushes the value of the given variable to the temporary stack.

Store into the instance variable [variable].
Get the instance variable [variable].

The above two are the same as the aforementioned, except they operate on the current object.

An empty string? What?

The above pushes an empty string to the temporary stack.

What do you have to say?

The above reads a line of input as a string and pushes it to the temporary stack.

Here's what I have to tell you.

The above pops the top of the temporary stack and prints it, without a newline.

Arithmetic and comparison

Add the top two values on the stack.
Subtract the top two values on the stack.
Multiply the top two values on the stack.
Divide the top two values on the stack.
Modulo the top two values on the stack.
Are the top two values on the stack equal?
Are the top two values on the stack not equal?
Is the second from the top greater than the top of the stack?
Is the second from the top less than the top of the stack?
Is the second from the top greater than or equal to the top of the stack?
Is the second from the top less than or equal to the top of the stack?
Logical not of the top value on the stack.

The above are self-explanatory, with the first element popped being on the right-hand-side of the operator. The first one can perform string and array concatenation.

Cast the top of the stack into a 64-bit signed integer.

Self-explanatory. On failure, it pushes zero.

Control flow

Oh wow, a block statement.
Oh wow, the end of a block statement.

The above two delimit a block statement. Block statements have their own scopes and allow variable shadowing.

Is the top of the stack truthy? If so, then run the following.
End if statement.

The above is an if-statement. It pops the top of the temporary stack and if it is truthy (not zero or an empty string) then it runs the instructions between the delimiters.

Is the top of the stack truthy? If so, then run the following.
Otherwise, run the following instead.
End if statement.

The above is an if-else statement.

While the top of the stack is truthy, do the following.
Oh wow, the end of a block statement.

While loop. Similar to the if-statement but it jumps back to the start after every iteration.

Arrays

An empty array?

The above pushes an empty array to the temporary stack.

Get the Nth item from the collection.

The above pops an array, then an integer index, then gets the Nth item of the array and pushes it to the stack. This also works for strings.

Set the Nth item of the collection.

The above pops an array, an integer index, then a value, then sets the Nth item of the array to the value then pushes the array back. This also works for strings.

Languages

Oh wow, a language that prints "[text]". How interesting.

The above pushes to the temporary stack a Constant language object that returns [text] when you invoke it.

Oh wow, a language that prints "[text1]" or prints "[text2]" if the first one is a quine. Very very interesting indeed.

The above pushes to the temporary stack a Quine-avoiding constant language object that returns [text1] if the input program is not a quine, or [text2] if it is a quine.

Oh wow, a language that prints "[text]" for every character in the source. Very very VERY interesting indeed.

The above pushes to the temporary stack a Length-based constant language object that returns its output.

Oh, it's one of those languages. The one where you replace "i" with "[string1]", "d" with "[string2]", "s" with "[string3]", and "o" with "[string4]".

Oh, it's one of those languages. The one where you replace "i" with "[string1]", "d" with "[string2]", "s" with "[string3]", "o" with "[string4]", and "h" with "[string5]".

The above both push to the stack a Trivial deadfish substitution object. The first one does not have the halt command while the second one does.

Oh, it's one of those languages. The one where you replace "+" with "[string1]", "-" with "[string2]", "<" with "[string3]", ">" with "[string4]", "," with "[string5]", "." with "[string6]", "[" with "[string7]", and "]" with "[string8]".

The above pushes to the stack a Trivial BF substitution object.

Oh, it's one of those languages.
The one where "[command1]" does
    [code]
and "[command2]" does
    [code]
and "[command3]" does
    [code]
...
and "[commandN]" does
    [code]
but before all of that you do
    [code]
and after that you do
    [code]
and everything else is ignored.

The above pushes to the stack an LCE (Linear command executor) object. Newlines do not matter and are simply a matter of style here. The but before all of that you do [code] and and after that you do [code] sections are optional.

Run the thing with the program below it.

The above invokes the language with the program stored in the string below it on the stack, which is popped too.

Computational class

Since the language has a built-in trivial brainfuck substitution runner, OwO-UwU is Turing-complete as brainfuck and trivial substitutions of it are Turing-complete. However, it can also run brainfuck by itself as it has arbitrary memory access and unbounded conditional and unconditional loops.

Examples

Hello, world! program

An empty string? What?
Oh wow, a language that prints "Hello, world!\n". How interesting.
Run the thing with the program below it.
Here's what I have to tell you.

Nope. interpreter

What do you have to say?
Oh wow, a language that prints "Nope.\n". How interesting.
Run the thing with the program below it.
Here's what I have to tell you.

As a meta-language imitation:

Oh wow, a language that prints "Nope.". How interesting.

Nope. without a quine interpreter

What do you have to say?
Oh wow, a language that prints "Nope.\n" or prints "lol no quine for you\n" if the first one is a quine. Very very interesting indeed.
Run the thing with the program below it.
Here's what I have to tell you.

Hi interpreter

What do you have to say?
Oh wow, a language that prints "hi" for every character in the source. Very very VERY interesting indeed.
Here's what I have to tell you.

Fuck you! interpreter

What do you have to say?
Oh, it's one of those languages.
The one where "!" does
    An empty string? What?
    Oh wow, a language that prints "Fuck you!\n". How interesting.
    Run the thing with the program below it.
    Here's what I have to tell you.
and everything else is ignored.
Run the thing with the program below it.
Here's what I have to tell you.

deadfish interpreter

Trivial substitution one

What do you have to say?
Oh, it's one of those languages. The one where you replace "i" with "i", "d" with "d", "s" with "s", "o" with "o", and "h" with "h".
Run the thing with the program below it.

Long one

What do you have to say?
Oh, it's one of those languages.
The one where "i" does
    Get the instance variable run.
    Is the top of the stack truthy? If so, then run the following.
        Get the instance variable accumulator.
        An empty string? What?
        Oh wow, a language that prints "1". How interesting.
        Run the thing with the program below it.
        Cast the top of the stack into a 64-bit signed integer.
        Add the top two values on the stack.
        Store into the variable tmp.
        Get the variable tmp.
        An empty string? What?
        Oh wow, a language that prints "256". How interesting.
        Run the thing with the program below it.
        Cast the top of the stack into a 64-bit signed integer.
        Are the top two values on the stack equal?
        Is the top of the stack truthy? If so, then run the following.
            An empty string? What?
            Oh wow, a language that prints "0". How interesting.
            Run the thing with the program below it.
            Cast the top of the stack into a 64-bit signed integer.
            Store into the instance variable accumulator.
        Otherwise, run the following instead.
            Get the variable tmp.
            Store into the instance variable accumulator.
        End if statement.
        Store into the instance variable accumulator.
    End if statement.
and "d" does
    Get the instance variable run.
    Is the top of the stack truthy? If so, then run the following.
        Get the instance variable accumulator.
        An empty string? What?
        Oh wow, a language that prints "1". How interesting.
        Run the thing with the program below it.
        Cast the top of the stack into a 64-bit signed integer.
        Subtract the top two values on the stack.
        Store into the variable tmp.
        Get the variable tmp.
        An empty string? What?
        Oh wow, a language that prints "256". How interesting.
        Run the thing with the program below it.
        Cast the top of the stack into a 64-bit signed integer.
        Are the top two values on the stack equal?
        Is the top of the stack truthy? If so, then run the following.
            An empty string? What?
            Oh wow, a language that prints "0". How interesting.
            Run the thing with the program below it.
            Cast the top of the stack into a 64-bit signed integer.
            Store into the instance variable accumulator.
        Otherwise, run the following instead.
            Get the variable tmp.
            An empty string? What?
            Oh wow, a language that prints "-1". How interesting.
            Run the thing with the program below it.
            Cast the top of the stack into a 64-bit signed integer.
            Are the top two values on the stack equal?
            Is the top of the stack truthy? If so, then run the following.
                An empty string? What?
                Oh wow, a language that prints "0". How interesting.
                Run the thing with the program below it.
                Cast the top of the stack into a 64-bit signed integer.
                Store into the instance variable accumulator.
            Otherwise, run the following instead.
                Get the variable tmp.
                Store into the instance variable accumulator.
            End if statement.
        End if statement.
    End if statement.
and "s" does
    Get the instance variable run.
    Is the top of the stack truthy? If so, then run the following.
        Get the instance variable accumulator.
        Get the instance variable accumulator.
        Multiply the top two values on the stack.
        Store into the variable tmp.
        Get the variable tmp.
        An empty string? What?
        Oh wow, a language that prints "256". How interesting.
        Run the thing with the program below it.
        Cast the top of the stack into a 64-bit signed integer.
        Are the top two values on the stack equal?
        Is the top of the stack truthy? If so, then run the following.
            An empty string? What?
            Oh wow, a language that prints "0". How interesting.
            Run the thing with the program below it.
            Cast the top of the stack into a 64-bit signed integer.
            Store into the instance variable accumulator.
        Otherwise, run the following instead.
            Get the variable tmp.
            Store into the instance variable accumulator.
        End if statement.
    End if statement.
and "o" does
    Get the instance variable run.
    Is the top of the stack truthy? If so, then run the following.
        Get the instance variable accumulator.
        Here's what I have to tell you.
        An empty string? What?
        Oh wow, a language that prints " ". How interesting.
        Run the thing with the program below it.
        Here's what I have to tell you.
    End if statement.
and "h" does
    An empty string? What?
    Oh wow, a language that prints "0". How interesting.
    Run the thing with the program below it.
    Here's what I have to tell you.
    Cast the top of the stack into a 64-bit signed integer.
    Store into the instance variable halt.
but before all of that you do
    An empty string? What?
    Oh wow, a language that prints "0". How interesting.
    Run the thing with the program below it.
    Cast the top of the stack into a 64-bit signed integer.
    Store into the instance variable accumulator.
    An empty string? What?
    Oh wow, a language that prints "1". How interesting.
    Run the thing with the program below it.
    Cast the top of the stack into a 64-bit signed integer.
    Store into the instance variable run.
and everything else is ignored.
Run the thing with the program below it.

BF interpreter

What do you have to say?
Oh, it's one of those languages. The one where you replace "+" with "+", "-" with "-", "<" with "<", ">" with ">", "," with ",", "." with ",", "[" with "[", and "]" with "]".
Run the thing with the program below it.

It's likely possible to create a BF interpreter without using the Trivial BF substitution object as OwO-UwU has many qualities of a typical imperative programming language.

See also

• brainfuck
  • Trivial brainfuck substitution
• deadfish
  • Trivial deadfish substitution
• Constant language
  • ConstantLanguage()
• Meta-languages
• YO_DAWG, an esolang based on "first-class esolangs". OwO-UwU and YO_DAWG have somewhat similar ideas (having esolangs as first-class types) but both go about it in very different ways. For example, OwO-UwU has many non-esolang types while everything in YO_DAWG is an esolang.
• ORK is quite distant from OwO-UwU, but both have similarly verbose syntax.