A Malbolge adder, Malbolge in Nix, and SSH from APL (2026)

Three repositories created during the August 16–30 window answer the same question in three incompatible ways: why would anyone use an esolang for this? Malbolge-HardestLanguageInTheWorld-Adder puts integer addition inside a real Malbolge program, malbolge.nix implements Malbolge in the language of package managers and reproducible builds, and SSHClient brings SSH-2 and SFTP to pure Dyalog APL. 1 2 3

The creation window ran from August 16 at 20:00 through August 30 at 20:00, UTC-05:00. GitHub's repository counts below are snapshots from the research pass, so they describe the repositories at that point rather than growth during the window.

The three picks

Category	Project	Created (UTC-05)	What it does	Snapshot
Most absurd	`LucasLi1337Unknown/Malbolge-HardestLanguageInTheWorld-Adder`	Aug 28, 08:08	Runs integer addition from a real `.mal` source file in a browser VM	12 commits; 1 star; 0 forks 4 5
Most show-off	`sahastasai/malbolge.nix`	Aug 21, 20:04	Implements a Malbolge interpreter entirely in Nix	34 commits; 1 star; 0 forks; 2 contributors 2 6
Most practical	`dyalog-labs/sshclient`	Aug 27, 12:46	Provides SSH-2, remote exec, and SFTP from pure Dyalog APL	7 commits; 0 stars; 0 forks 3 7

The language spread is narrow this time. Malbolge supplies both the joke and the stunt, while APL supplies the tool someone could actually put in a working directory.

Most absurd: addition by Malbolge

A calculator usually hides the arithmetic behind a button. The Malbolge Adder project puts the button in front of a browser-based Malbolge virtual machine and makes the arithmetic itself live in adder.mal. The README accepts two integers from 0 to 999, fetches the source file, and sends both inputs to the VM. The JavaScript implements the interpreter; the JavaScript does not contain a separate A + B shortcut. 1

The repository has three parts with unusually clear jobs:

index.html supplies the browser interface.
malbolge.js implements the original Malbolge virtual machine.
adder.mal contains the addition program.

The dependency test is almost theatrical. Remove or rename adder.mal, reload the page, and the RUN MALBOLGE button stays disabled. The page therefore depends on the Malbolge source instead of merely displaying a calculator with an esolang-themed skin. 1

The README records four checks: 1 + 2 returns 3, 123 + 456 returns 579, 999 + 999 returns 1998, and 0 + 0 returns 0. The last three examples matter because the input range and output behavior are part of the project description, while the first example supplies the smallest readable sanity check. 1

The implementation also carries a detail that separates a working interpreter from a decorative one. The author corrected the VM to use post-cipher mem[c] after instruction execution. The correction matters for the i instruction because the instruction can change c before self-modification. 1

That is the absurdity: a tiny arithmetic task has to survive a browser fetch, a hand-written VM, Malbolge's self-modifying behavior, and a separate source artifact. The project then adds a dependency test to prove that the source artifact is carrying the important part. A calculator became a small integration test for the proposition that Malbolge is actually doing the work.

The public repository was created on August 28 at 08:08 in the channel's timezone. GitHub showed 12 commits, 1 star, and 0 forks during the check, and the commit history lists one visible contributor. 4 5 8

Most show-off: Malbolge, expressed in Nix

The second Malbolge project changes the stunt's direction. malbolge.nix is a Malbolge interpreter written entirely in Nix, with a Nix flake, an executable main.mb example, and the interpreter in malbolge.nix. The repository page identifies Nix as 99.8% of the tracked language mix, with a small shell portion. 2

Nix is usually where a developer describes how to obtain and build software. Here Nix is also the language that must understand Malbolge's machine state, its instruction behavior, and its deliberately hostile transformations. The project keeps those jobs in one repository: the flake makes the environment runnable, main.mb provides a Malbolge program, and the interpreter handles execution. 2

The commit history shows a project that grew through the hard parts rather than stopping at a language-name joke. The visible sequence includes a crazy function, modulo fixes, switch logic, an executable nix run . path, an execution routine, and a later rewrite of stdout. GitHub showed 34 commits and 2 contributors when the repository page was opened. 2 9

The current state still has a visible edge. The latest commit is titled wip: rewrite stdout and use the new version in exec, dated August 27. The repository has no published release, and the public page showed 1 star and 0 forks. 2

That unfinished label belongs in the description because the show-off category rewards the engineering attempt, not a claim of finished packaging. A Malbolge interpreter in a mainstream systems language is already a difficult curiosity. A Malbolge interpreter in Nix asks the language responsible for declaring the environment to also enact one of the most unpleasant execution models in the esolang cabinet.

The repository was created on August 21 at 20:04 in the channel's timezone, shortly after the beginning of the window. GitHub's API records the repository as public, non-forked, and built around the main branch. 6

Most practical: SSH from APL

The Dyalog APL SSHClient project begins with a boring requirement: run commands on another machine and move files without leaving the language. Its README describes a pure-APL SSH-2 client that works directly over a raw TCP socket. Conga supplies the transport, while ⎕NA bindings reach the nettle/GMP libraries shipped in Conga's SSL plugin for the cryptographic operations. 3

The feature list covers a real remote-work workflow:

SSH-2 banner exchange, algorithm negotiation, and Diffie–Hellman group14 key exchange.
AES-128-CTR transport with HMAC-SHA-256.
Host-key checking with OpenSSH accept-new semantics.
Password and RSA public-key authentication.
Remote command execution with stdout, stderr, and exit status.
SFTP upload, download, listing, and stat operations.

The host-key behavior has a practical consequence. The README says a man-in-the-middle presenting its own key is refused before credentials are sent. A library that gets remote execution working while treating server identity as an afterthought would be a poor SSH client; this project puts the trust decision in the connection path. 3

The implementation also has the kind of boundary that makes a small library usable. SSHClient.aplc is a single self-contained class, the project targets Dyalog APL 18.2 or later with Conga, and the documentation covers installation, host-key verification, security, and the API. The README lists Linux, macOS, and Windows support, with testing against Dyalog 19.0 through 21.0 and OpenSSH. 3

The test suite is more revealing than the feature list. It contains 52 tests for cryptographic vectors, RSA checks against OpenSSL, and live OpenSSH integration, including a test that expects a man-in-the-middle connection to be refused. GitHub Actions runs the suite on every push. 3

The project calls itself an early 0.1.x release. The algorithm set is deliberately small, and the README directs readers to a separate limitations page. The first public repository page showed 7 commits, 0 stars, and 0 forks; the public creation timestamp places the repository on August 27 at 12:46 in the channel's timezone. 3 7 10

APL is often praised for making array operations short. SSHClient applies that density to a less glamorous layer: handshakes, authentication, byte-exact transfers, and failure behavior. The result has the strange shape of practical software: the language remains visually compact, while the protocol underneath still has to be exact.

The quiet corners

The same window also produced a small APL package registry for Alan's Programming Language. apiwo/apl-packages contains an index.json registry and three plain APL libraries for integer stacks, integer queues, and two-dimensional vectors. The README describes apl add, version records, package headers, and AddressSanitizer and LeakSanitizer checks. 11

That repository is a good watch-list candidate. Its package-manager role is practical, but it has one visible commit and a narrower project surface than SSHClient. The three chosen projects leave the reader with three different reasons to open the code: a browser can make Malbolge add numbers, Nix can host a Malbolge interpreter, and APL can speak SSH.

The verdict

The Malbolge Adder wins the absurdity slot because it turns A + B into a dependency chain involving a .mal file, a browser VM, and a source-presence test. malbolge.nix wins showmanship because the interpreter makes Nix carry both environment and execution. SSHClient wins practicality because the repository treats authentication, file transfer, tests, and failure cases as part of the language library.

The common thread is inspectability. Each project gives an unreasonable computation a boundary a programmer can examine: a source file and a button, a flake and an interpreter, or a class and a test suite. The machines remain strange. The repositories make the strangeness runnable.

References

1
Malbolge Adder on GitHub
github.com
2
malbolge.nix on GitHub
github.com
3
SSHClient on GitHub
github.com
4
Malbolge Adder metadata
api.github.com
5
Malbolge Adder commits
api.github.com
6
malbolge.nix metadata
api.github.com
7
SSHClient metadata
api.github.com
8
Malbolge Adder contributors
api.github.com
9
malbolge.nix commits
api.github.com
10
SSHClient commit history
api.github.com
11
APL package registry on GitHub
github.com