Forty-Four Esolangs: the Art of Esoteric Code
Posted4 months agoActive4 months ago
spectrum.ieee.orgTechstory
excitedpositive
Debate
40/100
Esoteric Programming LanguagesProgramming Language DesignComputer Science Education
Key topics
Esoteric Programming Languages
Programming Language Design
Computer Science Education
The article discusses the author's book on esoteric programming languages, sparking a lively discussion on various esolangs and their educational value.
Snapshot generated from the HN discussion
Discussion Activity
Very active discussionFirst comment
2d
Peak period
34
60-72h
Avg / period
11.6
Comment distribution58 data points
Loading chart...
Based on 58 loaded comments
Key moments
- 01Story posted
Sep 5, 2025 at 8:33 AM EDT
4 months ago
Step 01 - 02First comment
Sep 7, 2025 at 8:19 PM EDT
2d after posting
Step 02 - 03Peak activity
34 comments in 60-72h
Hottest window of the conversation
Step 03 - 04Latest activity
Sep 11, 2025 at 4:38 PM EDT
4 months ago
Step 04
Generating AI Summary...
Analyzing up to 500 comments to identify key contributors and discussion patterns
ID: 45137772Type: storyLast synced: 11/20/2025, 5:11:42 PM
Want the full context?
Jump to the original sources
Read the primary article or dive into the live Hacker News thread when you're ready.
I also like this one just for the insanity lol
https://esolangs.org/wiki/5D_5D_Brainfuck_With_Multiverse_Ti...
Quick description:
Like 5D Brainfuck With Multiverse Time Travel, 5D 5D Brainfuck With Multiverse Time Travel With Multiverse Time Travel operates on an array of 5D Brainfuck With Multiverse Time Travel program cells initialized to the 5D 5D Brainfuck With Multiverse Time Travel With Multiverse Time Travel program's source code (treated as a 5D Brainfuck With Multiverse Time Travel program). Multiple pointers to memory, and to the program, may coexist in each timeline. The state of the tape is stored as a timeline, allowing programs to rewind time. In addition, programs may create and traverse parallel universes, which are timelines that all execute simultaneously, "below" their parent timeline. Each timeline has its own pointer.
There are more of course.
Esoteric language =/= any non-mainstream language.
Here's the definition from the esoteric programming language wiki, which is a lovely resource for anyone interested https://esolangs.org/wiki/Esoteric_programming_language:
> An esoteric programming language is a computer programming language designed to experiment with weird ideas, to be hard to program in, or as a joke, rather than for practical use.
https://racket-lang.org/
It's not maintained by the core developers, but it pass all the test suit and if you ever find a bug and post an issue in github or in the discourse group, it will be fixed very soon.
https://pkgs.racket-lang.org/package/r7rs
https://github.com/lexi-lambda/racket-r7rs
more info: https://github.com/lassik/racket-r7rs-example
/random
I love esoteric languages. They're a never ending rabbit hole, and they really force you to revisit all of your assumptions about what it means to program. The most interesting ones for me were the Lambda calculus and Brainfuck.
And of course there is Forth. Which always felt like it was just around the corner from some kind of breakthrough but it never really happened.
Collaborative software projects and all of the modern tooling feel like massive (and endless) layers of abstraction on top of some pretty simple principles. Esoteric programming languages allow you to revisit programming without all of that super structure and for that alone they are valuable, they are pretty pure in that sense.
Forth, (I think even more so than lisp), is fragmented, because its philosophy is not that you write “a forth program”, but that you write “a forth” that does what you need it to do. Don’t like the sign MOD chose to compute ‘-3124 modulo -17’? Don’t add a new one, but change yours. Need better approximations for integer goniometric functions? Change them to work in half-degrees, etc.
That makes sharing code difficult and that, in turn, makes it hard to write large programs.
Nowadays, I guess a ‘solution’ to that problem would be to run zillions of forths as microservices in a single process, but I don’t think that’s practical (could be fun, though. In the limit, one could give each forth a VM page of RAM or maybe even less to work in. Imagine a forth whose sole goal is to maintain and edit a string, with words for string indexing, search, replace, duplication, etc. that runs together with millions of other forths in a single process.
The biggest issues that I had with Forth were: hard to work on code as a team, the 'screens', finding it increasingly hard to name words.
You must have had the luxury of zillions (that is: > 16 kilobytes) of RAM and ROM.
> The biggest issues that I had with Forth were: […] the ‘screens’
Most Forths on larger machines, where you had the luxury of not needing to tweak the base system to fit all your code in are fine working with source files.
Screens were an invention for smaller systems (for those who don’t know: early forth didn’t have a file system, but just a way to load 1 kilobyte blocks from disk. Code was written in such 1 kB blocks, called ‘screens’ because 1kB effectively filled a 16 line by 64 character terminal screen)
"With 144 independent computers, it enables parallel or pipelined programming on an unprecedented scale. Map a data flow diagram or an analog block diagram onto its array of computers for continuous processes without interrupts or context switching."
I can understand that perspective, there are plenty of purpose-built esolangs which are very close to the OG lambda calculus, and depending on your background the whole thing might seem bizarre and unfamiliar and ancient and irrelevant.
At least logically I see that could happen, but my heart disagrees. I see lambda calculus as a root of the conjoined tree[0] which supports all of modern programming. It feels to me like calling written English esoteric because some people get by without reading and writing!
(I'm certainyl not saying you're wrong, but just that it's fascinating how different two valid perspectives can be.)
[0] https://en.wikipedia.org/wiki/Inosculation
File under "old man yells at cloud."
If there is anything that helped me 'see the light' then it was this: that I could build anything with a core that small.
It is most assuredly different than typical languages, but I don't think that means "esoteric". As an industry, we're sort of lost if "esoteric" means anything that doesn't look like Algol.
I'm of the opinion that one must write a forth to grok forth, and I'm far from alone in that. However, I'd not quite call forth itself esoteric. But to many, it's a language family... of which most of the members are esoteric inasmuch they only have a single user.
* shout-out to my friend whose forth supports lists, hash tables, and structs through syntactic sugar... https://github.com/cstrainge/sorth
But more to your point. FORTH was used in a time when the predominant mode of coding was to construct more complex programs from less complex programs, so application developers usually got their hands dirty with some lower level aspects. That is... the application programmers chose the lower level abstractions they wanted to use. Now that we're beyond that and have, as an industry, decided that van Rossom and Latner are the only people who are allowed to define low-level abstractions, it's a lot harder to do that.
(Again, file this one under "old man yells at cloud.")
[2nd edit]
Maybe it's best to think of FORTH as a DSL construction kit. Lisp is kinda-sorta the same way. As you point out, it's super easy for someone to develop DSLs that require coders to understand not only their application domain, but also how the language and it's underlying hardware abstractions operate. And when you're using someone else's DSL, you have to understand how they thought about the problem domain. And we stopped teaching how to analyze that in the 80s.
Also... +1 on the "you've got to write it to understand it." And in the 80s, the documentation wasn't super. Leo Brodie's book was great to get you started, but understanding things like ' (tick) and how to program in "idiomatic forth" was a challenge. So I would add, "not only do you have to code FORTH to understand FORTH, you also have to rip someone elses' FORTH program apart to understand the more advanced bits." -- I could be wrong about that today, it's been a while since I did a survey of FORTH documentation.
It isn't how we teach math in the two countries I've lived in. Lisp is just as weird. Many people see a mathematical expression and panic. A level up from them, people see a mathematical expression in some source code and expect it to respect the symbol precedence that they were taught in grade school -- which they can "understand" without knowing how the language parses and abstracts all that away. And maybe their understanding is flawed but they can survive as programmers for decades without ever going deeper. Lisps, FORTHs, etc., don't allow you to proceed without understanding.
Forth is not that.
It was designed as a practical, stack-based language for embedded systems, instrumentation, and real-time applications. It emphasizes simpilcity, extensibility, and efficiency, and has been widely used in space missions, robotics, and hardware control. While its stack-oriented, postfix syntax can look unusual to those used to C-like languages, its purpose is entirely practical, not experimental or artistic.
> Here's the definition from the esoteric programming language wiki, which is a lovely resource for anyone interested https://esolangs.org/wiki/Esoteric_programming_language:
> "An esoteric programming language is a computer programming language designed to experiment with weird ideas, to be hard to program in, or as a joke, rather than for practical use."
It's available at https://howerj.github.io/subleq.htm if you want to try it online.
Consider for example the Olympus language highlighted in the article. It is impractically verbose but is all the more amusing for it.
Other examples include languages made entirely from whitespace, one that I can't remember the name of that is designed to read like poetry in either German or English, and LOLCODE which is to be written in the style of lol cats memes.
It reminded me of an overambitious educational game idea: The player builds interpreters for prayers directed at several gods, each cult having its own theurgic practices resembling different programming paradigms: https://gashlin.net/blog/pages/2010-12-25-shell-script-of-th...
EDIT: According to https://esolangs.org/wiki/Olympus, you need more epithets if the line of code is more demanding (?), and you need to use varying ones, but other than that they aren't syntactic
Question for the author if they are here: why not use one of the many languages that compile to Wasm to write compilers for esoteric languages?
And then there's the legendary https://github.com/hundredrabbits/Orca
"Orca is an esoteric programming language designed to quickly create procedural sequencers, in which every letter of the alphabet is an operation, where lowercase letters operate on bang, uppercase letters operate each frame."
The one I created for class supports supports concurrency, regular expressions, HTTP requests, and file I/O. The challenging part is that every line executes concurrently in round-robin style (one command per line). There are only 8 commands and each line can only store a single string value.
https://austinhenley.com/blog/hofstadter.html
Although I discuss esolang history in the Spectrum piece (something I get deeper into on my blog, https://esoteric.codes), the book is a monograph of my esolangs specifically: Folders, Entropy, Olympus and more; some are collected at https://danieltemkin.com/Esolangs. It’s meant to make esolangs approachable, focusing on concept rather than technical aspects of the languages. I wrote it to encourage people to experiment with esolangs and to show the community-based nature of the work: the delightful conversation that happens when another programmer takes your language in a direction you would never have conceived of.
The languages range from fully implemented works to pieces that are not implementable (e.g. Past Tense is a language whose programs are not runnable by definition and would cease to be programs if they were https://github.com/rottytooth/PastTense). There’s one where even articulating a program into words or symbols invalidates it: only unreified thought is valid.
The languages are presented first as prompts. In the second half, I present details on those that are implemented, showing the sometimes surprising results of carrying out the initial idea. I hope it will expand the conversation around esoteric languages as an art form.
https://www.youtube.com/watch?v=ieqsL5NkS6I