We are currently working on new rules for what content should and shouldn't be allowed on this website, and are looking for feedback! See Esolang:2026 topicality proposal to view and give feedback on the current draft.

Meowlang

From Esolang
Jump to navigation Jump to search
Not to be confused with Meow (Martsadas), nor Meow (None1).

Meowlang is an esoteric programming language where every program speaks exclusively in cat. Instead of keywords or symbols, the entire source code consists of one sound: the meow. Each element is written as a run of Meow tokens — the more meows, the higher the opcode — making Meowlang perhaps the only Turing-complete language whose source code is also a valid feline monologue. As of version 0.4.0, a Meowlang program can read keyboard input, print arbitrary text, sleep, and clear the screen, putting full interactive programs within reach of any sufficiently patient cat.

The language was inspired by Chicken. User:Wixette designed Meowlang's instruction set and open-sourced the JavaScript interpreter.

Examples

Hello, World!

The following program prints Hello, World! using the YOWL instruction (opcode 10), which pops the tail value and prints the corresponding ASCII character. Each character's code is loaded with PUSH (opcode 2) and immediately printed with YOWL. Here are the first two instructions — PUSH 'H' then YOWL — in the standard .meow token format, where every number is simply a run of Meow tokens followed by a semicolon: 

MeowMeow;
MeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeow;
MeowMeowMeowMeowMeowMeowMeowMeowMeowMeow;
MeowMeow;
MeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeow;
MeowMeowMeowMeowMeowMeowMeowMeowMeowMeow;

(the pattern repeats for each of the remaining 11 characters)

Each run of Meow tokens is simply a number. The same program in the simplified .smeow format makes the numeric values explicit: 

2    // PUSH
72   // 'H' = 72
10   // YOWL
2    // PUSH
101  // 'e' = 101
10   // YOWL
2    // PUSH
108  // 'l' = 108
10   // YOWL
2    // PUSH
108  // 'l' = 108
10   // YOWL
2    // PUSH
111  // 'o' = 111
10   // YOWL
2    // PUSH
44   // ',' = 44
10   // YOWL
2    // PUSH
32   // ' ' = 32
10   // YOWL
2    // PUSH
87   // 'W' = 87
10   // YOWL
2    // PUSH
111  // 'o' = 111
10   // YOWL
2    // PUSH
114  // 'r' = 114
10   // YOWL
2    // PUSH
108  // 'l' = 108
10   // YOWL
2    // PUSH
100  // 'd' = 100
10   // YOWL
2    // PUSH
33   // '!' = 33
10   // YOWL
0    // RET

Output: 

Hello, World!

Echo

A real-time character echo loop using SNIFF (opcode 11) and YOWL (opcode 10). SNIFF reads one character from standard input and pushes its ASCII code; YOWL pops and prints it back. The loop exits when SNIFF receives a zero (end of input, e.g. Ctrl+D in a terminal). 

11 // [0] SNIFF — read one character from stdin
9  // [1] JE
6  // [2] → jump to index 6 if input is 0 (end of input)
10 // [3] YOWL  — echo the character
8  // [4] JMP
0  // [5] → back to index 0
0  // [6] RET   — final newline

Fibonacci

A Meowlang program to print the Fibonacci numbers: 

MeowMeowMeowMeowMeowMeowMeowMeow;
MeowMeowMeowMeow;
Meow;
Meow;
MeowMeow;
MeowMeowMeowMeowMeowMeowMeowMeowMeowMeow;
MeowMeowMeowMeow;
MeowMeow;
Meow;
;
MeowMeowMeow;
MeowMeowMeowMeow;
MeowMeow;
MeowMeowMeowMeow;
MeowMeowMeow;
MeowMeowMeowMeowMeowMeow;
MeowMeowMeowMeow;
MeowMeowMeow;
MeowMeowMeowMeowMeow;
MeowMeow;
MeowMeowMeow;
MeowMeowMeowMeowMeow;
MeowMeowMeow;
MeowMeowMeow;
MeowMeow;
Meow;
MeowMeowMeowMeowMeowMeowMeow;
MeowMeowMeowMeowMeowMeowMeowMeowMeow;
MeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeowMeow;
MeowMeowMeowMeowMeowMeowMeowMeow;
MeowMeowMeowMeowMeowMeow;
MeowMeowMeow;
MeowMeowMeowMeowMeowMeowMeowMeowMeowMeow;

The output of the Fibonacci program: 

🐈
🐈
🐈🐈
🐈🐈🐈
🐈🐈🐈🐈🐈
🐈🐈🐈🐈🐈🐈🐈🐈
🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈
🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈
🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈
🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈🐈

Language Specification

Meow List

A valid Meowlang program is a text representation of a Meow List.

A Meow List is a sequence of Meow elements.

Every Meow element contains zero or more Meow tokens. The number of Meow tokens in a Meow element corresponds to a non-negative integer value, which is the value of the Meow element.

A Meow element can be treated either as a Meow instruction or a Meow operand, depending on the execution context:

  • When a Meow element is treated as a Meow instruction, the value of the element is the opcode of the instruction.
  • When a Meow element is treated as a Meow operand, the operand value is the value of the element.

In the Meowlang runtime, the loaded Meow List is a read/write list, which is both the sequence of instructions to execute and the only in-memory data structure that instructions can access.

In other words, code is data and data is code.

Meow Tokens

A Meow token is a cat cry written in plain text. The following Meow tokens are valid and interchangeable in Meowlang programs:

  • Meow in English (also Miaow and Meaw)
  • Miaou in French
  • 喵 in Chinese
  • Miao in Chinese Pinyin
  • Miau in German
  • ニャー in Japanese Katakana
  • Мяу in Russian

Meow tokens are case-insensitive. For example, Meow, meow, and MEOW are all the same token. Tokens from different languages can be mixed freely within a single program.

Meow File Format

The text representation of a Meowlang program uses the semicolon ; to end every Meow element. The Chinese fullwidth semicolon ； is also accepted as an equivalent separator.

For example, the following code contains 5 Meow elements whose values are 0, 1, 2, 3, and 4: 

;
Meow;
Meow Meow;
Meow Meow Meow;
Meow Meow Meow Meow;

White spaces (space, tab, newline) are used for formatting only and are ignored during execution. You may lay out your code in many creative ways. For example: 

; M e o w ; MeowMeow ; MeowMeowMeow ; MeowMeowMeowMeow ;

Tokens from different languages can be mixed in the same element. For example: 

;
喵;
Meow Miao;
Miaou Miaou Miaou;
Miaou 喵 Meow Miao;

The preferred file extension for the Meow format is .meow.

Simplified Meow File Format

A Meow program can also be stored as a sequence of non-negative integers, one per line, each corresponding to the value of a Meow element: 

0
1
2
3
4

Line comments starting with // are supported in this format: 

11 // SNIFF
9  // JE
6  // → jump to index 6

The preferred file extension for the simplified format is .smeow.

Meow Instruction Set

Opcode Name Cat Behavior Description IP Operation
0 RET Print an empty line ("\n") to the output. IP++
1 MEOW Print T cat emoji characters to the output. IP++
2 PUSH Push N to the tail of the Meow List. IP += 2
3 POP Pop the tail element from the Meow List. IP++
4 LOAD Push the value of E(N) to the tail of the Meow List. IP += 2
5 SAVE Copy the tail value into E(N). The tail is not popped. IP += 2
6 ADD Pop the last two tail elements, push their sum. IP++
7 SUB Pop the last two tail elements, push (second-to-last − last). If the result would be negative, push zero instead. IP++
8 JMP Set IP to N. IP = N
9 JE If the tail value is zero, set IP to N; otherwise skip the operand and continue. IP = (T == 0) ? N : IP + 2
10 YOWL A loud sound directed at humans. ASCII Output: Pop the tail value and print the corresponding ASCII character. IP++
11 SNIFF Detecting a scent from the environment. ASCII Input: Read one character from standard input and push its ASCII code to the tail. Pushes 0 on EOF. IP++
12 NAP A cat's rest. Sleep: Pop the tail value and pause execution for that many milliseconds. IP++
13 SCRATCH Cleaning the territory. Clear Screen: Clear the output console or screen. IP++
≥14 NOP No operation. IP++
  • IP: The Instruction Pointer.
  • T: The value of the tail element.
  • N: The value of the next element (the operand).
  • E(N): The element at index N in the Meow List.

Interpreters

Retrieved from "https://esolangs.org/w/index.php?title=Meowlang&oldid=183622"