lLvlN++

LLvlN++ or Low-Level Nonsense Plus Plus is an esoteric programming language created in 2025 as an extension of LLvlN. It adds support for functions, procedures, object-oriented programming, and asynchronous programming to the base LLvlN language, allowing for more structured and modern programming while maintaining the culinary-themed absurdity of the original.

Overview

LLvlN++ extends LLvlN by introducing:

• Function and procedure definitions
• Parameter passing mechanisms
• Return values
• Call stack management
• Local variable scoping (using the same food-themed registers)
• Recursive function calls
• Object-oriented programming with "KITCHEN" classes
• Asynchronous programming with "MICROWAVE" and "TIMER" keywords

The language maintains full backward compatibility with LLvlN programs, meaning any valid LLvlN program is also a valid LLvlN++ program. The additions use cooking-themed terminology consistent with the base language: functions are "RECIPES" (distinct from the program start marker), procedures are called with "ORDER", returns use "PLATE", classes are "KITCHEN", and async operations use "MICROWAVE" and "TIMER".

Language Specification

New Instructions

Function Definition

• MENU <name> - Begins a function definition with the given name
• DISH <name> - Alternative to MENU (procedure with no return value)
• PLATED - Ends a function/procedure definition
• PLATE <register> - Returns from function with value in register
• PLATE - Returns from procedure (no return value)

Function Invocation

• ORDER <function> - Calls a function or procedure
• PREP <function> - Calls function and stores return value in register

Parameter Passing

• INGREDIENT <register> - Declares that a register is a parameter (inside function definition)
• WITH <register> - Pushes register value as argument before ORDER/PREP

Object-Oriented Programming

• KITCHEN <name> - Begins a class definition
• CLOSED - Ends a class definition
• CHEF <register> - Declares a member variable
• COOKBOOK <name> - Defines a method within a class
• NEW <class> <register> - Creates an instance of a class
• CALL <instance>.<method> - Invokes a method on an object
• GET <instance>.<field> <register> - Accesses a member variable
• SET <instance>.<field> <register> - Sets a member variable

Asynchronous Programming

• MICROWAVE <function> - Starts an asynchronous function call
• TIMER <register> - Waits for async operation to complete, stores result
• READY <async_id> - Checks if async operation is complete (non-blocking)
• CANCEL <async_id> - Cancels a pending async operation

Parameters are passed by value. When a function is called: 1. Arguments are pushed onto the argument stack using WITH 2. The function is invoked with ORDER or PREP 3. Inside the function, INGREDIENT declarations pop arguments in order 4. Registers not declared as INGREDIENT maintain their values from the caller (but changes don't propagate back)

Call Stack

LLvlN++ maintains a separate call stack from the data stack:

• Each function call creates a new stack frame
• Registers are saved and restored automatically
• The data stack (used by BAKE, CHOP, etc.) is shared across all frames
• Maximum recursion depth is implementation-defined (recommended minimum: 1000)

Object System

Classes in LLvlN++ follow the cooking metaphor:

• Classes are "KITCHEN" environments where methods ("COOKBOOK" recipes) operate
• Member variables are "CHEF" ingredients that persist across method calls
• Object instances represent individual kitchen setups
• Inheritance is supported through "APPRENTICE" relationships

Asynchronous Model

Asynchronous operations use kitchen timing metaphors:

• "MICROWAVE" starts non-blocking operations
• "TIMER" blocks until completion
• "READY" checks completion status
• Multiple async operations can run concurrently

Syntax Changes

The main program must still start with RECIPE and end with DONE. Function and class definitions can appear:

• Before RECIPE (recommended)
• After DONE
• Between RECIPE and DONE (execution skips over them)

Function and class names follow the same rules as labels but cannot conflict with each other.

Example Syntax

KITCHEN Counter
    CHEF ingredients
    COOKBOOK increment
        INGREDIENT amount
        ADD ingredients amount
        PLATE ingredients
    PLATED
CLOSED

MENU DOUBLE
    INGREDIENT SOUP    # SOUP is the parameter
    ADD SOUP SOUP      # Double it
    PLATE SOUP         # Return the value
PLATED

RECIPE
    NEW Counter MEAT
    SET CAKE 5
    WITH CAKE
    CALL MEAT.increment
    
    WITH CAKE          # Pass CAKE as argument
    MICROWAVE DOUBLE   # Start async call
    TIMER FISH         # Wait for result in FISH
    SERVE FISH         # Output: 10
DONE

Computational Class

LLvlN++ remains Turing complete, as it includes all capabilities of the base LLvlN language. The addition of functions, procedures, objects, and async operations does not increase the computational power but provides better abstraction, code organization, and modern programming paradigms.

Examples

Factorial (Recursive)

MENU FACTORIAL
    INGREDIENT SOUP           # n is the parameter
    SET CAKE 1
    CMP SOUP CAKE
    BLAND BEAN BASE_CASE      # If n <= 1, return 1
    
    # Recursive case: n * factorial(n-1)
    COPY MEAT SOUP            # Save n
    SET CAKE 1
    SUB SOUP CAKE             # n-1
    WITH SOUP                 # Pass n-1 as argument
    PREP SOUP FACTORIAL       # factorial(n-1)
    MUL SOUP MEAT             # n * factorial(n-1)
    PLATE SOUP
    
BASE_CASE:
    SET SOUP 1
    PLATE SOUP
PLATED

RECIPE
    TASTE RICE                # Read number
    WITH RICE
    PREP MEAT FACTORIAL
    SERVE MEAT                # Output factorial
DONE

Counter Class (OOP Example)

KITCHEN Counter
    CHEF value               # Member variable
    
    COOKBOOK init
        INGREDIENT start_val
        SET value start_val
        PLATE
    PLATED
    
    COOKBOOK increment
        INGREDIENT amount
        ADD value amount
        PLATE value
    PLATED
    
    COOKBOOK get_value
        PLATE value
    PLATED
CLOSED

RECIPE
    NEW Counter SOUP         # Create counter instance
    SET CAKE 10
    WITH CAKE
    CALL SOUP.init           # Initialize with 10
    
    SET MEAT 5
    WITH MEAT
    CALL SOUP.increment      # Increment by 5
    
    CALL SOUP.get_value
    SERVE SOUP               # Output: 15
DONE

Async File Processing

MENU PROCESS_FILE
    INGREDIENT filename
    # Simulate file processing
    SET SOUP 1000
    SALT DELAY_LOOP
    PLATE filename
    
DELAY_LOOP:
    SUB SOUP 1
    BLAND SOUP DONE
    SALT DELAY_LOOP
DONE:
    PLATE filename
PLATED

RECIPE
    SET CAKE 1               # file1.txt
    SET MEAT 2               # file2.txt
    SET FISH 3               # file3.txt
    
    # Start async processing
    WITH CAKE
    MICROWAVE PROCESS_FILE   # Returns async_id in CAKE
    
    WITH MEAT
    MICROWAVE PROCESS_FILE   # Returns async_id in MEAT
    
    WITH FISH
    MICROWAVE PROCESS_FILE   # Returns async_id in FISH
    
    # Wait for all to complete
    TIMER CAKE               # Wait for first
    TIMER MEAT               # Wait for second
    TIMER FISH               # Wait for third
    
    SERVE CAKE
    SERVE MEAT
    SERVE FISH
DONE

Print Array (Procedure Example)

DISH PRINT_ARRAY
    INGREDIENT SOUP           # Array length (on stack below)
    
PRINT_LOOP:
    BLAND SOUP PRINT_END      # If length == 0, done
    CHOP CAKE                 # Pop value from stack
    SERVE CAKE                # Print it
    SET MEAT 10
    SERVE MEAT CHAR           # Print newline
    SET MEAT 1
    SUB SOUP MEAT             # Decrement length
    SALT PRINT_LOOP
    
PRINT_END:
    PLATE                     # Return (no value)
PLATED

RECIPE
    # Push some values
    SET SOUP 10
    BAKE SOUP
    SET SOUP 20
    BAKE SOUP
    SET SOUP 30
    BAKE SOUP
    
    SET CAKE 3                # Array length
    WITH CAKE
    ORDER PRINT_ARRAY         # Call procedure
DONE

Power Function

MENU POWER
    INGREDIENT SOUP           # base
    INGREDIENT CAKE           # exponent
    
    BLAND CAKE POW_ZERO       # If exponent == 0
    
    SET MEAT 1                # result = 1
    
POW_LOOP:
    BLAND CAKE POW_DONE       # If exponent == 0, done
    MUL MEAT SOUP             # result *= base
    SET FISH 1
    SUB CAKE FISH             # exponent--
    SALT POW_LOOP
    
POW_DONE:
    PLATE MEAT                # Return result
    
POW_ZERO:
    SET SOUP 1
    PLATE SOUP
PLATED

RECIPE
    TASTE SOUP                # Read base
    TASTE CAKE                # Read exponent
    WITH SOUP
    WITH CAKE
    PREP MEAT POWER
    SERVE MEAT
DONE

Implementation Notes

Call Stack Management

An implementation must maintain:

• A call stack with frames containing:
  • Return address (instruction pointer)
  • Saved register values
  • Function/procedure name (for debugging)
• An argument stack (separate from data stack) for parameter passing
• A return value register (implementation detail)

Object System Implementation

The object system requires:

• Object heap for instance storage
• Method dispatch tables for each class
• Member variable access tracking
• Garbage collection (recommended)

Asynchronous System Implementation

Async operations require:

• Thread pool or event loop
• Async operation tracking
• Result storage and retrieval
• Timeout handling

Register Scoping

When a function is called: 1. All 8 registers are saved to the call stack 2. Arguments are popped from argument stack into registers as specified by INGREDIENT 3. Other registers start with undefined values (recommended: 0) 4. On return, all registers are restored to their pre-call values 5. If PREP was used, the return value overwrites the specified register after restoration

Optimization Opportunities

• Tail call optimization for recursive functions
• Inline expansion of small functions
• Register allocation across function boundaries
• Argument passing via registers instead of argument stack
• Method inlining for objects
• Async operation batching

Error Conditions

Implementations should detect:

• Stack overflow (too many nested calls)
• Calling undefined functions or methods
• Argument count mismatch (recommended, not required)
• PLATE outside of function context
• INGREDIENT outside of function definition
• Duplicate function/class names
• Invalid object access
• Async operation timeouts

Differences from LLvlN

Feature	LLvlN	LLvlN++
Functions	Not supported	MENU/DISH definitions
Procedures	Not supported	DISH definitions
Parameter passing	Not supported	WITH/INGREDIENT
Return values	Not supported	PLATE
Call stack	Only data stack	Separate call stack with frames
Recursion	Not supported	Fully supported
Code organization	Linear with labels	Modular with functions
Register scoping	Global only	Local to function calls
Object-oriented	Not supported	KITCHEN classes with methods
Asynchronous	Not supported	MICROWAVE/TIMER async operations
Backward compatibility	N/A	All LLvlN programs valid

See Also

• LLvlN - The base language
• Chef - Another cooking-themed esoteric language
• FALSE - Stack-based language with procedures
• Assembly language - The structural inspiration
• Subleq - Minimalist instruction set with function-like behavior
• Smalltalk - Object-oriented programming inspiration
• Erlang - Asynchronous programming model inspiration

External Resources

• Contributions welcome on the Esolang wiki