Irma

"We find our limits when we go past them."

Introduction

Original logo of Irma, circa 2025. Made by Irma's creator, Nicholas.

Irma-Arnold

Paradigm(s)	Functional
Designed by	User:Neon
Appeared in	2025
Computational class	Turing complete
Major implementations	none
File extension(s)	.rirma .cirma

Irma is a low-level functional esoteric programming language which uses only 1 character to build code, with the exception of /n (new line). It was made in November 2025 by User:Neon. The language is named after the Category 5 hurricane that struck parts of the Caribbean and Florida Keys in 2017, which the author experienced as a child. It is recommended to learn the ASCII integers of all printable characters or have a cheat sheet handy. The current and only version of Irma currently available is Irma Arnold. New versions are planned in the future. A compiler is in development by User:Neon.

Author's note

"Raw string" refers to the composition zeros as ASCII integers creating a string. "String" refers to the characters defined by a composition of zeros as ASCII integers. The "map" is the set of instructions used by the compiler to find a position in the registry. An "integer" refers to an actual whole number, while "integer code" refers to the ASCII value for a specific character. The author begs the community to not change anything about the language until he removes the Works-in-Progress category from the page.

Compilation

Irma programs have 4 formats.

• [Raw IRMA] file format: files with the extension .rirma which consist of the code programmers can read and write. These are practically identical to .txt files but are used to differentiate themselves from other non-irma files. It is generally most comfortable to use .irma files to write and read Irma.

• [Compressed IRMA] file format: files with the extension .cirma, whose boolean data is visually identical to that of .bin or .exe files. It can't be run, although it does store program data using less memory than a .irma file. It is possible to read and write Irma in .cirma files, though the readability is arguably worse. The key difference is that new lines are represented with 1. Zeros represent themselves. This file can not be compiled in the same way as a .irma file and requires a different compiler.

• [IRMA Extension] file format: files with the extension .irmae dedicated to acting like a library.

• Compiled file format: .exe files that can be run on the computer without a special interpreter but are very difficult to read and modify.

.irma and .cirma can be run on the computer with an interpreter, though this will be much slower than a compiled version.

Instruction set

Instruction	Description
	Empty line (VOID).
0	Declares an output.
00	Declares an input.
000	Registers/moves a register.
0000	Declares a function.
00000	Executes a function.
000000	Checks a condition.
0000000	Declares an arithmetic operation.
00000000	Finds index of a raw string
000000000	Jumps to a specific line in the code.
0000000000	Imports a library.

Any other sequence length of zeros will lead to an illegal instruction error. NULL consists of 10 zeros(equivalent to import file instruction) and is similar to VOID when used in arguments. VOID is used as a placeholder for some unused or unapplicable arguments and is used 3 times in a row to terminate an ASCII character raw string. NULL is used to terminate maps or pure integer raw strings.

Character Set

Irma uses ASCII encoding for it's characters. It reads 3 lines containing x, y and z amounts of 0. The x, y and z are the first, second and third digits of the integer code between 0 and 127 stored as a 7-bit integer to represent a specific character.

For example, in order to define a right-facing curly brace:{, which has the ASCII integer code of 123:

0
00
000

This would be used as an argument for an instruction such as output (0). Argument structure may differ between different instructions.

The next 2 lines can be used for other code. If an integer code consists of a 2-digit number, such as 24, then this number must be converted to a 3-digit number, such as 024. Irma always reads 3 lines at a time.

Alternatively, if a single integer needs to be stored, the programmer can use a different type of encoding for a pure integer. The separate digits of a number can be stored as it's equivalent in an amount of zeros for each digit in 1 line. To store 24, the following raw string will be stored in the register:

00
0000

This is a pure integer and won't be interpreted correctly as an ASCII integer.

0000000000(NULL) is used to terminate a raw string for both pure integers and ASCII characters. It is used in the first of the 3 lines defining a new character in a raw string. After NULL, other instructions can be written. NULL isn't stored in the registry but is used to show the compiler where the raw string stops and the rest of the code continues.

Memory Management

Memory in Irma is pointer-based. The registry is 2-dimensional. There are 2 axes in the register grid. The pointer is initialized to position 0,0 in the grid pointing in the NORTH direction. It can only be moved forwards 1 square using 00, turned 90 degrees to the left using 0000 and turned 90 degrees to the right using 000000. These two instructions can be combined in a specific sequence to provide a map for the compiler to find a specific address.

In order to point the pointer to xy position 3,3 when starting from 0,0 NORTH, the following code can be used:

00      (forward)
00      (forward)
00      (forward)
000000  (right)
00      (forward)
00      (forward)
00      (forward)

In this code, the pointer moves NORTH 3 times before turning 90 degrees to the right and moving forward a further 3 times EAST. Now, the pointer is facing EAST at 3,3. A raw string can now be assigned to this point.

Comments

Compilers for Irma must only read 0s. All other characters can be used in the code and be ignored safely. A line full of non-zero characters will be interpreted as an empty line.

Outputting

There are 2 mandatory arguments used in an outputting instruction:

• Source determination.

0: Pre-determined, where the raw string being printed is defined in the code itself.

00: Variable-determined, where the raw string being printed is defined in a register.

• Source encoding.

0: The source is encoded as an ASCII integer code.

00: The source is encoded as a pure integer.

The structure for a pre-determined output:

[output declaration] [argument for pre-determined or register-determined output] [argument for printing the raw string or ASCII encoding character equivalent of the raw string]

[raw string]

The structure for a variable-determined output:

[output declaration]

[argument for printing the raw string, ASCII encoding character equivalent of the raw string or pure integer equivalent of raw string]

[argument for what part of the string gets printed]

[map for variable position in registry]

Printing "Hello, World!" (Pre-determined)

The comments here are for informational purposes only; they contain zeros which would break the code if actually used.

0            (output)
0            (argument for pre-determined output)
0            (source is made from ASCII integer codes)             
             (0 in 072 for letter H ASCII integer value)
0000000      (7 in 072 for letter H ASCII integer value)
00           (2 in 072 for letter H ASCII integer value)
0            (1 in 101 for letter e ASCII integer value)
             (0 in 101 for letter e ASCII integer value)
0            (1 in 101 for letter e ASCII integer value)
0            (1 in 108 for letter l ASCII integer value)
             (0 in 108 for letter l ASCII integer value)
000000000    (8 in 108 for letter l ASCII integer value)
0            (1 in 108 for letter l ASCII integer value)
             (0 in 108 for letter l ASCII integer value)
000000000    (8 in 108 for letter l ASCII integer value)
0            (1 in 111 for letter o ASCII integer value)
             (0 in 111 for letter o ASCII integer value)
000000000    (1 in 118 for letter o ASCII integer value)
             (0 in 044 for letter , ASCII integer value)
0000         (4 in 044 for letter , ASCII integer value)
0000         (4 in 044 for letter , ASCII integer value)
             (0 in 032 for letter SPACE ASCII integer value)
000          (3 in 032 for letter SPACE ASCII integer value)
00           (2 in 032 for letter SPACE ASCII integer value)
0            (0 in 119 for letter w ASCII integer value)
0            (4 in 119 for letter w ASCII integer value)
000000000    (0 in 119 for letter w ASCII integer value)
0            (1 in 111 for letter o ASCII integer value)
             (0 in 111 for letter o ASCII integer value)
000000000    (1 in 118 for letter o ASCII integer value)
0            (1 in 114 for letter r ASCII integer value)
0            (1 in 114 for letter r ASCII integer value)
0000         (4 in 114 for letter r ASCII integer value)
0            (1 in 108 for letter l ASCII integer value)
             (0 in 108 for letter l ASCII integer value)
000000000    (8 in 108 for letter l ASCII integer value)
0            (1 in 100 for letter d ASCII integer value)
             (0 in 100 for letter d ASCII integer value)
             (0 in 100 for letter d ASCII integer value)
0000000000   (NULL, end of instruction)

Printing "Hello, World!" (Variable-determined, raw string, all chars)

In this example, the string is stored in coordinate 2,4.

0            (output declaration)
00           (argument for variable-determined)
0            (argument for printing raw string from registry)
             (VOID, used for printing all available characters )
000000       (right)
00           (forward)
00           (forward)
0000         (left)
00           (forward)
00           (forward)
00           (forward)
00           (forward)
0000000000   (NULL, end of map)

To print the ASCII integer equivalent of the raw string, the third line would be replaced with 2 zeros. This only works if the stored raw string encodes a single integer. To print the ASCII character equivalent of the raw string, the third line would have 3 zeros. It can print integers as well, but only if they are encoded as a regular character.

To print all stored characters in a string, an empty line is used for the 3rd argument of an output. Otherwise, the amount of zeros in this line would determine the amount of characters printed starting from the first character, forwards. 000 as the third argument would print hel from a stored raw string of "hello".

Inputting

Using inputs in Irma with instruction 00 must be written with 2 arguments:

• Storing input as a raw string or as a non-ASCII integer.
• Map for storage register

00 in the first argument only functions properly if the input only contains integers. It stores a raw string, but in a different format that is not applicable to non-integer characters. 0 can store all integers, letters and special characters as a raw string in ASCII encoding with integer codes.

Ask for input and store as pure integer in -3, 1

00         (input instruction)
00         (store input as pure integer)
0000       (start of destination register map)
00 
0000
00
00
00
0000000000 (end of destination register map)

For an input of 369, the stored pure integer encoding in register -1,-3 would be:

000
000000
000000000

Otherwise, if the input of 369 would be stored as a raw string of ASCII integer encoding, register -1,-3 would store:

00000
0

00000
0000

00000
0000000

Registering Variables

To register a variable, 000 is used. The structure of this instruction is:

[variable registering declaration]

[argument for raw string source (pre or register-determined)]

[other arguments] If the source is pre-determined, the following arguments are:

[argument for register overwrite/append]

If the source is register-determined, the arguments following are:

[argument for register overwrite/append]

[argument for raw string transfer, what part of the string will be tranferred]

[argument for raw string deletion]

[argument for source map]

[argument for destination map]

[content]

Overwriting register 1,6 to "cat"

000
0           (tells the compiler that "cat" will be pre-defined)
0           (tells the compiler to overwrite the register)
            (VOID, only used for register transfer)
            (VOID, only used for register transfer)
            (VOID, there is no source register)
00          (start of map for destination register)
000000
00
00
00
00
00
00          
0000000000  (NULL, end of map for destination register)
            (start of content)
000000000 
000000000

000000000
0000000
0
0
000000      


            (NULL, end of content)

Append "hel" in "hello" in register -1,2 to register -2,-5 with deletion

000        (output declaration)
00         (tells the compiler that the content in the register)
00         (tells the compiler to append)
000        (tells the compiler to delete what is being moved)
00         (tells the compiler delete the first 3 characters in source registry)
0000       (beginning of source map)
00
00
0000
00
00
00
00
00
0000000000 (end of source map)
0000       (beginning of destination map)
00
0000
00
00
00
00
00
00
00        
0000000000 (NULL, end of destination map)
           (VOID, content already comes from register -2,-5)

Declaring a function

Declaring a function means defining a function that will later be used in the code. Function recursion is allowed.

Function declarations require 2 arguments:

• Function data register location
• Function data
• 2 NULLS to mark the end of the function data.

Creating a function that prints "hi" stored at 2,-1

0000        (new function declaration)
000000      (start of map)
00
00
000000
00
0000000000  (NULL, end of map)
0           (start of raw string)
0
0

0000
0

00000


 
            (NULL, end of raw string)
0000000000  (1st NULL)
0000000000  (2nd NULL, end of function code)

Executing functions

Executing a function means running the code stored in a register. The instruction is structured with 1 argument, which is the map of the register in which the function code is stored in.

Executing a function at 5,-2

00000       (function execution instruction)
00          (start of map)
00
00
00
00
000000
00
00
0000000000  (NULL, end of map)

Checking a condition

Conditions check if a statement between two arguments is true. If it is true, the code continues where another condition is declared with 00000. If the statement is false, the code continues directly after the condition. The second condition declaration must not go directly after the first condition declaration. For a condition, 9 arguments are needed.

• First argument source

0: The first argument is pre-determined.

00: The first argument is register-determined.

• Second argument source

0: The second argument is pre-determined.

00: The second argument is register-determined.

• Register content encoding type

0: Pure integer

00: ASCII character (integer)

00: ASCII character (string)

• First argument map OR raw string

When the first argument is pre-determined, the raw string should go here. If the first argument is register-determined, the map for the register should go here.

• Second argument map OR raw string

When the first argument is pre-determined, the raw string should go here. If the first argument is register-determined, the map for the register should go here.

• Expression type

0: Equal to

00: Less than

000: More than

0000: Not equal to

• Code for false expression

This code will be executed if the condition is false.

• NULLNULL

2 lines of NULL which separates false expression code with true expression code

• Code for true expression

This code will be executed if the expression is true.

• NULLNULL

2 lines of NULL which marks the end of the instruction.

Checking if the pure integer in 3,1 is equal to 9, returning 1 or 0.

000000     (condition declaration)
00         (the first argument is register-determined)
0          (the second argument is pre-determined)
0          (the data in the raw strings are all pure integers)
000000     (start of map)
00
00
00
0000
00     
0000000000 (end of map)
000000000  (start of pure integer raw string)
0000000000 (NULL, end of pure integer raw string)
0          (expression is "equal to")
0          (output instruction)(Beginning of FALSE code)
0          (output is pre-determined)
00         (output is encoded as a pure integer)
           (0, the condition is false)
0000000000 (NULL, end of raw string)
0000000000 (1st NULL)
0000000000 (2nd NULL, TRUE condition code starts in next line)
0          (output instruction)
0          (output is pre-determined)
00         (output is pure integer)
0          (1, the condition is true)
0000000000 (NULL, end of raw string)
0000000000 (1st NULL (technically import file instruction))
0000000000 (2nd NULL, the condition has ended and new code can be written.

Arithmetic Operations

Floating points do not exist in Irma. There are 5 operation types:

• 0:Addition
• 00:Subtraction
• 000:Multiplication
• 0000:Division
• 00000:Modulo

For an arithmetic instruction, 5 arguments are required in this order:

[operation type]

[first argument pre-defined or register-defined]

[second argument pre-defined or register-defined]

[register raw string or pre-determined raw string encoding type(pure integer or ASCII character)]

[first argument raw string or map]

[second argument raw string or map]

[result destination register map]

Whether or not a raw string or map is inserted into the 5th and 6th arguments depends on whether or not the first and second arguments are pre-defined or register-defined. The result will always overwrite whatever is in the destination register.

Multiplying an ASCII character in 6,8 with ASCII character 3 and store result in 8,8

0000000       (declares an arithmetic operation)
000           (operation type is multiplication)
00            (the first argument is register-defined)
0             (the second argument is pre-defined)
00            (beginning of map)
00
00
00
00
00
000000
00
00
00
00
00
00
00
00
0000000000   (end of map)
             (beginning of ASCII character raw string for pre-determined argument)
00000
0
0000000000   (end of ASCII character raw string)
0000         (start of result register map)
00
00
0000000000   (End of result register map)

Finding the index of a raw string

The index is the length of a string. The index of a raw string can be found in 2 ways using the first argument after the instruction is given.

• 0:Find the index of the raw string itself, where

0
0
00
0000
00
000

has an index of 6.

• 00: Find the index of the ASCII characters in the raw string, where

0
0
00
0
00
000

has an index of 2 (consists of characters "p" and "|"). 2 additional arguments are needed for determining the source of the raw string and the destination registry in which the index will be kept in. The result will overwrite whatever is in the destination register. Overall, the structure should be:

[index finding instruction]

[argument for how the index is read]

[map of source register]

[map of destination register]

Finding the index of the raw string stored in 2,2 and store result in 2,2

00000000   (index finding instruction)
0          (argument for finding the index of the actual raw string itself)
00         (start of source map)
00
000000
00
00
0000000000 (NULL, end of source map)
0000000000 (an empty map signifies that the destination map is the same as the source)

Jumping to a line

Jumping to specific lines in the code is a very useful component of Irma. The structure of this instruction is relatively basic:

• 000000000:Instruction declaration
• Pre-determined or register-determined number of line
• Number encoding: ASCII character or pure integer
• Raw string or map of source register based on first argument

Jumping to line 44 in the code

000000000  (instruction declaration)
0          (the line number will be pre-determined)
00         (raw string is pure integer)
0000       (4)
0000       (4)
0000000000 (end of pure integer)

It is important to note that lines in .irma files are 1-indexed.

Importing a library

0000000000 is used to import files with additional instructions, functions or data. This file must be written in Irma with the .irmac file extension.

Versions

DATE NOT DECIDED, VERSION UNFINISHED: Irma-Arnold