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.
Reaph
Reaph (pronounced reaf, or reap with a long breath at the end if you use \H and " at the same time) is a (still work in progress) esolang based on the syntax of LaTeX but having nothing to do with what the LaTeX math symbols even mean.
also the reason why this page doesn't use the math tags is because apparently Notability (the thing i've been prototyping this on) has more LaTeX commands (i.e. \o), or notability is outdated, or is just fucking wrong
Basic Structs
there are 3 structs, functions/variables, functors, and pointers. pointers are basically the raw version of a struct, they can either be stored in variables (a link to a pointer), or are variables (a named pointer). everything that isn't a pointer is either a function/variable, or both in an ambiguous way (functor). idk why i started with pointers because functions/variables are the entire point of this. the reason there's a slash is because they're almost the same thing. using a variable in a functional way will do something, same thing for a function accessed in a variable way. functors are variables and functions, or a function and a function, or a variable and a variable, or anything up to 2 variables and 2 functions. useful if you want a function to actually have a specific variable representation than just the Reaph equivalent to .toString(). btw you can't use brackets (i.e. (), [], {}, <>) in a function/variable way due to the functional syntax (that being f() for a function/variable named f)
also theres a stack which stores variable/function values/definitions, pointer values, what variables/functions are also functors, etc. the stack is small by default (256 symbols per definition, 128 stack items) so Reaph can run on anything.
strings are defined as either "" or \H \H depending how much you like LaTeX (and you can even mix them if you're evil)
numbers just work like numbers, unless you use \to to define numbers while running a function (\frac{f(x)}{x\to 1}
How to Use Functions/Variables
there are multiple ways to apply functions to stuff or run functions. the simplest way to run a function is (for a function named f)
\sqrt{f()}
you can also use arguments
f(x, y)
or apply stuff into it (if it's a functor or has only 1 argument)
\frac{f}{x\to i}
in those examples, f was defined as
f(i) = i + 1
you can also use \to to define functions/variables, and \implies to define functors. you can also define functors using
x \to f(y)
for adding a variable (x) to a function (y), or
f^x(y)
for adding a function (x) to a variable (y)
although, f() is already a function, the subfunction function, for when you need a function but don't have/need a name for it, like when defining a function but need another function inside it
speaking of functions inside functions, how about variables inside variables?
if you want a variable that isn't an argument as part of a function, you can define the function with
f(x) = (y = 1) \to x + y
(pretend the function is named something other than f)
Basic Functions
| Function | What it does |
|---|---|
| \o or o() | output/print |
| \i | input, further explanation below [1] |
| \P | the parent function, allows you to grab shit about the function itself (i.e. ex = f(\P) gets the function name) |
| \S | the semi-parent function, allows you to grab a part the parent (i.e. ex = f(\S) gives you e) |
| \letter[2] | if any functions look like letters (w/ or wo/ something) in LaTeX, they have a variable set which is the letter itself |
| \d | creates a pointer, because it looks like a point |
| f() | sub-function, as mentioned above |
| r() | rotates variable (i.e. 1234 -> 4321) |
| a() | gets the "atom" of the function/variable (i.e. 2 -> f(1+1) or f() -> \frac{\Xi}) |
| \v | pointer version of f() |
| \r | pointer version of r() |
| \u | pointer version of a() |
| \c | pointer version of o()/\o |
| \l | the stack limit, useful if you want to avoid stackoverflow.com |
| 5 functions[3] | they work normally, until you use them like functions instead of math symbols |
| sum[4] | basically an if, the thing on top gets checked with the thing on the bottom (i.e. \sum_{=1}^{\i}), continues to the right if it's correct (or if theres a matrix) |
| \wr | another way to do ifs, although you need 2 (i.e. \i \wr =1 \wr o(\i)) |
| matrixes[5] | multiple functors stored as a pointer because that sounds like a good idea, also are used for what ifs/sums do when true or false (needs at least one of the sides to have 2 parts for sum) |
| prod[6] | same thing as \sum, but now it repeats the right when the check work |
- ↑ it's unstable unless you give it a value, which is by some sort of input. \frac{\P}{\i} gives user input. also to print it you need it to be a function, i.e. f(\i)
- ↑ i.e. \o, \i, \j, \l, etc.
- ↑ +, -, * or \times, / or \div, % or modulo
- ↑ \sum_{variable 2}^{variable 1}
- ↑ \begin{matrix}...\end{bmatrix}, can also use pmatrix
- ↑ same as \sum but with prod instead of sum
Examples
Hello World:
o("Hello World!") or \frac{\o}{\H Hello World! \H}
Truth-Machine:
\i = \frac{\P}{\i}
\sum_{=1}^{\i} \begin{bmatrix} o(1) & \prod_{=0}^{\i} o(0) \end{bmatrix}