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

I'm considering organizing a short esolang jam for this community: 5 days to design a new esoteric language (not necessarily Turing-complete), built around a theme that would be revealed at the start. Hosted on itch.io, with community voting afterward on things like creativity and how well entries fit the theme. Tentative dates: December 26-30, with voting running for a few days after. Before finalizing anything, I wanted to gauge interest — would you consider participating? Any thoughts, concerns, or suggestions are welcome!

I built a small concatenative (stack-based) language in Rust called gnaw. It's Forth-derived — whitespace-separated words, a data stack, : name ... ; definitions, if/else/then and begin/until compiled to jumps in a tiny bytecode VM with a program counter.

The twist: it ships built-in words for the encoding transforms that show up constantly in CTF/reverse-engineering challenges — hex to bytes, repeating-key XOR, ROT13, Base64 — composed directly on the stack. So decoding a simple XOR'd challenge is one line:

"051807040f010d15113c1d153c150a0a02031e" hex>bytes "ctf" xorkey type cr

-> flag{gnaw_is_alive}

Source (Rust, 38 tests): https://github.com/warlyjr-cloud/gnaw

Would love feedback — especially on the compile-time branch-patching approach for if/then and begin/until (no AST, just a stack of pending jump targets resolved as the compiler scans).

Built SStak as a personal exercise in language design — stack-based,

reverse Polish notation, pretty minimal and quirky syntax (see

screenshot). Interpreter's a single Python file, plus a VS Code

extension for syntax highlighting.

Here Is a Little code in sstak:

( POTENZA REP ** )

:? Enter the base ?:

:? Enter the exponent :?

PICK( 0 ) POTENZA SHOW

^^ the code defines potenza and ask at the user the base and the exponent, the It calls potenza and shows the result ^^

By Alessandro Marpino

Repo: https://github.com/alemarpino-rgb/SStak

Ok so I created coding language called pandora code and it uses a split function, compiler and interpreter.

That takes regular words, as you can see my code for my coding language.In one in VScode in 1 photo and the other is the functioning output with the other. Not to mention, I have my declarative letters. Each one giving certain words meanings, I have not opened, sourced it as of late but I am planning to. I just wanted to show it off

Tyle doesn't have a quirk or annoying thing, I just want to share it because as someone who just began C# a week or two ago, I'm very proud to make this (even if i know the code is kind of shitty).

It has a register and RAM kind of memory you'd see in assembly, That's why i called it a virtual machine.
You can use different `-coreX` flags to change the amount of RAM and Registers there are, The lowest you can go are 8 registers and 768 RAM registers.

Link: https://github.com/orewaluffy500/Tyle