LLvlN-mini

This page should be deleted for the following reason: Requested by the creator: variant not needed

LLvlN-mini is a minimalist variant of LLvlN (Low-Level Nonsense), an esoteric programming language created in 2025 by Comet AI Browser. It reduces the parent language to its essential core, maintaining Turing completeness while featuring only the most necessary instructions. This variant is ideal for code golf challenges and learning the fundamentals of stack-based programming.

Overview

LLvlN-mini strips away the complexity of the full LLvlN language, retaining only 4 registers (down from 8) and a carefully selected subset of instructions that preserve computational completeness. The language maintains the food-themed register names and cooking metaphors that make LLvlN distinctive, while making programs more concise and easier to reason about. Key features:

• 4 food-themed registers (SOUP, CAKE, MEAT, FISH)
• Minimal instruction set (12 instructions total)
• Stack-based operations with cooking terminology
• Turing complete
• Compatible subset of full LLvlN syntax
• Case-insensitive instructions

Language Specification

Registers

LLvlN-mini provides only 4 general-purpose registers:

• SOUP - Primary accumulator register
• CAKE - Secondary computation register
• MEAT - Auxiliary register for complex operations
• FISH - General-purpose register

All registers are initialized to 0 at program start and hold signed integers (typically 32-bit or 64-bit).

Instructions

Program Structure

• RECIPE - Marks the beginning of a program (must be first instruction)
• DONE - Marks the end of a program (terminates execution)

Data Movement

• SET <value> - Sets a register to a literal value
• COPY <source> - Copies value from source register to destination register

Arithmetic Operations

• ADD <source> - Adds source register to destination register
• SUB <source> - Subtracts source register from destination register

Stack Operations

• BAKE <register> - Pushes register value onto the stack
• CHOP <register> - Pops top value from stack into register

Input/Output

• SERVE <register> - Outputs the value in register as a number
• TASTE <register> - Reads a number from input into register

Control Flow

• SALT <label> - Unconditional jump to label
• SPICE <label> - Conditional jump: jumps to label if register is non-zero

Syntax Rules

• Instructions are case-insensitive
• One instruction per line
• Comments begin with # and extend to end of line
• Labels are alphanumeric identifiers followed by a colon
• Whitespace between tokens is flexible
• Empty lines are ignored

Computational Class

LLvlN-mini is Turing complete despite its minimalist design. The language provides:

• Unbounded memory (through the stack)
• Conditional branching (SPICE instruction)
• Potentially-infinite looping (SALT instruction)
• Arithmetic operations (ADD, SUB)
• Data movement between registers and stack

A Minsky machine can be implemented in LLvlN-mini, proving its computational completeness.

Examples

Hello, World!

RECIPE
# Print "Hi!"
SET SOUP 72      # H
SERVE SOUP
SET SOUP 105     # i
SERVE SOUP
SET SOUP 33      # !
SERVE SOUP
DONE

Truth Machine

RECIPE
# Read input and output 1 forever if 1, or output 0 once if 0
TASTE SOUP       # Read input
SERVE SOUP       # Output the number
SPICE SOUP LOOP  # If non-zero, jump to LOOP
DONE             # If zero, end

LOOP:
SERVE SOUP       # Output the number
SALT LOOP        # Infinite loop

Counter Program

RECIPE
# Count from 1 to 10
SET SOUP 1
SET CAKE 10

COUNT:
SERVE SOUP       # Output current number
SET MEAT 1
ADD SOUP MEAT    # Increment counter
SUB CAKE MEAT    # Decrement limit
SPICE CAKE COUNT # Continue if limit > 0

DONE

Addition Calculator

RECIPE
# Read two numbers and output their sum
TASTE SOUP       # Read first number
TASTE CAKE       # Read second number
ADD SOUP CAKE    # Add them
SERVE SOUP       # Output result
DONE

Implementation Notes

Memory Model

An implementation must provide:

• 4 registers (signed integers)
• An unbounded stack (or as large as memory permits)
• Standard input/output streams for numbers

Error Handling

Implementations should handle:

• Stack underflow (terminate with error)
• Invalid labels (compile-time error)
• Invalid register names (compile-time error)
• Division by zero not applicable (no division instruction)

Differences from Full LLvlN

LLvlN-mini removes:

• 4 registers (RICE, BEAN, NUTS, MILK)
• Multiplication and division (MUL, DIV, MOD)
• Character I/O (CHAR modifier)
• Advanced stack operations (BOIL, DICE, FLIP, STIR)
• Comparison instruction (CMP)
• Zero-conditional jump (BLAND)

Compatibility

All valid LLvlN-mini programs are valid LLvlN programs. However, LLvlN programs using removed features will not run on LLvlN-mini.

See Also

• LLvlN - The parent language
• Chef - Another cooking-themed esoteric language
• Brainfuck - A famous minimalist language
• Stack-based - Category of stack-based languages

External Resources

• LLvlN-mini is a variant of LLvlN
• Compatible with LLvlN interpreters (subset functionality)