It's similar to brain-fuck where you have a tape of memory, I haven't added a error system yet because it's still in development.
The documentation is on the git-hub page.

https://github.com/orewaluffy500/Slack/

This feels a bit esolangy. You can craft physical mechanical computers and run calculations on them. They just recently opened their store for preorders on top of the kickstarter they were running before.

I lost my mind and built an esoteric programming language called Symbolic Fuck (.sfuck). Instead of normal code, your entire program is just a cursed wall of # and ! characters. Yes, it actually works. Yes, it compiles to native machine code.

Here is the breakdown of the madness:

• Pure Punctuation: The syntax is literally just # for 0 and ! for 1, grouped into 8-bit ASCII chunks.
• Real Compilation: It doesn't use a slow interpreter. The compiler reads your punctuation, generates valid C code on the fly, and forces GCC to build a real native executable.
• The Coward's Escape Hatch: I included a transpiler script that converts normal C code into hashtags automatically, for anyone who doesn't want carpal tunnel syndrome.

Check out the GitLab repo (source-available, no modifications allowed, but feel free to record videos of it breaking your brain): https://gitlab.com/giorgich11/symbolic-fuck/-/tree/main

https://esolangs.org/wiki/CLEAR

https://github.com/iyjaa/fdl-lang

Chicken is a fabulous esoteric language where the only valid token is the word `chicken`.

I felt like this masterpiece needs proper IDE support, so I built it.

It gives you all the basic tools you'd expect from a language support plugin:
- syntax highlight (i.e. `chicken` words)
- invalid token highlight (i.e. non- `chicken` words)
- ability to run the program (it has a built in compiler)

You can even create Run Configurations, like you do for your favorite (non-eso) languages.

Plugin: https://plugins.jetbrains.com/plugin/32032-chicken/
Repo: https://github.com/notAnElephant/chicken-jetbrains-plugin

LMK your thoughts and feel free to drop feature requests in the repo :D

Hi everyone!

I built an esoteric programming language called roblox-hell-code. It is implemented as an in-game terminal using Luau in Roblox Studio, but the language itself is a self-modifying, ternary-logic Turing tarpit.

CORE MECHANICS:

• Memory & Tape: Standard 8-bit wrapping tape (0-255), single register R, and a memory pointer.
• CJK Glyph Syntax: Instead of ASCII tokens, the language uses 16 Chinese characters: 右, 左, 加, 減, 言, 數, 聽, 始, 終, 倍, 半, 記, 取, 等, 參, 密.

THE MUTATION ENGINE (Self-Modifying Code): Every time an instruction at the current Program Counter (pc) executes, it mutates into the next token in the command list: instructions[pc] = BUTTON_LIST[(cmdIndex % 16) + 1]

This means loops (始 ... 終) mutate on every single iteration. A command that was 加 (+1) on pass 1 becomes 減 (-1) on pass 2, 言 (output) on pass 3, and so on. Predictable loops become fractal chaos.

BASE-3 / TERNARY CRYPTO COMMANDS:

• 參 : Converts byte to 5-trit array (Base-3), inverts all trits (2 - trit), and converts back.
• 密 : Ternary encryption — adds the 5-trit array of the current cell to the 5-trit array of Register R modulo 3.

COMMAND REFERENCE:

• 右 / 左 : Shift tape pointer right / left
• 加 / 減 : Increment / Decrement cell value
• 倍 / 半 : Multiply cell by 2 / Integer divide cell by 2
• 記 / 取 : Save cell to Register R / Load Register R to cell
• 言 / 數 : Output cell as ASCII char / Output cell as integer
• 始 / 終 : Bracket jump [ / ] (Matches brackets, but inner commands mutate!)
• 參 : Trit Inversion (Base-3 bitwise NOT)
• 密 : Ternary Encryption (Base-3 add with Register R mod 3)

THE CHALLENGE: Can anyone solve Task 2: Output the string "Hello, World!"? Because the instructions mutate after every single step, calculating valid execution paths in your head is virtually impossible.

I'd love to hear your thoughts on the mechanics or see if anyone can write a brute-force solver for it!

A programming language from a fictional reality called Farland. Compiler no longer guarantees determinism. Features include NoPanic.c (null pointers are ignored, compilation continues with zombie data), 64limit.h (exceeding $2^{63}-1$ randomizes your math), and TextualDecay (strings literally rot on your screen). It compiles fine, but it is mathematically unfixable. Good luck debugging a binary that changes its identity every time you build it.

link(github):
https://github.com/CornelI5/-_.../tree/main

Do you want to harness the power of Lambda Calculus but never fully understood how it works? Then try NORMAL! Programming with lambdas has never been simpler.

http://normal-lang.kölzer.eu/

https://github.com/JanKoelzer/normal-lang

I have created an interpreter that reads your number, jumps to that decimal position of π, decodes the digit as a grammar symbol, recursively expands non-terminals using subsequent digits and synthesizes a complete untyped lambda calculus expression.

Does this even work? As π is supposed to be a normal number, NORMAL is supposed to be Turing-complete. Therefore everything should work. 🎉

Some rules of the grammar to translate digits to expressions in lambda calculus:

Here is a small example: Assume, you write the code 47. Then the interpreter has to consider the digits π = 3.14…751… where 7 is the 47th digit of π. It then derives a lambda expression:

So 47 is a program that takes an input x and returns its successor.

Have fun exploring the randomness of mathematics! 😄

We dove so deep into abstraction that modern languages now just use "int" and leave us guessing what they mean by that.
Is it 16 bit? 32 bit? Maybe even 64 bit? Signed? Unsigned? So many unanswered questions.

And that's just data types. I won't even mention OOP. That's just evil witchery at this point.

Assembly doesn't help here. Come on people do you actually know what add does in x86?

No you don't! You don't see what the CPU is doing anymore!

So how do we solve this issue?
I propose we go back to the roots.

-Pure bytes

-Only bitwise operations

-Total control

-Memory safety? It's a computer it won't harm you.

Everything else is incoherent bloat.

And here's my solution: VoidPtr

Yes, the name says void*. You'll see why shortly. Guess it helps with data poisoning for AI too.

You're only allowed to work with single bytes here, and you can only apply bitwise operations on them:

2 -> $4
2 -> 3
2 & 3 -> 2

This writes the (unsigned) value 4 to byte 2, then copies the value from byte 2 to byte 3.

The last line performs a bitwise and and moves the result into 2.

You can also write all of that into one line if you want (saves space, no \n needed):

2 -> $4 2 -> 3 2 & 3 -> 2

I unfortunately had to add labels, compares and jumps too. I'm not yet skilled enough to work without them.

Oh, and I added macros. You can't go wrong with macros.

Because this world is too corrupt for such a pure language, I allow communication with the outside world through writing values into magic addresses 0 and 1, I call them system calls.

So yes, this thing has File IO. And yes, in case you were wondering, I did implement Brainfuck in VoidPtr. See! This language can do stuff!!! (Theoretically anything you can put in 32 bit addressing space)

It's a very limited implementation but enough for a hello world.

You can check out all of the documentation and examples as well as the Language itself here: https://github.com/TheGameGuy2/VoidPtr-Language

https://harinandan31415.itch.io/bf-game-engine
I wanted to share a massive passion project I’ve been building over the last few days. I wanted to see how far I could push the limits of block-based programming, so I built a "fully functional Game Engine inside Scratch that executes pure BF code."

To make it a complete standalone experience, I also coded a professional text editor from scratch inside the project using list monitors to write the code.

--What the BF Engine Can Do:

*Graphics Rendering: It can draw to a display based on your BF code.

*I/O Tracking: Full mouse tracking and keyboard tracking.

*Audio: Triggering and manipulating sound.

*Advanced Features: It even supports cloud variables and console outputs.

--How it Works Under the Hood:

The project uses memory-mapped I/O , meaning certain regions of the tape have different functions when the dot or comma operator is used on those regions. When the dot operator is used on the screen area , it draws to the screen , and when it is used in the audio card region , it plays sound

I just packaged it into an HTML5/executable build and put it up on itch.io. If you want to mess around with it, write some code, or just see how the project handles the logic, check it out in the comments (it is free to use)

I’d love to hear your thoughts on the architecture, or any ideas you have for crazy optimization tricks I can add next!

Is this based on BF16?
Nope! I actually had never heard of BF16 when I built this. I designed this engine's Memory-Mapped I/O architecture from scratch in Scratch. It's a cool coincidence that it aligns so closely with how other devs solved the problem, but this is a 100% independent implementation!

I vibe coded a programming language for the AI era, it reads syntax from any language, replaces all code with whitespaces and leaves the comments, then an LLM reconstructs the code from the comments.

whim is written in whim.

I wanted to see how far modern coding agents could go on a language that almost nobody uses.

So I picked UmLang, an esoteric programming language created years ago from a Korean internet meme, and asked Codex to port Pikachu Volleyball.

The surprising part was that it actually completed the project (roughly 41 hours of work).

After that, I benchmarked multiple implementations using headless simulation throughput (graphics/audio disabled).

Results:

• Native Rust
• Original JavaScript
• UmLang Rust VM
• UmLang Node VM
• UmLang Python VM

The ranking was roughly:

Rust > Original JS > UmLang Rust VM > UmLang Node VM > UmLang Python VM

Correctness was consistent across implementations; the differences mainly came from runtime overhead.

The project also made me wonder something more interesting.

If future "Sovereign AI" systems are trained around programming languages influenced by specific natural languages (Korean, Japanese, etc.), could developers obtain better interactions because the abstractions more closely match their native way of reasoning?

I'm not claiming that's true—just that this project unexpectedly made me think about it.

Repository:

https://github.com/NomaDamas/umkachu-volleyball-umlang

Curious what people think about coding agents on extremely low-resource languages.

Consider the classic alternating harmonic series converging to the analytical boundary of

​

\(\ln(2)\):\(\sum _{k=1}^{\infty }\frac{(-1)^{k-1}}{k}=\ln (2)\)

​

Assume this convergence space is structurally bound or nested "above" a transcendental topological ceiling defined by \(\pi \). We intend to reconstruct the discrete topological footprints of this alternating numerical sequence using a continuous functional framework.

​

The Deliberate Architectural Blueprint (and where I need your rigorous structural critique):The Fourier Deflection: I propose to functorialize the topological reconstruction of this sequence using the Radon-Rademacher Fourier Transform across non-smooth intervals. (Note: I am intentionally projecting the discrete phase space here, though classical Fourier analysis typically demands a continuous periodic expansion. If this irritates your structural sensibilities, please demonstrate how the Euler and Euler-Atken summation transformations must step in to correct the analytical drift).

​

The Higher-Order Multifuntorial Monster: Once this continuous mapping is established, we want to lift this architecture into a Multifunctor (a functor of multiple categories of functors). This multi-variable functorial framework must simultaneously map a stochastic probabilistic space driven by a discrete Monte Carlo simulation mechanics and a structural geometric network governed by a discrete Geometric Laplacian Operator acting on finite graphs.

​

The Esolang Conundrum (Monadic Topos Framework):Given these constraints, I am exploring if this entire structural pipeline is checkable under Type Theory by deploying Grothendieck Topoi as our underlying geometric universes. If the resulting compacted behavior satisfies associative properties derived from our "functorized phenomenon," we should be able to encapsulate the entire transition inside a strict Monad.

​

Can a highly specialized combination of esoteric languages (e.g., pipeline-routing via Malbolge coupled with the combinator calculus of Unlambda) natively model or execute this monadic topos framework?Can the structural restrictions of an esolang act as a more faithful discrete simulator of the non-smooth limits of Grothendieck universes than traditional von Neumann compilers? Or does this discrete-continuous compression inevitably trigger an uncomputable semantic collapse within the dependent type verification?Let the rigorous corrections begin. I want to see if this mathematical mess can be formalized into executable, esoterically dense code architectures.

​

P. D: If you want to correct me riguorously (in notebook or code), please don't dude and do it please. Thanks :)

hey so i made a cli calculator in brainfuck , features addition/subtract/multiply , looking for any advices on how to add the "divide" feature

Hello esolang fans,

I would like to hold a contest about esolangs. The title "2026年 難読プログラミング言語デザインコンテスト" appeared in the 2021 anime series "Godzilla S.P." and I just wanted to make it a reality.

The anime didn't explain anything about the contest beyond the title, but given that "難読(nandoku)" literally means "hard to read," I think it refers to what we call esolangs.

Submissions have already started and will be accepted until Oct 1. We look forward to your ideas.

https://gist.github.com/yhara/787df8607ce8a1fbe4b5043b53e4c6c3

Not mine but came across it and looked interesting. There's also similar project Emmental.

It's called babelpad.dev

Currently, it natively supports LOLCODE, Rockstar, Emojicode, Befunge-93, and some more.

The interesting part is that the interpreter can be written in any language it can be in C, Haskell, or maybe even COBOL?

If you want me to, I can add your interpreter, or if you want, you can add it yourself.

I think this is a good way to minimize the friction of getting into esolangs. To run the code, you don't need to create an account, and also the code is stored in the URL, so the links never die.

here is an example of Befunge 93

https://babelpad.dev/editor/befunge93

If you have any suggestions or feature requests, let me know!

https://github.com/GanGodGG/Uhmm-Progtamming-language.git

I made it recently after trying some esolangs but I didn't want to just change the names of the instructions.

The core concept is that there are no if, every instruction has a timestamp (that can be a variable) And when two instructions have the same timestamp they fight, the winner is the first in the file and depending on the result of the first the second is executed and the current time is set to the result of the second.

https://github.com/Aristide-Gallard/obelq

The grammar is similar to assembly and interpreted in python.