The MEOW
Language

Introduction

MEOW is a dynamically-typed, interpreted programming language designed entirely around cat behavior and vocabulary. Every keyword, construct, and concept maps to something a cat would do — because all great languages start with a 🐱.

Version 2 adds dictionaries (den), string interpolation (${...}), user input (ask()), file operations, import, and many new built-in functions.

Language Features

• Dynamic typing — No type declarations, just like a cat ignoring rules
• First-class functions — Define and call with claw
• Closures — Functions capture their environment (like a cat in a box)
• Arrays (Litters) — Ordered collections
• Dictionaries (Dens) — Key-value stores v2
• String interpolation — Embed expressions with ${...} v2
• User input — Read from console with ask() v2
• Import system — Share code across tabs with import v2
• File operations — read_file() / write_file() v2
• 25+ built-in functions — Math, strings, arrays, dicts
• Rich control flow — Conditionals, two loop types, break/continue

Quick Start

Write your first MEOW program. Open the IDE and type:

# My first MEOW program
meow "Hello, World! 🐱"

purr name = "Whiskers"
meow "My cat's name is: " + name

purr lives = 9
meow "${name} has ${lives} lives"

Syntax Overview

MEOW has a clean, block-based syntax. Blocks are delimited by { }. There are no semicolons. Comments start with #.

.meow# This is a comment

purr x = 42           # variable declaration
meow x               # print output

psspss (x > 10) {      # if block
  meow "big number: ${x}"
}

File Extension

MEOW source files use the .meow extension. The IDE supports multiple open files and import between them.

Comments

# This is a single-line comment
meow "Hello" # Comments can follow code

Variables

Variables are declared using the purr keyword. Once declared, they can be reassigned without a keyword. MEOW also supports += and ++ / -- shorthand. v2

.meowpurr x = 10
purr name = "Luna"
purr isHungry = pawsitive
purr nothing = nap

# Reassignment
x = 20
x += 5         # x is now 25

# Compound assignment
name = name + " the cat"

meow x
meow name

Types

MEOW is dynamically typed. There are six value types:

Truthiness

Falsy values: clawful, nap, 0, "". Everything else is truthy.

Type Checking

meow sniff(42)          # → "number"
meow sniff("hello")     # → "string"
meow sniff(pawsitive)  # → "bool"
meow sniff(litter [])  # → "array"
meow sniff(den {})     # → "dict"

Operators

Arithmetic

Logical Operators

String Concatenation

The + operator concatenates strings. Prefer string interpolation for embedded values — see the Strings section.

meow "Hello " + "World"       # → "Hello World"
meow "Count: " + 42           # → "Count: 42"

Operator Precedence

Highest to lowest: not, - (unary), * / %, + -, < > <= >=, == !=, and, or.

Strings & Interpolation v2

Strings are enclosed in double "..." or single '...' quotes. Escape sequences: \n (newline), \t (tab), \\ (backslash).

String Interpolation

Embed any expression directly inside a string using ${expr}. This is the recommended way to compose strings with variable values.

purr name = "Luna"
purr age  = 3
purr score = 9.5

meow "My cat ${name} is ${age} years old!"
meow "Score: ${score * 10}/100"
meow "Next year she'll be ${age + 1}"

String Built-ins

purr s = "Hello, Whiskers!"
meow fur(s)            # → 16 (length)
meow meow_upper(s)     # → "HELLO, WHISKERS!"
meow meow_lower(s)     # → "hello, whiskers!"

purr parts = scratch_split(s, ", ")
meow parts[0]          # → "Hello"
meow parts[1]          # → "Whiskers!"

Control Flow

psspss — If Statement

.meowpsspss (condition) {
  # runs if truthy
}

psspss (x > 10) {
  meow "big"
} else {
  meow "small"
}

else if Chaining

purr score = 85
psspss (score >= 90) {
  meow "Grade A — Magnificent cat! 😻"
} else psspss (score >= 70) {
  meow "Grade B — Pretty good kitty 😸"
} else {
  meow "Needs more napping... 😾"
}

Loops

stalk — While Loop

.meowpurr i = 0
stalk (i < 5) {
  meow "Stalking step ${i}"
  i = i + 1
}

pounce — For Range Loop

pounce (i from 1 to 5) {
  meow "Pounce #${i}"
}

scratch — Break  |  knead — Continue

# Print only odd numbers 1–10
pounce (i from 1 to 10) {
  psspss (i % 2 == 0) { knead }
  meow whisker(i)
}

Functions

Functions are defined with claw and return values with paw.

.meowclaw functionName(param1, param2) {
  paw result
}
purr result = functionName(a, b)

claw greet(name, title) {
  paw "Hello, ${title} ${name}! 🐱"
}

claw power(base, exp) {
  purr result = 1
  pounce (i from 1 to exp) {
    result = result * base
  }
  paw result
}

meow greet("Whiskers", "Dr.")
meow "2^10 = ${power(2, 10)}"

Recursion

claw fib(n) {
  psspss (n <= 1) { paw n }
  paw fib(n - 1) + fib(n - 2)
}
meow "fib(10) = ${fib(10)}"  # → 55

Arrays (Litters)

Arrays are created with the litter [...] syntax. Indexed from zero.

.meowpurr cats = litter ["Whiskers", "Luna", "Shadow"]
meow cats[0]   # → "Whiskers"
meow cats[2]   # → "Shadow"

Array Operations

purr cats = litter ["Pixel", "Luna", "Biscuit"]
meow "Count: ${fur(cats)}"
chase(cats, "Mochi")
meow "All: ${nuzzle(cats, ", ")}"

purr scores = litter [99, 41, 72, 55]
meow "Sorted: ${nuzzle(sort(scores), " < ")}"
meow "Max: ${max(scores)}  Min: ${min(scores)}"

Dictionaries (Dens) v2

Dictionaries are key-value stores created with the den { ... } syntax. Keys are strings; values can be any type, including nested dicts or arrays.

.meowpurr cat = den {
  "name": "Luna",
  "age":  3,
  "purring": pawsitive
}

# Read a key
meow cat["name"]      # → "Luna"

# Write / update a key
cat["age"] = 4
meow cat["age"]       # → 4

Dict Operations

purr cat = den { "name": "Luna", "age": 3, "color": "silver" }
meow "Name: ${cat["name"]}"
cat["age"] = 4
meow "Updated age: ${cat["age"]}"
meow "Has color? ${has(cat, "color")}"
meow "Keys: ${nuzzle(keys(cat), ", ")}"
del_key(cat, "color")
meow "After delete: ${nuzzle(keys(cat), ", ")}"

Nested Dicts

purr zoo = den {
  "cat":  den { "sound": "meow", "legs": 4 },
  "bird": den { "sound": "tweet", "legs": 2 }
}
meow zoo["cat"]["sound"]   # → "meow"
meow zoo["bird"]["legs"]  # → 2

User Input v2

The ask(prompt) built-in displays a prompt and returns the user's input as a string. Use paw_num() to convert to a number if needed.

.meowpurr name = ask("What is your cat's name? ")
meow "Hello, ${name}! 🐱"

purr rawAge = ask("Cat's age? ")
purr age    = paw_num(rawAge)
meow "In human years that's ${age * 7}"

Import v2

The import "filename" statement runs another open tab's code in the current scope, making its functions and variables available. The .meow extension is optional.

.meow# In utils.meow:
claw square(n) { paw n * n }

# In main.meow:
import "utils"
meow whisker(square(7))   # → 49

File Operations v2

MEOW's file built-ins let your program read from and write to IDE tabs as if they were files.

.meow# Write content to a new tab called "log.txt"
purr log = ""
pounce (i from 1 to 5) {
  log = log + "Entry ${i}: item_${i}\n"
}
write_file("log.txt", log)
meow "Written! Open log.txt to see it."

# Read it back
purr content = read_file("log.txt")
meow content

GUI Programming v2.1.2

MEOW v2.1.2 introduces a built-in GUI Engine that allows you to create interactive visual programs. In the MEOW IDE, these programs appear in a floating, draggable overlay.

Layout & Nesting

MEOW uses a "Container Stack" for layouts. By default, elements are added vertically. Use gui_row() and gui_column() to create complex grids.

# A horizontal toolbar with a spacer pushing buttons apart
gui_row()
  gui_button("Save", "saveFn")
  gui_spacer()
  gui_button("Exit", "exitFn")
gui_end()

Visual Components

Use these built-ins to add interactivity and media to your programs.

Interactive State

Callbacks in MEOW are powerful. When a user clicks a gui_button, the IDE executes the named claw function using the environment from the last successful "Run".

purr count = 0
claw clk() {
  count = count + 1
  gui_clear()
  gui_label("Clicks: ${count}")
  gui_button("Click Me!", "clk")
}
gui_button("Start Counter", "clk")

Styling Elements

Customize the look of your GUI elements on the fly.

• gui_set_color(hex) — Sets text color for next elements.
• gui_set_padding(px) — Sets padding for the active layout container.
• gui_set_id(id) — Assigns a CSS ID to the very next element created.

All Keywords

Built-in Functions

MEOW provides 25+ built-in functions, all with cat-themed names. Never need to import — always available.

Core

Arrays

Dictionaries v2

Math

Strings

File Operations v2

GUI Engine v2.1.2

Math Examples

meow whisker(kibble(3.7))       # → "3"
meow whisker(treat(3.5))        # → "4"
meow whisker(pounce_sqrt(16))   # → "4"
meow whisker(abs(-42))          # → "42"
meow whisker(pow(2, 8))          # → "256"
meow whisker(catnap(100))       # → random 0–99

Grammar (EBNF)

The formal grammar of MEOW v2, in Extended Backus-Naur Form:

Errors

Example Programs

FizzBuzz

pounce (i from 1 to 20) {
  psspss (i % 15 == 0) { meow "PurrBuzz 🐱"
  } else psspss (i % 3 == 0) { meow "Purr 🐾"
  } else psspss (i % 5 == 0) { meow "Buzz 🐟"
  } else { meow whisker(i) }
}

Cat Profile — using Dicts & Interpolation

purr cat = den {
  "name":  "Luna",
  "age":   3,
  "color": "silver",
  "score": 9.8
}

meow "=== Cat Profile ==="
purr ks = keys(cat)
pounce (i from 0 to fur(ks) - 1) {
  purr k = ks[i]
  meow "  ${k}: ${cat[k]}"
}
cat["age"] = cat["age"] + 1
meow "Happy birthday ${cat["name"]}! Now ${cat["age"]} years old 🎂"

Bubble Sort

.meowclaw bubbleSort(arr, n) {
  pounce (i from 0 to n - 2) {
    pounce (j from 0 to n - i - 2) {
      psspss (arr[j] > arr[j + 1]) {
        purr tmp = arr[j]
        arr[j] = arr[j + 1]
        arr[j + 1] = tmp
      }
    }
  }
}

purr data = litter [64, 34, 25, 12, 22, 11]
bubbleSort(data, 6)
meow nuzzle(data, " → ")

Common Patterns

purr sum = 0
pounce (i from 1 to 100) {
  sum = sum + i
}
meow "Sum 1–100 = ${sum}"  # → 5050

purr stats = den { "wins": 12, "losses": 3, "draws": 5 }
purr ks = keys(stats)
pounce (i from 0 to fur(ks) - 1) {
  purr k = ks[i]
  meow "${k}: ${stats[k]}"
}

# helpers.meow
claw clamp(val, lo, hi) {
  psspss (val < lo) { paw lo }
  psspss (val > hi) { paw hi }
  paw val
}

# main.meow
import "helpers"
meow whisker(clamp(150, 0, 100))  # → 100
meow whisker(clamp(-5, 0, 100))   # → 0

purr catName = "Whiskers"
purr health = 85

claw draw() {
  gui_clear()
  gui_row()
    gui_set_color("#FF8C42")
    gui_label("🐾 CAT PROFILE")
  gui_end()
  gui_image("https://placekitten.com/400/200")
  gui_row()
    gui_label("Name: ")
    gui_input("Name...", "catName")
  gui_end()
  gui_label("Health: ${health}%")
  gui_slider(0, 100, "health")
}
draw()