Weirdest Programming Languages Ever Created

By Alex Carter on October 2, 2024

Programming languages are typically designed for efficiency, functionality, and ease of use. However, some languages take a completely different approach, prioritizing creativity, humor, or experimentation. These unconventional languages function as thought experiments, pushing the boundaries of traditional programming logic and syntax.

Some of these languages mimic natural speech patterns, while others resemble fictional scripts, roadmaps, or even abstract art. They may not be practical for real-world applications, but they offer insight into the flexibility of coding and how programming can be approached from unconventional angles. This collection highlights some of the most unusual programming languages ever created, showing how coding can be more than just a technical skill—it can also be a form of expression.

How Humor Enhances Creativity in Programming

Scientific research suggests that humor plays a role in boosting creativity. Laughter engages multiple areas of the brain, with the left hemisphere setting up the joke and the right hemisphere processing its meaning. A study at Northwestern University tested this connection by having one group watch a comedy and another watch a horror movie before solving a puzzle. The group that watched the comedy performed better on creative problem-solving tasks.

Sarcasm can have a similar effect, but only when used in a setting where trust exists. For programmers, humor often takes a unique form, influencing the way they think and create. Unconventional programming languages are an example of this, encouraging both creators and users to explore coding from a different perspective. If you have an idea for a humorous programming language, it’s worth pursuing—using humor can open the door to greater creativity.

Integrating humor into programming not only enhances creativity but also encourages experimentation with unconventional approaches. Similarly, using web development tools that simplify coding tasks and enhance collaboration can free up mental space for innovative thinking, allowing developers to focus more on problem-solving and creativity.

The Most Unusual Programming Languages of All Time

LOLCODE

LOLCODE is built entirely in lolspeak, the playful internet language popularized by lolcats. Every command is written in capitalized, meme-inspired syntax, making it seem like a cat is actually coding. Created in 2007 by Adam Lindsay, a researcher at Lancaster University, LOLCODE is not meant for serious programming but can handle basic tasks like reading files and printing text. While its practicality is limited, its humor and unique structure make it an entertaining language to explore.

SHAKESPEARE

This programming language transforms code into something resembling a Shakespearean play. Variables are represented by characters, and their values are determined by the sentiment of nouns assigned to them. For instance, if Hamlet holds a negative value, another character can enter the scene and insult him to alter it. The language incorporates acts, scenes, and stage directions, making it read more like a literary work than a programming script.

A typical program in Shakespeare is structured as a play, complete with acts and scenes:

Act I: Hamlet’s Insults and Flattery

Scene I: The Insulting of Romeo

VELATO

Velato is a programming language that uses MIDI files as its source code. Instead of conventional text-based commands, it relies on note sequences to determine instructions. Musicians with coding experience can compose songs that double as functional programs, embedding hidden messages within melodies.

CHICKEN

Chicken is a programming language that takes minimalism to an extreme, allowing only one word: “chicken.” Created by Swedish programmer Torbjörn Söderstedt, it was inspired by Doug Zongker’s parody of scientific speeches. Every command in the language consists solely of the word “chicken,” repeated in specific patterns. Writing even a simple program results in a long block of text filled exclusively with “chicken,” making it one of the most unusual coding languages ever created.

OOK!

Ook! is a programming language derived from Brainfck but designed to be understood by orangutans. Created by David Morgan-Mar, it replaces Brainfck’s eight commands with different combinations of “Ook.”, “Ook?”, and “Ook!”. While functionally similar to its predecessor, its structure gives it a unique identity. Below is an example of the “Hello, World!” program written entirely in Ook syntax:

Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook? Ook! Ook? Ook! Ook!

OMGROFL

Juraj Borza’s programming language Omgrofl is entirely built from internet acronyms like “lol,” “brb,” and “kthx.” Every command mimics early internet slang, making it one of the most humor-driven coding languages. The “Hello, World!” program in Omgrofl looks like a string of chatroom abbreviations rather than actual code.

Rockstar

Rockstar is a programming language designed to turn programmers into “rockstars”—literally. Created by Dylan Beattie, it allows developers to write code that resembles song lyrics. It was developed as a response to job postings looking for “rockstar programmers.” Rockstar discourages comments in code, instead encouraging readers to interpret meaning on their own.

Example:

• My heart is true (initializes a Boolean variable);
• Tommy is nobody (sets the variable Tommy to null).

Rockstar turns coding into poetic expression, making it one of the most creative programming languages.

TrumpScript

Originally created as satire, TrumpScript is a programming language based on the idea of what Donald Trump would want in a programming language. It was designed to be strict, bombastic, and intentionally restrictive. Key features include:

• Only whole numbers—no decimals, because “America never does anything halfway”;
• All numbers must be greater than one million;
• Import statements are banned; all code must be “homegrown”;
• True and False are replaced with “fact” and “lie”;
• Error messages are taken directly from Trump’s speeches.

Although no longer in development, TrumpScript was a statement about internet culture and satire in programming.

Brainf*ck

Brainfck is a minimalistic yet notoriously difficult programming language designed to challenge programmers rather than provide practical use. Created in 1993 by Urban Müller, this language consists of only eight commands, each represented by a single character. Despite its extreme simplicity, writing even basic programs in Brainfck requires significant effort, making it a test of logic and patience. Over the years, it has gained a cult following among those who enjoy complex problem-solving. 

Below is an example of the “Hello, World!” program in Brainf*ck:

++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.

<<+++++++++++++++.>.+++.——.——–.>+.>.

Whitespace

Whitespace is an esoteric programming language that takes an unconventional approach by recognizing only spaces, tabs, and newlines as commands. Created as an April Fools’ joke by Edwin Brady and Chris Morris, it ignores all non-whitespace characters, making its source code effectively invisible. Below is a sample of Whitespace code, where spaces (S) and tabs (T) are marked for readability:

S S S T    S S T S S S  

T   

S S S S S T T   S S T S T 

Piet

Piet is a visually unique programming language where code is represented as abstract art. Developed by David Morgan-Mar and named after Dutch painter Piet Mondrian, Piet programs use color blocks instead of traditional syntax. The language does not rely on specific colors but instead processes transitions in hue and brightness to determine instructions. The result is a programming language that produces abstract images while still executing commands.

Befunge

Befunge is a two-dimensional programming language created in 1993 by Chris Pressey. Unlike conventional linear code, Befunge allows instructions to be arranged in a grid, where the instruction pointer can move in multiple directions. It uses a stack-based execution model and lacks conventional syntax for comments, requiring programmers to route control flow around documentation areas. Below is an example of the “Hello, World!” program in Befunge:

0″!dlroW ,olleH”>:#,_@  

Some key commands in Befunge include:

+ – * / % for arithmetic operations

! for logical NOT

< > ^ v for directional movement

? for random movement

Befunge remains one of the more complex and experimental languages, offering a unique challenge for programmers.

ArnoldC

ArnoldC is a programming language composed entirely of famous one-liners from Arnold Schwarzenegger movies. Created by Lauri Hartikka, it replaces standard programming commands with quotes from films like The Terminator and Predator. For example, “False” and “True” are replaced with “I LIED” and “NO PROBLEMO,” while “Return” becomes “I’LL BE BACK.” Below is an example of a “Hello, World!” program in ArnoldC:

IT’S SHOWTIME  

TALK TO THE HAND “Hello World!”  

YOU HAVE BEEN TERMINATED  

ArnoldC blends humor and coding, making it one of the most entertaining yet functional esoteric programming languages.

Chef

Chef, designed by David Morgan-Mar, looks like a cookbook but functions as a programming language. Each program must be structured as a recipe, and valid code should also result in an actual dish that can be prepared. The challenge lies in crafting a recipe that is both syntactically correct and edible, making Chef an unusual but engaging way to experiment with coding.

Instead of traditional syntax, it presents code as recipes, adhering to three key principles:

• The output should be both a valid program and an actual dish that can be prepared;
• Recipes should cater to different budgets;
• Measurements should follow the metric system.

This means that Chef programs must be both executable and edible.

reMorse

ReMorse, created by Ryan Kusnery, is a programming language designed to resemble Morse code. It operates using only four instructions: dot (.), dot followed by a space (.), dash (-), and dash followed by a space (-).

Due to its ambiguous specifications, ReMorse2 was later introduced to refine its structure. Below is a partial example of how “Hello, World!” would be written in ReMorse:

– – – ..- …-.—.;newline

– – – .-. – ..-.- …-. —.;!

– – – …- . . -.—.;d

—-. . . -.—.;l

—-. . -…—.;r

—-. -…—.;o

—-…-.- ..-. —.;W

Though not practical for conventional programming, ReMorse demonstrates how coding can be reimagined through unconventional formats.

l33t

Anyone who has spent time online has likely encountered l33t sp34k (leet speak), where letters and words are substituted with numbers and intentionally altered spelling.

Inspired by this, programmers Stephen McGreal and Alex Mole decided to turn l33t speak into a full-fledged programming language. Like many esoteric languages, l33t was designed to be as difficult as possible to read and write—intentionally making coding a challenge.

Here’s what “Hello, World!” looks like in l33t:

 // “Hello World” by Stephen McGreal.

 // Note that the views expressed in this source code

 // do not necessarily coincide with those of the author :o)

 Gr34t l33tN3$$?

 M3h…

 iT 41n’t s0 7rIckY.

 l33t sP33k is U8er keWl 4nD eA5y wehn u 7hink 1t tHr0uGh.

 1f u w4nn4be UB3R-l33t u d3f1n1t3lY w4nt in 0n a b4d4sS h4xX0r1ng s1tE!!! ;p

 w4r3Z c0ll3cT10n2 r 7eh l3Et3r!

 Qu4k3 cL4nS r 7eh bE5t tH1ng 1n teh 3nTIr3 w0rlD!!!

 g4m3s wh3r3 u g3t to 5h00t ppl r 70tAl1_y w1cK1d!!

 I’M teh fr4GM4stEr aN I’lL t0t41_1Ly wIpE teh phr34k1ng fL00r ***j3d1 5tYlE*** 

 wItH y0uR h1dE!!!! L0L0L0L!

 t3lEphR4gG1nG l4m3rs wit mY m8tes r34lLy k1kK$ A$$

 l33t hAxX0r$ CrE4t3 u8er- k3wL 5tUff lIkE n34t pR0gR4mm1nG lAnguidGe$…

 s0m3tIm3$ teh l4nGu4gES l00k jUst l1k3 rE41_ 0neS 7o mAkE ppl Th1nk th3y’r3 ju$t 

 n0rMal lEE7 5pEEk but th3y’re 5ecRetLy c0dE!!!!

 n080DY unDer5tAnD$ l33t SpEaK 4p4rT fr0m j3d1!!!!!

 50mE kId 0n A me$$4gEb04rD m1ghT 8E a r0xX0r1nG hAxX0r wH0 w4nT2 t0 bR34k 5tuFf, 

 0r mAyb3 ju5t sh0w 7eh wAy5 l33t ppl cAn 8E m0re lIkE y0d4!!! hE i5 teh u8ER!!!!

 1t m1ght 8E 5omE v1rus 0r a Pl4ySt4tI0n ch34t c0dE.

 1t 3v3n MiTe jUs7 s4y “H3LL0 W0RLD!!!” u ju5t cAn’T gu3s5.

 tH3r3’s n3v3r anY p0iNt l00KiNg sC3pT1c4l c0s th4t, be1_1Ev3 iT 0r n0t, 

 1s whAt th1s 1s!!!!!

 5uxX0r5!!!L0L0L0L0L!!!!!!!

Malbolge

Named after the eighth circle of Hell in Dante’s Inferno, Malbolge is an intentionally impossible programming language. Created by Ben Olmstead in 1998, it was designed to be so complex that even its first working program was not written by a person—it was generated by an algorithm.

It took two years for the first working Malbolge program to be created. Here’s what “Hello, World!” looks like in this nearly unreadable language:

(=<`#9]~6ZY32Vx/4Rs+0No-&Jk)”Fh}|Bcy?`=*z]Kw%oG4UUS0/@-ejc(:’8dc

Taxi

Unlike traditional code, Taxi is structured like a roadmap. Created as the official programming language of Townsville, it replaces conventional coding elements like variables and functions with places, cities, and taxi routes.

In Taxi, you transport passengers along mapped-out routes, picking up and dropping them off at various locations while ensuring that taxis remain fueled.

Here’s how to print “Hello, World!” in Taxi language:

“Hello, World!” is waiting at the Writer’s Depot.  

Go to Writer’s Depot: west 1st left, 2nd right, 1st left, 2nd left.  

Pickup a passenger going to the Post Office.  

Go to the Post Office: north 1st right, 2nd right, 1st left.  

Go to the Taxi Garage: north 1st right, 1st left, 1st right. 

ZOMBIE

ZOMBIE is a programming language crafted for necromancers—those who seek to command the dead. It enables developers to animate corpses, summon spirits, and process computational tasks using supernatural forces.

To ensure safe execution, ZOMBIE guarantees that system memory remains intact, preventing any malicious entities from slipping through the cracks. However, syntax errors in this language can be catastrophic—incorrect binding commands may unleash demons into the physical world, leading to unpredictable consequences.

ZOMBIE follows a declarative entity-based structure, where programs consist of summoned entities that carry out specific tasks. Data values in this language are freeform but still follow standard mathematical rules.

Here’s how to print “Hello, World!” using ZOMBIE:

HelloWorld is a zombie

summon

task SayHello

say “Hello, World!”

animate

animate

BIT

BIT is a minimalist, low-level programming language that grants complete access to ASCII-based data representation. Unlike high-level languages, BIT relies on direct data manipulation using a binary-centric syntax, making it a complex yet intricate language for those who seek precise control.

In BIT, there are only two data types:

bit (single binary value)

address-of-a-bit (location reference)

While the language enforces strict strong typing, it surprisingly supports the GOTO command, allowing for unconventional flow control. BIT also tolerates any amount of whitespace and line breaks within its syntax.

Below is an example of “Hello, World!” written in BIT:

LINE NUMBER ZERO CODE PRINT ZERO GOTO ONE ONE ZERO ONE  

LINE NUMBER ONE CODE PRINT ZERO GOTO ONE ZERO  

LINE NUMBER ONE ONE CODE PRINT ZERO GOTO ONE ZERO ZERO ONE ZERO  

LINE NUMBER ONE ZERO CODE PRINT ONE GOTO ONE ONE  

LINE NUMBER ONE ONE ONE CODE PRINT ONE GOTO ONE ZERO ONE  

LINE NUMBER ONE ZERO ONE CODE PRINT ZERO GOTO ONE ONE ZERO  

…

(And the list goes on, forming a brutal, binary-driven representation of text output.)

Unlambda

Unlambda is an obfuscated, functional programming language where everything is a function—even data itself. Unlike conventional languages, Unlambda does not allow variable storage or direct data manipulation. Instead, programs are constructed using anonymous functions that cannot be named or saved.

Every function in Unlambda takes exactly one other function as an argument and returns another function, making it a pure function composition language. While it does support working with data structures, they must be represented as ad-hoc functions, maintaining the language’s extreme functional nature.

Here’s how to print “Hello, World!” in Unlambda:

“`s“sii`ki

“s“s`ks

“s“s`ks“s`k`s`kr

“s`k`si“s`k`s`k

`d““““““.H.e.l.l.o.,. .W.o.r.l.d.!

k

k

`k“s“s`ksk`k.*

Java2K

Java2K is a probabilistic programming language that applies the uncertainty of the universe. Instead of executing commands deterministically, Java2K selects random implementations at runtime. Even built-in functions may not behave as expected, reinforcing the idea that “there is never absolute security, only probability”.

This language operates on an 11-based number system (digits 0-9 plus 10), making arithmetic unconventional. Programs always require two arguments, even when only one is needed. Java2K enforces strict security checks at the source code level, yet its randomness ensures no two executions behave exactly the same.

Here’s what printing “Hello, World!” looks like in Java2K:

1 1 /125 /131 /119 /125 /11 6/*/_\/_\/125 /13 2  

/*/_\/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2  

/*/_\/_\\/119 /125 /11 6/*/_\/_\/125 /13 2/*/_\  

/_\\\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/  

_\/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/  

_\/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/  

_\/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/  

…

(The randomness and unconventional syntax make predictability a luxury in Java2K.)

Deadfish

Deadfish is an esoteric programming language created in just a few hours using C, featuring only four commands. Notably, it has no way to accept user input—only outputs are possible. The language operates solely on integer values and allows only incrementing, decrementing, squaring, and outputting numbers.

Unlike structured programming languages, Deadfish has no error handling—invalid operations simply produce a blank line. The name “Deadfish” was chosen because programming in it feels as frustrating as eating rotten fish.

Here’s how “Hello, World!” is printed in Deadfish:

iisiiiisiiiiiiiioiiiiiiiiiiiiiiiiiiiiiiiiiiiiioiiiiiiiooiiio  

dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddo  

dddddddddddddddddddddsddoddddddddoiiioddddddoddddddddo  

Emmental

Emmental is a stack-based, self-modifying programming language that operates using a meta-circular interpreter. With only 13 instructions, its stack can hold only ASCII characters. Although it lacks direct support for conditional branching, programmers can achieve it using the ‘?’ eval instruction.

Despite its obscure nature, Emmental is more readable than some esoteric languages due to its English-like semantics. It allows for primitive arithmetic, stack and queue manipulation, and more.

“Hello, World!” in Emmental:

;#58#126#63#36!;#46#36#!;#0#1!;#0#2!;#0#3!;#0#4!;#0#5!;#0#6!;#0#7!#0#33#100#108#114#111#119#32#44#111#108#108#101#72$

Whenever

Whenever is a programming language that refuses to follow any fixed execution sequence. Instead of executing commands in order, it runs them whenever it feels like it—adding a layer of randomness and unpredictability to coding.

It does not support variables or data structures, as it disregards traditional program sequencing. However, it provides constructs to reassign values dynamically if a command depends on an unready prerequisite.

“Hello, World!” in Whenever:

1 print(“Hello, World!”);

(Though it may or may not run immediately—or ever.)

INTERCAL

INTERCAL (“Compiler Language With No Pronounceable Acronym”) was designed as a parody of traditional programming languages. It introduces absurd features like “PLEASE,” “FORGET,” and “IGNORE” as commands. If a programmer fails to use “PLEASE” often enough, the compiler considers the program impolite and throws an error.

Despite being deliberately frustrating, INTERCAL provides data structures, operators, and control structures, though they do not make programming in it any easier.

“Hello, World!” in INTERCAL:

DO ,1 <- #13  

PLEASE DO ,1 SUB #1 <- #238  

DO ,1 SUB #2 <- #108  

DO ,1 SUB #3 <- #112  

DO ,1 SUB #4 <- #0  

DO ,1 SUB #5 <- #64  

DO ,1 SUB #6 <- #194  

DO ,1 SUB #7 <- #48  

PLEASE DO ,1 SUB #8 <- #22  

DO ,1 SUB #9 <- #248  

DO ,1 SUB #10 <- #168  

DO ,1 SUB #11 <- #24  

DO ,1 SUB #12 <- #16  

DO ,1 SUB #13 <- #162  

PLEASE READ OUT ,1  

PLEASE GIVE UP  

Orthogonal

Orthogonal is a 2D programming language where execution can move in any direction. Unlike traditional linear execution, flow control is completely flexible, making it an experimental proof-of-concept language.

The language consists of two primary elements:

• The Grid (functions like an array)
• The Stack (a single-dimensional data structure)

It categorizes instructions into operators, directives, and miscellaneous commands, offering more structure than Deadfish or BIT.

“Hello, World!” in Orthogonal:

0 ‘d’ ‘l’ ‘r’ ‘o’ ‘w’ ‘ ‘ ‘,’ ‘o’ ‘l’ ‘l’ ‘e’ ‘h’ s 0 c 0 ret

Conclusion

Weird programming languages showcase the creativity and humor that can exist within coding. While they may not be practical for everyday development, they show that programming is not just about efficiency but can also be a form of expression. These languages challenge conventional thinking, introduce unique problem-solving approaches, and bring an element of fun to software development. Whether designed as experiments, jokes, or artistic endeavors, they highlight the flexibility and diversity within the programming world.