Fun Translations
Login
Fun Translations
Toggle sidebar
← Back to Blog

The Strangest Programming Language Ever Made (It Uses Time Travel)

By Fun Translations ·

The Strangest Programming Language Ever Made (It Uses Time Travel)

Here's the counterintuitive thing about emiT: it doesn't just run your program backwards as a novelty. It forces you to confront a question that most programmers never ask — does the order of operations actually matter, or have we just been assuming it does? The answer, it turns out, is stranger than you'd expect.

emiT (that's "Time" spelled backwards) is an esoteric programming language where the program counter starts at the last instruction and runs toward the first. Every program you write is a journey that begins at the destination and ends at the origin. You're not programming a machine. You're programming a time machine.

What emiT Actually Is

emiT belongs to the family of stack-based esolangs — languages where all operations act on a stack of values rather than named variables. Languages like Brainfuck, COW, and Forth all share this DNA. What sets emiT apart is its fundamental execution model: the interpreter reads your source code, reverses the order of all instructions, and then executes them.

This means writing a working emiT program requires holding the end state in your mind first. You decide what you want the stack to look like at the end of execution, and work backwards from there. Push before pop. Clean up before you make a mess. Build the scaffolding after you've erected the building.

The name is a perfect piece of design: every time you see emiT in a filename or import, you're already reading the language's core concept backwards.

Why This Isn't Just a Joke

The esolang community on the Esolangs wiki catalogs over 1,400 documented languages — a number that has grown by roughly 150 new entries per year over the last decade. Most of them are pranks. Some are philosophical statements. A rare few accidentally illuminate something true about computation.

emiT lands in that final category.

Here's why: reversible computation is a genuine research field. Reversible programming languages — where every operation can be undone — are studied seriously in quantum computing, because quantum circuits must be reversible by definition. emiT isn't a reversible language in that technical sense, but it surfaces the same intuition: the relationship between a program and its reverse is not trivial. It's not symmetric. Writing code that runs backwards teaches you things about causality in programs that forward-only execution never reveals.

COW, which writes Brainfuck-style programs entirely in moo-sounds, is a linguistic joke. emiT is a temporal joke with actual philosophical depth hiding inside it.

You can experience a related flavor of "encoding as obfuscation" with our COW Language Translator — the same kind of cognitive displacement, but in the vocabulary dimension rather than the time dimension.

The Experience of Writing in emiT

Imagine you're writing a program to output the word "Hello". In a normal language, you'd push H, then e, then l, then l, then o, then print each one. Intuitive. Sequential. Human.

In emiT, you need to think about what must be true just before execution ends — then what must be true before that — unwinding all the way back to the first instruction, which actually fires last.

This is what we call retrograde programming: writing code whose intent flows opposite to its execution. It's not unlike writing a mystery novel starting from the killer's confession and constructing all the clues that lead to it — backwards.

The disorientation is the point. Esolangs like emiT, Malbolge, and Whitespace exist on a spectrum of deliberate cognitive friction — the idea that making programming harder in specific ways can make it more illuminating. Whitespace hides its syntax in invisible characters. Malbolge encrypts its own instructions as it runs. emiT inverts your sense of causality.

emiT in Context: The Esolang Family Tree

emiT sits in an interesting branch of the esolang family tree. Stack-based ancestors like Brainfuck and Forth gave it the execution model. The concept of "reading code backwards" has parallels in several other experiments:

emiT's contribution is the most radical: it's the whole program, reversed, every time.

Try a flavor of encoding inversion yourself: Binary Translator converts text to the base layer that all programs ultimately compile to — another reminder that everything is just another notation for the same underlying computation.

Reading emiT Code

A minimal emiT program (pseudocode representation) might look like:

OUTPUT
ADD
PUSH 3
PUSH 5

In most languages, execution would try to OUTPUT something before anything is on the stack — an error. But in emiT, this executes bottom-up: PUSH 5, then PUSH 3, then ADD (giving 8), then OUTPUT. The program as written looks broken. The program as executed is correct.

This is why emiT programs often look like corrupted output from another program. They are, in a literal sense, the reverse image of what they compute.

The Creator and the Community

The esoteric language community thrives on exactly this kind of conceptual experimentation. David Morgan-Mar — creator of both Chef (programs as cooking recipes) and Ook! (programs written entirely in orangutan sounds) — represents the archetypal esolang designer: someone who uses absurd constraints to expose real ideas about computation. emiT follows the same tradition.

The Esolangs wiki, a community-maintained encyclopedia started in 2005, has become the canonical archive for these languages. It's where emiT, Piet, Malbolge, and over a thousand other experiments live — each one a different angle on the same question: what is a programming language, really?

Explore another notable language from this tradition: Chef Speak Translator — where computation meets culinary instruction.

What emiT Teaches Us (That Normal Languages Don't)

There are two things you learn quickly when you try to write in emiT:

First: Most programmers think in time-forward sequences almost exclusively. We start, we do things, we finish. emiT reveals how deeply that assumption is baked into how we reason about code — and how awkward it is to reason without it.

Second: Stack operations that seem trivially simple forward (push, pop, add) become deeply unintuitive in reverse. You start to appreciate why computer architects chose the execution models they did. Forward execution isn't arbitrary — it matches the causality structure of human cognition. emiT's reversal is a stress test of that cognition.

The Morse Code Translator offers a gentler version of this encoding shift — a notation system that maps letters to time-sequences of dots and dashes, where the pattern of duration carries meaning. A different axis of temporal encoding.

What Comes Next for Time-Travel Languages

Here's a prediction worth making: as quantum computing moves toward practical applications, languages with non-forward execution models will move from academic curiosities to engineering necessities. Quantum circuits are inherently reversible — every gate must be undoable. The programmers who've played with emiT, explored reversible Turing machines, or wrestled with retrograde programming will have a significant intuitive advantage when quantum programming environments become mainstream tools. The joke language of today is the training ground for the engineer of 2035.

Try Them Yourself

You don't need to debug a time-reversed stack machine to experience the spirit of emiT. These translators let you play with alternative encodings and non-standard notations:

emiT isn't the most popular esolang, and it's certainly not the most practical. But it's one of the few that makes you genuinely feel something when you realize your code runs backwards — a small, vertiginous moment of temporal displacement. Which is, after all, the whole point.

← Previous 10 of the Weirdest Esolangs Ever Created