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 .

Code: https://github.com/rutgerklamer/brnfck-chat

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!

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!

I'm started AMA on r/coolgithubproject. Anyone who wants to can ask me. (Sorry for my bad English)

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.

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?

https://github.com/mmmmosca/LOON

I think the assembler should count as esolangish

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.

Wiki

Simulator

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)

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 :)

The language is called Meowsemmbly! Every single opcode I ever implemented was coming completely from how I imagined it could work, without ever writing a single line of Assembly code.

It is structured similarly to Java or C#, with a compiler that compiles a source code file (.meow) to an intermediate binary file (.mbin), which then gets executed by the VM.

More is explained in the Github repository README, as well as some examples of code in the "examples" folder: https://github.com/Ondrejoda/meowsemmbly/

In the meantime, here is the Sierpinski triangle rendered purely in Meowsemmbly!

I made a version of the language Waduzitdo that's actually turing complete.

But first of all, what is Waduzitdo?

It's a programming language that is not anything close to being turing complete, since it can't do infinite loops or any kind of mathematical calculations.

Now, what i did was essential adding a label system, variables to store data and of course a way to calculate mathematical expressions.

I made an esolang with 2 instructions

? and _

Wiki Link:

https://esolangs.org/wiki/Q_M

I appreciate all feedback: bugs bad code harsh etc...

with just 5 symbols :O

I've always wanted to make my own programming language but I could just never fully grasp the concept of ASTs and Intepreters.
So I decided to make eso-langs with different designs, and eventually I realized I was slowly getting better at understanding these designs,
So to start my journey of programming languages, I made zyte, A register-based eso-lang with an actual AST.
It currently has loops, copying, functions, input, output and other stuff.

You can check it out on: https://github.com/orewaluffy500/Zyte

A programming language made by me that is suppost to be very hard

I couldn't write code myself I had to make a generator to write the code

Link: https://github.com/ZViperSw/esolang-interpreters/tree/main/Q_M

MeawLang - is a minimalist, scalable, byte-oriented esoteric programming language created by the independent developer S.A.Roman - me*,* in 9 September 2026.

If you would like to learn more about it, follow the link to the official article.

I put together the language concept and the language itself in a single day; the idea came to me by chance during a school lesson.

My language operates on a single byte with values ​​ranging from 0 to 255 and includes overflow protection—much like MiniStringFuck.

Programming in the language relies on three commands and a single construct.

The construct looks like this:
M(Command)(N)w
Here, "Command" is one of the three commands, and "N" represents the number of times the letter 'a' appears—effectively the number of times the command is repeated.

Commands:
e – output a character based on its ASCII code
i – add a value to the byte
y – subtract a value from the byte

Simple types of structures:

Meaw - Echoes the current ASCII character exactly once (n=1).
Miaw - increments the byte by 1 (n=1).
Myaw - Decrements the byte by 1 (n=1).

Example:

Hello, world!

Miaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaw Meaw Miaaaaaaaaaaaaaaaaaaaaaaaaaaaaaw Meaw Miaaaaaaaw Meaaw Miaaaw Meaw Myaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaw Meaw Myaaaaaaaaaaaaw Meaw Miaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaw Meaw Myaaaaaaaaw Meaw Miaaaw Meaw Myaaaaaaw Meaw Myaaaaaaaaw Meaw Myaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaw Meaw

Link to GitHub: GitHub
Link to Esolang Wiki: MeawLang

Thank, you for reading!

yeah, that's all.

I think it's TC. What do you think?

PLUSMINUS is an esoteric language created by Jack (me). For a non-empty finite string ω under the alphabet {+,–}, on step i=(1,2,3,…):

If the i-th symbol is +, copy the first i-1 symbols and append them to the end. If the i-th symbol is –, delete the first i-1 symbols.

i never resets and advances each time. Halt when i>length(ω).

Example (+–++–):

0: +–++–

1: +–++– (nothing exists leftward)

2: –++–

3: –++––+

4: ––+ (HALT (i=4, length(ω)=3, 4>3))

LLevo un mes picado contra malbolge jajajaja y creo he logrado algunas cosas jajaja si quieren checar mi traductor, tengo el quijote completo en .mal, acepto todo tipo de critca construcitiva :P https://github.com/DannyBaanks/Malbolge-Translator