r/esolangs • u/realcomitabrailens • 22h ago
Recipe I made that emulates cat.
reddit.comUse chef
r/esolangs • u/realcomitabrailens • 22h ago
Use chef
r/esolangs • u/random_dev1 • 1d ago
When people say that a language is close to the metal, they usually mean silicon. But you don't even get to touch that metal and it usually just hums a bit and doesn't cause any harm. So I thought I would create something that would make you feel the machine and work with the metal.
Introducing: Finite Steam Machine !

In this language (and I should probably include interpreter, because the language alone doesn't have any meaning if we ignore the underlying machine) you have to manage resources like coal, water and steam because the instructions rely on steam pressure to get executed. At a first glance it might look like your average stack based eso lang, but try to implement conditional branching and you'll see the true nature of this thing.
Your instructions are positioned on a belt which can move back and forth, you use a steam press for many different instructions, you use pressure to pump more water into the boiler and you control your pressure with valves. Be sure to control it or you might end up with your boiler exploding.
So, why would one want to use this thing?
Well, it's fun! You can come up with a ton of possible solutions when implementing something even as simple as a while loop. It provides a different perspective on programing because you can use the machines properties to your advantage.
Go try it out! And feel encouraged to send your programs in as a PR, if it works correctly I'll add it to the examples, and besides that I would be very interested in what one can make with this language!
There was no AI used in this project in case you care. Any code, text (this post, doc.) or images (the icon) you see in the repo were created by me. I hope it's obvious why you wouldn't use AI for such a project. Code can be art. I stand by this. The code for this project isn't perfect, it really isn't, look at the parser, because this is a project I made for fun. I'm telling people about it because maybe someone else will have fun with it too.
With all of that said, do that! Have fun! I'd love to hear what you think about it.
r/esolangs • u/phacey-facephones • 1d ago
A modified version of BrainF meant to be easy to use
+-<>[]., Normal BF Commands, work as normal
? Alternative to ,
{ }#) Loops until cell equals #
\n or ; Sets cell to newline ascii
"$ Sets cell to ascii of $
(+#)(-#)(<#)(>#) Does action # Times
(=#) Sets cell value to #
(^#) Sets cell pointer to # (Left most cell used is always 0)
(r#) Sets cell to random value between 0 and #
(w#) Makes program wait for #/10 seconds
'$$$' Sets current and right cells to string, leaves pointer to the right of string
# # Comment, Everything in it is not treated as code
* interpreter will by default append \n to users inputs, place * at beginning of code to turn off
This was partially made with the help from a tutorial by camto2437 on youtube
r/esolangs • u/SpiritedYou2689 • 2d ago
Author here — built this for TinkerHub's Useless Projects 2.0 hackathon (it won).
SlowLang is a Python-based esolang that enforces a ~30 WPM typing cap. Type
faster and an angry ASCII turtle appears, you get a 2-second lockout, and the
error messages are sarcastic haikus. There's a mandatory please() builtin the
interpreter demands at random 3–7-line intervals, and a lazy mode that
refuses ~10% of perfectly valid runs.
It's Turing complete — .slow files execute as arbitrary Python under the hood.
Repo: https://github.com/sebin-gg/slowlang
Browser demo: https://sebin-gg.github.io/slowlang/
Esolangs wiki article: https://esolangs.org/wiki/SlowLang
r/esolangs • u/SpiritedYou2689 • 2d ago
Author here - built this for TinkerHub's Useless Projects 2.0 hackathon (it won).
SlowLang is a Python-based esolang that enforces a ~30 WPM typing cap. Type faster and an angry ASCII turtle appears, you get a 2-second lockout, and the error messages are sarcastic haikus. There's a mandatory please() builtin the interpreter demands at random 3-7-line intervals, and a lazy mode that refuses ~10% of perfectly valid runs.
It's Turing complete - .slow files execute as arbitrary Python under the hood.
Repo: https://github.com/sebin-gg/slowlang
Browser demo: https://sebin-gg.github.io/slowlang/
Esolangs wiki article: https://esolangs.org/wiki/SlowLang
r/esolangs • u/phacey-facephones • 4d ago
Brain Fluff, an easier to use version of brainf made by me!
working
+ add 1 at pointer
\- subtract 1 at pointer
< move pointer left
\> move pointer right
[ ] loop until zero
, or ? set value to user input
. output value as ascii
“$ set value to ascii value of $
not done
{ }# loop until #
(+#) add #
(-#) subtract #
(<#) move pointer left by #
(>#) move pointer right by #
(=#) set value to #
'$$$' set multiple ascii values at pointer and right
; sets value to newline ascii
(^#) move pointer to #
r/esolangs • u/TheConnectShoe12 • 5d ago
Hello! I made my own coding esolang and IDE for my language, Bedrock. It is really easy to create and lightweight.
r/esolangs • u/GAFANIY • 5d ago
Hi everyone!
Over the last few weeks, I've been writing a tree-walking interpreter in C called **TELL**.
I wanted to make a language with a normal syntax for math and loops, but with a twist: it allows you to embed inline esoteric sub-languages directly into the code. Right now it supports **KROS**, **OTG**, **BABL**, and **HEXAGRAM**.
Here is an example of a normal loop and a jump table:
```tell
SET A 5
HOL_JMP:
1_ (5): (START)
hol_START
WHILE A > 0:
SET A A - 1
PRINT A
END
PRINT "KAAAK!? RABOTAET!!!"And here is how you run KROS inside the main program:
tell
PRINT "Normal code"
SUB(KROS)
GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
H
END
PRINT "Back to normal"Features:
Variables, arithmetic, strings, dynamic lists
IF/ELSE, WHILE, FOREACH
TRY/CATCH/FINALLY (implemented via setjmp/longjmp)
Isolated threads (each thread gets its own VM, so no race conditions)
VS Code extension with syntax highlighting and autocomplete
I know it's a toy project, but I had a lot of fun building it and learning how interpreters work under the hood.
(I didn't post a direct link to avoid spam filters, but if you want to check out the source or the VS Code extension, let me know in the comments! I also created a small subreddit r/tell_lang for the project).

r/esolangs • u/crazy-dev-bear • 6d ago
Hi r/esolangs!
I recently created UsagiC, a C-based esoteric programming language inspired by Usagi's expressions from Chiikawa.
I previously developed UsagiLang, a Python-based interpreted language. This time, I wanted to experiment with C!
How UsagiC works:
- The transpiler itself is written in C11 — no Python required.
- It converts ".usagic" source files into standard C code.
- GCC or Clang compiles the generated C into native executables.
- Both Japanese and Korean keywords are supported, even in the same file.
- Standard C syntax, pointers, and ".h" headers are preserved.
Here's a Hello World example:
#ハイ<stdio.h>
ウ main(プ) {
ウラ("ヤハ! Hello, World!");
ウラララ 0;
}
Some keyword translations:
UsagiC| C
"#ハイ"| "#include"
"ウ"| "int"
"プ"| "void"
"ウラ"| "puts"
"ハァ"| "if"
"ウラララ"| "return"
It's essentially a playful C dialect with Usagi-inspired keywords, rather than an entirely new compiler backend.
Current version: v0.1.1-alpha
GitHub (UsagiC):
https://github.com/Lee-sangyul/UsagiC
Original UsagiLang:
https://github.com/Lee-sangyul/UsagiLang
This is an unofficial fan-made project, not affiliated with the original creators of Chiikawa.
I'd love to hear what you think! What would you improve about the syntax, keyword design, or transpiler?
Thanks for checking it out!
r/esolangs • u/n0067h • 8d ago
I've been working on Yahalang, a stack-based programming language whose keywords are inspired by the Usagi rap makes in Chiikawa.
It started with a question: could I write programs using those sounds? It now supports conditionals, loops, checked integer arithmetic, arrays, and UTF-8 character and string I/O. Programs can use Korean, English, or Japanese spellings.
Here's the same countdown in all three spellings. Each version prints 321.
Korean:
하야하 뿌루뿌루뿌루 야하
이야 야다야다
뿌루
이이이야하 뿌루루
하야하 뿌루 야하
우라 야하
우라 야다야다
얏English:
hayaha ppuruppuruppuru yaha
iya yadayada
ppuru
iiiiyaha ppururu
hayaha ppuru yaha
ura yaha
ura yadayada
yatJapanese:
ハヤハ プルプルプル ヤハ
イヤ ヤダヤダ
プル
イイイヤハ プルル
ハヤハ プル ヤハ
ウラ ヤハ
ウラ ヤダヤダ
ヤッThe interpreter is written in Rust. It includes a persistent REPL and a --trace option that shows executed phrases, source locations, and stack changes. The repository also has examples such as factorial, sorting, palindrome detection, and a postfix calculator.
Recently, the project's first external contributor added a Yahalang-to-C compiler written in Yahalang itself. Its C output can be built into standalone executables, and it can compile itself. We also verified that the interpreted and native versions of the compiler produce byte-identical C output.
The syntax is playful, but building it has turned into an exercise in parsing, runtime semantics, error handling, and self-hosting. I'd be interested in feedback on the language design or implementation, especially from people who have worked on esolangs or small compilers.
Code and examples: https://github.com/N0067H/yahalang
r/esolangs • u/crazy-dev-bear • 9d ago
Hi r/esolangs!
I recently created UsagiLang, a fun esoteric programming language inspired by Usagi's unique way of speaking in Chiikawa!
It's a Python-based interpreter supporting Korean and Japanese commands.
Here's a Hello World example:
우라 "Hello, World!"
The project is currently in its early alpha stage.
It's an unofficial fan project, and I'm sharing it because I thought programming with Usagi-style expressions would be hilarious.
GitHub: https://github.com/Lee-sangyul/UsagiLang
I'd love to hear your feedback!
What features or commands do you think I should add next?
Thanks for checking it out! 🐰
r/esolangs • u/stack_of_thoughts • 20d ago
Was wondering if I could make an LLM inside brainfuck and that idea got a bit out of hand. So I present to you brnfck.chat
The video is one of the training programs. It learns names, then prints itself with what it learned written in, and that one learns more and prints the next. All done in pure brainfuck. Every square is the real file and the last one prints a child that only makes up the names.
The LLMs are all single brainfuck files too, the question goes in through the only , and the answer comes out of the only .
r/esolangs • u/Leather-Title-6490 • 25d ago
Hello everyone! I'm Czar Pedro (NeuroSpice), an 11-year-old developer. Over the past few days, I've been designing my own interpreted programming language called Quelang.
I wanted to create a language that is easy to read, fun to use, and has some unique mechanics. I built a custom compiler/playground for it that runs directly in your browser!
What makes Quelang special?
Native Fibonacci: You don't need loops or recursion. Fibonacci is built directly into the core. You can do fib(6) to get the 6th number, or fib(1..5) to get a sequence.
Simple Syntax: Uses "var" for mutable variables and "con" for constants.
Easy Printing: Just use put("Hello") to print to the screen.
Browser Playground: Runs instantly in your browser without any installation.
Try it out! You can run the code directly in your browser. No installation required.
Playground: https://czarofkadeksan.github.io/Quelang-compiler/
GitHub Repository: https://github.com/czarofkadeksan/Quelang-compiler
Hello World Example:
fn main() {
put("Hello, World!\n")
}
Fibonacci Example:
fn main() {
put("The 6th number is: " + fib(6) + "\n")
put("Sequence from 1 to 5: " + fib(1..5) + "\n")
}
Variables Example:
fn main() {
var x = 10
con pi = 3.14
put("X = " + x + "\n")
put("Pi = " + pi + "\n")
}
I would love to hear your feedback, suggestions, or even bugs I should fix!
Thank you!
r/esolangs • u/SuperCat-0877 • Oct 16 '26
Hey r/esolang! 👋
Esolang Translator is an open-source IDE for 43 esoteric and regular languages. It translates code between any pairs, features 2D visual editors for Piet/Rivulet, and includes a code sandbox. It’s a WIP project, so expect bugs—feedback is highly welcome!
Features:
· Multilingual UI – fully (and possibly badly!) translated into 6 languages: English, Русский, Deutsch, Español, Français, Italiano. · 43 languages – regular (Python, C++, JavaScript, etc.) and esoteric (Brainfuck, Piet, Whitespace, Malbolge, LOLCODE, etc.).
Links:
· GitHub: https://github.com/SuperCat-0877/esolang-translator-app · Releases (.exe + SHA256): https://github.com/SuperCat-0877/esolang-translator-app/releases · ChangeLog: https://github.com/SuperCat-0877/esolang-translator-app/blob/main/CHANGELOG.md
Known limitations:
· Some translation pairs are simplistic and produce awkward output. · BlockPiet and BrainPiet are project-internal variants, not official languages.
Feedback welcome! I wrote this code over the last 2 months. I'm sure there are small errors I couldn't find, so please don't be angry at my first project. I would really appreciate any feedback or advice!
Could you please test my work? (Sorry for my bad English)
r/esolangs • u/_JustPotato • Oct 12 '26
I originally intended to simulate Rule 110 using Vim motions (hence the name), but I fell down the rabbit hole. So here we are.
VimComplete is a self-hosted esoteric programming language built around Vim motions. No Ex commands or the = register, which uses VimScript for evaluation. Each source line is executed using a :normal! command in the runtime.
Registers x, y, and z are used to capture the exit code, stdout, and stderr, respectively. Register c passes command-line arguments.
The repository currently includes:
A bootstrapped compiler with preprocessing, validation, optimisation, and code generation stages
A recursive text-substitution model for multi-module support, similar to C's #include
An implementation of Conway's Game of Life
A standard library with search and replace, assertions, file diffs, basic arithmetic, and more
Unit tests for the compiler and standard library
A Cobra-based CLI, step debugger, and Neovim syntax highlighting support
If you’re interested in how the source code works, docs/techniques.md describes some common techniques used for emulating standard programming constructs like subroutines, conditionals, iteration, and asserts.
Do clone the repository instead of browsing the source GitHub because GitHub can’t render raw controls characters, which the source code is filled to the brim with.
Repository link: ksaze/vim-complete
P.S. Surely this will help me land a job. Good going, me.
r/esolangs • u/PlayfulDuck3677 • Oct 05 '26
r/esolangs • u/PerformerDazzling601 • Oct 03 '26
I recently stumbled myself into this old project of mine called LOON and on github it even got 10 stars surprisingly.
It's a configuration language designed for humans to write.
Check it out, maybe?
r/esolangs • u/PlayfulDuck3677 • Oct 01 '26
I think the assembler should count as esolangish
r/esolangs • u/HeapDweller • Sep 30 '26
Symblicity is a 'low-level' esoteric programming language with five 8-bit registers, 512 bytes of directly accessible memory, a double-ended stack, bidirectional execution, direction-sensitive letter jumps, and optional asynchronous audio.
Every non-formatting character in a .sym file has a meaning. Newline, carriage-return, form-feed, and vertical-tab characters are ignored as formatting. A literal TAB begins a comment and ignores the rest of that physical source line. A literal ASCII space is an instruction that skips the next instruction.
r/esolangs • u/PerformerDazzling601 • Sep 29 '26
r/esolangs • u/PerformerDazzling601 • Sep 24 '26
r/esolangs • u/Still-Addition-1109 • Sep 24 '26
this is probably one of, if not my favorite thing that i made ever
a spec can be found in the `spec/` directory for more information about the language, and some example programs can be found in the `examples/` directory
edit: i renamed the language to Stacklan because there's already one called Stacking (https://esolangs.org/wiki/Stacking)
r/esolangs • u/BidForeign1950 • Sep 22 '26
I'm working on a data structure that implements a number system, letting different parts of non-standard (and standard) math work together. The strangest part is how it treats zero:
1 - 1 -> |0|₀ a zero that remembers it was a cancellation
5 + 0 -> |5|₀ + |1|₋₁ adding zero leaves an infinitesimal behind
0 / 0 -> |1|₀
7*0*0/0/0 -> |7|₀ division by zero can be undone
ln(0) -> |-1|_(0,1) log of zero is a value on a log axis
5 + nothing -> |5|₀ "nothing" is not zero
What it currently brings together:
- zero as an infinitesimal, "nothing" as a separate value, no additive identity, division by zero that can be undone (this project)
- infinitesimals and infinities as ordinary values (Levi-Civita, Hahn; numerics by Berz and Shamseddine)
- numbers written in powers of an infinite unit, like Sergeyev's grossone, but with zero treated differently
- standard part, and limits by direct evaluation (Robinson's non-standard analysis)
- all-order Taylor arithmetic: every derivative from one evaluation (Wengert, Rall)
- log and log-log scales, toward transseries (Hardy, Écalle, van der Hoeven)
- divergent series: finite parts kept next to the divergent ones, Borel–Padé resummation
- completeness tracking: each result knows which orders it's exact to (this project)
Plus integration, multivariable and complex calculus, singularity analysis and a few applications. More in the repo, with examples under demos and tests: github.com/tmilovan/composite-machine
I'll be happy if you take a look at it :)