25 Most Bizarre Programming Languages

Some folks say learning to code is tough, boring, and really hard. It’s like learning an entirely new way to talk to a machine and telling it exactly what to do. But believe it or not, there are people who think programming isn’t complicated enough, so they created something even more challenging.

Welcome to the world of esoteric programming languages, also known as esolang. Here, programmers take language design to a whole new level. These languages aren’t meant to be easy. On the contrary, they’re designed to challenge, frustrate, and entertain programmers with their difficulty. There are plenty of esolangs to explore, but I’ve handpicked 25 of the weirdest and craziest ones out there.

5 Cool New Programming Languages to Check Out

Being a developer is a popular career choice, and it’s difficult to think otherwise. Now let’s explore some unique programming languages that are sure to pique your interest!

1. Brainf*ck

True to its name, this coding language is guaranteed to give any programmer an instant headache. Created by Urban Müller in 1993, Brainf*ck was designed to be implemented by a small compiler, purely for the amusement of programmers.

What makes Brainf*ck so fascinating is its extreme minimalism. It only consists of eight commands and an instruction pointer, each represented by a single character. Below is a code snippet that will undoubtedly leave you scratching your head – it prints out ‘Hello World!’:

[ as the cell will be cleared by the loop

>++ Add 2 to Cell #2

>+++ Add 3 to Cell #3

>+++ Add 3 to Cell #4

>+ Add 1 to Cell #5

+ Add 1 to Cell #2

>+ Add 1 to Cell #3

>- Subtract 1 from Cell #4

>>+ Add 1 to Cell #6 [>. Cell #2 has value 72 which is ‘H’

>—. Subtract 3 from Cell #3 to get 101 which is ‘e’

+++++ ++..+++. Likewise for ‘llo’ from Cell #3

>>. Cell #5 is 32 for the space

2. LOLCODE

Have you ever heard of LOLCODE? It’s a language that’s all about lolspeak, the kind of language that lolcats use. It was created by Adam Lindsay in 2007, a researcher at Lancaster University’s Computing Department. Unlike traditional languages, though, LOLCODE isn’t as complete. Its syntax and operator priorities can be a little fuzzy. But don’t worry! There are compilers available for it that actually work. So you can still have fun with it!

The language may not be easy to comprehend, but it is undeniably amusing and adorable. Just take a peek at the code for saying “Hello World!” below:

HAI CAN HAS STDIO? VISIBLE “Hello World!” KTHXBYE

Now let’s move on to Befunge, a language developed by Chris Pressey in 1993. Its purpose was to create a language that would be extremely challenging to compile.

To accomplish this, Pressey incorporated self-modifying code and a complex instruction set that allowed the same instruction to be executed in four different ways. Despite the difficulty, several compilers were eventually created. Here’s the source code for the famous “Hello World!” program in Befunge:

> v v . “Hello”

>48*, v v. “World!”

>25*,@

Last but not least, let’s explore ArnoldC, named after the one and only Arnold Schwarzenegger. This language is more than just a novelty; it’s a fully functional programming language inspired by Schwarzenegger’s iconic movie lines.

We can’t resist sharing a snippet of the “Hello World!” code in ArnoldC:

IT’S SHOWTIME

TALK TO THE HAND “Hello World!”

YOU HAVE BEEN TERMINATED

These quirky languages may be perplexing, but they certainly add a dash of excitement and humor to the world of programming.

Hey there! Did you know that there’s a programming language called ArnoldC? It’s pretty cool because it’s made up entirely of famous one-liners from Arnold Schwarzenegger movies like Terminator, Predator, and Total Recall. The person behind this genius idea is Lauri Hartikka. Instead of using regular programming commands, he replaced them with Arnold’s iconic one-liners.

Let me give you an example. In ArnoldC, the words False and True are represented as “I LIED” and “NO PROBLEMO” respectively. Now, here’s how you would write a basic “Hello World!” code:

IT’S SHOWTIME TALK TO THE HAND “Hello World!” YOU HAVE BEEN TERMINATED

5. Shakespeare

If you’re not into bodybuilding Austrian actors, you might find the Shakespeare programming language more intriguing. Jon Aslund and Karl Hesselstörm created this language with the goal of making it look nothing like a programming language. Instead, the source code resembles a Shakespeare play.

In this unique language, variables must be named after Shakespearean characters, and constants are chosen based on positive or negative nouns.

One of the most famous programs in the Shakespeare language is the “Hello World!” program. It’s quite long and reads just like a play. Here’s a snippet of the source code:

“`

The Infamous Hello World Program.

Romeo, a young man with a remarkable patience.

Juliet, a likewise young woman of remarkable grace.

Ophelia, a remarkable woman much in dispute with Hamlet.

Hamlet, the flatterer of Andersen Insulting A/S.

Act I: Hamlet’s insults and flattery.

Scene I: The insulting of Romeo.

[Enter Hamlet and Romeo]

Hamlet: You lying stupid fatherless big smelly half-witted coward!

You are as stupid as the difference between a handsome rich brave hero and thyself!

Speak your mind!

You are as brave as the sum of your fat little stuffed misused dusty old rotten codpiece and a beautiful fair warm peaceful sunny summer’s day.

You are as healthy as the difference between the sum of the sweetest reddest rose and my father and yourself!

Speak your mind!

You are as cowardly as the sum of yourself and the difference between a big mighty proud kingdom and a horse.

Speak your mind.

Speak your mind!

[Exit Romeo]

“`

If you’re curious about this unconventional programming language, you can explore the full “Hello World!” program and other examples.

6. Chef

Imagine if a programming language looked like a cooking recipe! Meet Chef, a unique programming language created by David Morgan-Mar. It’s unlike any other language you’ve seen before.

Chef is designed with a simple goal in mind: the code you write should not only produce valid output but should also be easy to prepare and delicious. Just like a good recipe, Chef appeals to cooks with different budgets and uses the metric system.

In simpler terms, Chef’s recipes are not only functional code, but they can also be cooked and enjoyed as real dishes!

Curious to see an example? Take a look at the ‘Hello World!’ program recipe below:

Hello, foodie! Get ready to feast your eyes and taste buds on a mouthwatering creation – the Hello World Souffle. This recipe will have you saying “Hello world!” in the most delicious way possible. And let me tell you, it makes a whole lot of food for just one person! So, gather your ingredients and let’s get cooking.

Here’s what you’ll need for this adventurous culinary journey:

– 72 grams of haricot beans

– 101 eggs

– 108 grams of lard

– 111 cups of oil

– 32 zucchinis

– 119 milliliters of water

– 114 grams of red salmon

– 100 grams of Dijon mustard

– 33 potatoes

Now that we have everything we need, let’s dive into the method:

1. Start by putting the potatoes into the mixing bowl.

2. Next, add the Dijon mustard, lard, red salmon, oil, water, and zucchinis to the mixing bowl.

3. Don’t forget to add the lard again – yes, twice!

4. Now, crack the eggs and add them to the mixture.

5. Finally, add the haricot beans to the mixing bowl.

Once all the ingredients are in the bowl, it’s time to work some magic. Give everything a good mix until it’s nice and smooth. You want the flavors to blend together perfectly.

Now, take the mixture and pour it into a baking dish. Get ready for the ultimate transformation! Pop it in the oven and let the souffle work its magic.

And there you have it – a magnificent Hello World Souffle, ready to be devoured. This recipe serves one lucky person, so grab a fork and dig in. Enjoy every bite of this extraordinary masterpiece!

Happy cooking, my fellow food explorer!

Hey there! Did you know that there’s a programming language called Whitespace? It’s actually pretty unique because it was created as an April Fools’ joke by Edwin Brady and Chris Morris.

What makes Whitespace different from other programming languages is that it actually pays attention to whitespace characters instead of ignoring them. Instead of caring about non-whitespace characters, Whitespace uses whitespace as commands.

Now, get this: you can even write Whitespace code inside programming languages that don’t care about whitespace. It’s pretty wild, right?

Check out this cool example below. It’s a ‘Hello World!’ source code written in Whitespace, and I’ve used different colors to make it easier to understand.

8. Piet

Hey there, folks! Ever heard of a programming language inspired by the famous artist Piet Mondrian? Well, let me introduce you to Piet – a quirky creation by David Morgan-Mar.

Now, let’s dive into the fascinating world of Piet. You see, this language is a little different. Instead of using traditional code, it relies on something colorful – yes, colors! The program is made up of a bunch of colors that the compiler reads and turns into a program. How cool is that?

Imagine a little pointer moving around an image, hopping from one colored section to another. Each color represents a different command. It’s like following a trail of colors to create an amazing program!

Take a look at this example of a ‘source code’ in Piet. When compiled, it produces the classic phrase ‘Hello World!’:

9. Chicken

Hey there! Let me tell you about this programming language called Chicken. It’s pretty unique because it only consists of one word: chicken. Can you believe that?! The brilliant mind behind this language is Torbjörn Söderstedt, a programmer from Sweden. He got inspired to create Chicken after listening to an incomprehensible parody speech by Doug Zongker.

Now, you might be expecting to see the code for the classic “Hello World!” program, but let me tell you, it’s not that simple. It would literally take up half the page and just be the word “chicken” repeated over and over again. So, instead, how about I show you the paper and presentation that inspired the creation of this fascinating language? You’ll really get a taste of the genius behind it.

10. Ook!

Alright, buckle up because we’re about to dive into another crazy programming language. This one is called Ook! and it’s actually a derivative of the famous language Brainf*ck. The brain behind Ook! is David Morgan-Mar, a developer who specializes in designing esoteric languages. What makes Ook! different from Brainf*ck? Well, instead of the usual eight commands, Ook! uses combinations of “Ook.”, “Ook?”, and “Ook!”.

Hold on to your hats because this is where it gets even more interesting. Morgan-Mar actually designed Ook! to be “writable and readable by orangutans”. Can you believe that? It’s like a whole new level of accessibility! Okay, now get ready to witness the magic – I’m going to show you the source code for the legendary “Hello World!” program in Ook!.

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

11. reMorse

Hey there, I’m Ryan Kusnery! I created a programming language called reMorse that looks just like Morse code. It’s pretty cool because it only has four instructions: dot (.), dotty (. followed by a space), dash (-), and dasher (- followed by a space).

The specifications for reMorse were a bit unclear, so I decided to make reMorse2 to clean up the code. Here’s an incomplete sample of how you would write ‘Hello World!’ in reMorse:

– – – ..- . -.—.;newline – – – .-. – ..-.- . -. —.;! – – – . – . . -.—.;d —-. . . -.—.;l —-. . -. —.;r —-. -. —.;o —-. -.- ..-. —.;W omitted code for “Hello ” is similar to the above for “World!” -. ;output all characters

12. l33t

Hey, have you ever spent time on the internet? Then I’m sure you’re familiar with l33t sp34k, also known as leet speak. It’s when people intentionally use numbers and bad spelling to substitute words and letters. It’s a unique way of communicating online!

Hey there, let me tell you a cool story! So, there were these two programmers, Stephen McGreal and Alex Mole, who had this brilliant idea to create a whole new programming language! They called it l33t, and it was one of those special languages that are just mind-boggling to code in.

Now, I’m going to show you the source code for a classic program: ‘Hello World!’

// “Hello World” by Stephen McGreal.

// Note that the views expressed in this source code

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

Great l33tN3$$? Meh. It ain’t so tricky. l33t sP33k is U8er keWl and easy when you think it through.

If you wanna be uber-l33t, you definitely want in on a badass h4xX0r1ng site. ;p

Warez collections are the bomb! Quake clans are the best thing in the entire world.

Games where you get to shoot people are totally wicked!! I’M the fr4GM4stEr and I’ll totally wipe the freaking floor ***j3d1 5tYlE*** with your hide.

LOLOLOL! Telephragging lamers with my mates really kicks ass.

l33t hAxX0r$ create uber-cool stuff like neat programming languages.

Sometimes, the languages look just like regular 5p33k to make people think they’re just normal, but they’re secretly code.

Nobody understands l33t speak apart from j3d1. Some kid on a message board might be a rocking hAxX0r who wants to break stuff or maybe just show the ways l33t people can be more like y0d4.

He is the ub3r. It might be some virus or a PlayStation cheat code.

It might even say “Hello World.” You just can’t guess.

There’s never any point looking skeptical ’cause that, believe it or not, is what this is. SuxX0r5. L0L0L0L0L.

13. Omgrofl

I can’t help but laugh when I hear about Omgrofl (which is short for ‘oh my god rolling on the floor’). It was invented by Juraj Borza, and what makes it so funny is that all the commands are made up of internet acronyms like lol, wtf, brb, stfu, and more. It’s like speaking the language of the internet!

Imagine this as the ‘Hello World!’ code in Omgrofl:
lol iz lol looooool iz lool rtfm wtf looooool iz liek 0 tldr brb lmao loool roflmao looooool brb

14. Velato

Here’s something really cool – a language called Velato, created by Daniel Temkin, that uses MIDI files as its source code. The commands in Velato are determined by the pitch and order of musical notes. And what’s interesting is that when you run the source code created in Velato, it sounds like a jazzy tune!

This is what the ‘Hello World!’ code looks like in Velato:

15. Malbolge

When a programming language is named after the eighth circle of Hell, you can expect something truly challenging. Created by Ben Olmstead in 1998, Malbolge was intentionally designed to be nearly impossible to program.

What makes it even more intriguing is that it wasn’t created by humans. Malbolge was generated using an algorithm, which explains why it took a whole two years for the program to materialize. To give you an idea of the mind-bending complexity of this programming language, here is the source code for a simple ‘Hello World!’ program:

(= Bcy?`=*z]Kw%oG4UUS0/@-ejc(:’8dc

16. Taxi

Taxi is an intriguing programming language that uses maps as its foundation. It’s like a roadmap for coders, making it easy to understand for road travelers, but not as simple to code itself. In the bustling city of Townsville, they have replaced the traditional coding language with this modern map-based language. Instead of variables, classes, or functions, Taxi uses places and cities as its building blocks.

When you delve into Taxi, you become a master of taxi routes. Your goal is to transport passengers from one place to another, and to do so, you need to provide detailed instructions about directions, pickups, and drop-offs. Of course, just like real taxis, your virtual taxis need fuel to run. Passengers pay for their rides, and you earn cash for refueling your taxi at the gas stations.

Now, let’s take a look at how you say “Hello, World!” in the Taxi language:

Hey there! ��️ The Writer’s Depot is where you’ll find the famous phrase, “Hello, World!” Want to head there? Okay, here’s the route: Go west on the first street, take a left, then turn right on the second street. After that, take another left, and finally, turn left once more on the second street. Got it? Great! Now, at the Writer’s Depot, your mission is to pick up a passenger who needs a ride to the Post Office. To get there, go north on the first street, then turn right on the second street, and take another right. Finally, make a left on the first street, and voila, you’ve arrived! Whew, that was quite a route! But wait, there’s more! Next, you need to head to the Taxi Garage. Go north on the first street, then turn right, followed by a left, and finally, make a right turn. Phew! All done. Safe travel! ��

Now, let’s talk about something fascinating: ZOMBIE! ��‍♂️ ZOMBIE is no ordinary programming language. It’s specifically designed for necromancers, which are folks who practice magic and communicate with the dead. With ZOMBIE, coders can write code that brings dead bodies to life, controls spirits, and even solves problems using these supernatural entities. Pretty wild, right? But don’t worry, ZOMBIE has your back. It’s built with a special guarantee: it won’t mess with system memory or release any nasty stuff into the world. So, you can code with confidence and explore the realm of the undead. Happy coding! ����

In the world of programming, there’s a language called ZOMBIE that uses a unique approach to coding with its entity declarations. If you’re not careful, though, syntax errors in ZOMBIE can lead to disastrous consequences, as they can release demons from the CPU and wreak havoc. So it’s crucial to be precise!

One interesting thing about ZOMBIE is that its data values are free format. This means you have the flexibility to work with them in any way you like, as long as you follow the rules of standard mathematics.

Let’s take a look at an example of how you can print “Hello, World!” in the ZOMBIE language:

HelloWorld is a zombie summon task

SayHello say “Hello, World!” animate animate

18. BIT

Now, let’s talk about BIT. It’s a powerful low-level programming language that gives you total control over your data in its ASCII implementation. Unlike high-level languages, BIT is less complicated when it comes to manipulating data because it uses specialized functions for abstract data types.

BIT has two data types: bit and address-of-a-bit. With these, you can work wonders and unleash your coding skills!

In BIT, I can use operators and commands to manipulate data values. This language is strict about declaring the type of data and actually lets you use the controversial “GOTO” command to control the flow. The cool thing about BIT is that it allows for any amount of whitespace and line breaks between the different parts of the code.

Let me show you an example of how to print “Hello, World!” in BIT:

LINE NUMBER ZERO CODE PRINT ZERO GOTO ONE

ONE ZERO CODE PRINT ZERO GOTO ONE

ONE ONE CODE PRINT ZERO GOTO ONE ZERO ZERO ONE ZERO

ONE ZERO CODE PRINT ONE GOTO ONE ONE

ONE ONE ONE CODE PRINT ONE GOTO ONE ZERO ONE

ONE ZERO ONE CODE PRINT ZERO GOTO ONE ONE ZERO

ONE ONE ZERO CODE PRINT ONE GOTO ONE ZERO ZERO

ONE ZERO ZERO CODE PRINT ONE GOTO ONE ONE ONE ONE

ONE ONE ONE ONE CODE PRINT ZERO GOTO ONE ZERO ONE ONE

ONE ZERO ONE ONE CODE PRINT ZERO GOTO VARIABLE ONE

ONE ONE ZERO ONE CODE PRINT ONE GOTO ONE ONE ONE ZERO

ONE ONE ONE ZERO CODE PRINT ZERO GOTO ONE ZERO ZERO ONE

ONE ZERO ZERO ONE CODE PRINT ZERO GOTO ONE ZERO ONE ZERO

ONE ZERO ONE ZERO CODE PRINT ONE GOTO ONE ONE ZERO ZERO

ONE ONE ZERO ZERO CODE PRINT ZERO GOTO ONE ZERO ZERO ZERO

ONE ZERO ZERO ZERO CODE PRINT ZERO GOTO ONE ONE ONE ONE ONE

ONE ONE ONE ONE ONE CODE PRINT ZERO GOTO ONE ZERO ONE ONE ONE

ONE ZERO ONE ONE ONE CODE PRINT ZERO GOTO ONE ONE ZERO ONE ONE

ONE ONE ZERO ONE ONE CODE PRINT ONE GOTO ONE ONE ONE ZERO ONE

ONE ONE ONE ZERO ONE CODE PRINT ONE GOTO ONE ONE ONE ONE ZERO

ONE ONE ONE ONE ZERO CODE PRINT ZERO GOTO ONE ZERO ZERO ONE ONE

ONE ZERO ZERO ONE ONE CODE PRINT ZERO GOTO ONE ZERO ONE ZERO ONE

ONE ZERO ONE ZERO ONE CODE PRINT ONE GOTO ONE ZERO ONE ONE ZERO

ONE ZERO ONE ONE ZERO CODE PRINT ZERO GOTO ONE ONE ZERO ZERO ONE

ONE ONE ZERO ZERO ONE CODE PRINT ONE GOTO ONE ONE ZERO ONE ZERO

ONE ONE ZERO ONE ZERO CODE VARIABLE ONE EQUALS ONE ONE ONE ZERO ZERO GOTO ONE

ONE ONE ONE ZERO ZERO CODE VARIABLE ONE EQUALS ONE ZERO ZERO ZERO ONE GOTO ONE

ONE ZERO ZERO ZERO ONE CODE VARIABLE ONE EQUALS ONE ONE ONE ONE ZERO ONE GOTO ONE ONE

ONE ZERO ZERO ONE ZERO CODE PRINT ONE GOTO ONE ZERO ONE ZERO ZERO

ONE ZERO ONE ZERO ZERO CODE PRINT ONE GOTO ONE ONE ZERO ZERO ZERO

ONE ONE ZERO ZERO ZERO CODE PRINT ZERO GOTO ONE ZERO ZERO ZERO ZERO

ONE ZERO ZERO ZERO ZERO CODE PRINT ONE GOTO ONE ONE ONE ONE ONE ONE

ONE ONE ONE ONE ONE ONE CODE PRINT ONE GOTO ONE ZERO ONE ONE ONE ONE

ONE ZERO ONE ONE ONE ONE

19. Unlambda

Hey there! Let me tell you about Unlambda, a pretty unique programming language that combines obfuscated and functional paradigms. In Unlambda, everything is a function – even the data itself! It’s a bit mind-boggling, I know. But stay with me on this.

Unlambda takes away some important features that you might be used to. For starters, there’s no way to store data or use variables. Yep, you heard me right. And if that wasn’t enough, you can create functions, but unfortunately, you can’t name or save them. Bummer.

Now, here’s the thing: Unlambda is all about functions. Every function in Unlambda takes one other function as an argument and returns… you guessed it, another function! No more, no less. So, if you want to get anything done in Unlambda, you better get cozy with these nested functions.

Don’t worry, though. Unlambda does allow you to work with data structures and such. The catch is that you have to represent them as ad-hoc functions. I mean, who needs plain old data when you can have everything as a function, right?

Just to give you a taste of this quirky language, here’s an example of how you would print “Hello, World!” in Unlambda:

Hey, everyone! It’s me, Java2K! Can you believe it? I’m a language that operates in a pretty unique way. You see, I work with probabilities and the unpredictable nature of the universe. Absolute security? Not really a thing in my world. It’s all about probability, my friends.

Now, let me tell you, I don’t always do exactly what you want me to do. Even my built-in functions can be a little funky. But hey, that’s what keeps things interesting, right? Plus, I’ve got some nifty features up my sleeve that make me worth checking out.

First off, I’ve got this nifty source-code level checking for security. It’s like having a guard watching over your code to make sure it’s all safe and sound. It gives you some peace of mind, you know?

And here’s something really cool: I use an 11-based number system. Most people are used to counting up to 9 and then moving on to 10. But not me, I like to keep things interesting. I count up to 9 and then include 10 in my system. It’s a little different, but it works!

So that’s me in a nutshell. I might not always do what you expect, but I’ve got some tricks up my sleeve and a unique way of doing things. Give me a try and see what you think!

In Java2K, the program always has two arguments, even when you only need one. There are two types of numbers: names of objects and integer values. Java2K has multiple implementations for each function, and one of them is randomly chosen at runtime. The language also has specific restrictions on valid keywords and functions, and it includes a garbage collector to automatically release memory.

Here’s an example of how to print “Hello, World!” in Java2K language:

“`

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/*/ _\/_\\/119 /125 /11 6/*/_\/_\/125 /13 2/*/_\/_\ \\\\\\\/*\1 1 /125 /119 /11 6/*/_\/13 2/*/_\\/ 125 /131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/_\ /_\\/119 /125 /11 6/*/_\/_\/125 /13 2/*/_\/_\\\ /125 /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/*/_ \/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/_ \/_\\/119 /125 /11 6/*/_\/_\/125 /13 2/*/_\/_\\\ \\\\\\\/*\1 1 /125 /131 /119 /125 /11 6/*/_\/_\ /125 /13 2/*/_\/_\\/119 /125 /11 6/*/_\/_\/ 125 /13 2/*/_\/_\\\/125 /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/*/_ \/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/_ \/_\\/119 /125 /11 6/*/_\/_\/125 /13 2/*/_\/_\\\ \\\\\\\\\\\/*\1 1 /131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/_\/_\\/119 /125 /11 6/*/_\/_\/ 125 /13 2/*/_\/_\\\/125 /131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/_\/_\\/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/*/_\/ _\\/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/*/_\/ _\\/119 /125 /11 6/*/_\/_\/125 /13 2/*/_\/ _\\/125 /13 2/*/_\/\ \\\\/*\1 1 /131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/_\/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/_\/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/_\/_\\/119 /125 /11 6/*/_\/_\/125 /13 2/*/_\/_\\/125 /131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/_ \/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/_ \/_\\/119 /125 /11 6/*/_\/_\/125 /13 2/*/_\/_\\ \\/125 /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/* /_\/_\/131 /119 /125 /11 6/*/_\/_\/125 /13 2/* /_\/_\/119 /125 /11 6/*/_\/_\/125 /13 2/*/_\/_\\\\ \\\\\\/*\1 1 /125 /131 /119 /125 /11 6/*/_\/_\/ 125 /13 2/*/_\/_\\/119 /125 /11 6/*/_\/_\/125 / 13 2/*/_\/_\\\/125 /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/*/_\/_\\/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/*/_\/ _\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/_\/ _\\/119 /125 /11 6/*/_\/_\/125 /13 2/*/_\/ _\\/125 /13 2/*/_\/\ \\\\/*\1 1 /125 /119 /125 /11 6/*/_\/_\/ 125 /13 2/*/_\/_\\/119 /125 /11 6/*/_\/_\/125 / 13 2/*/_\/_\\\/125 /131 /119 /125 /11 6/*/_\/_\ /125 /13 2/*/_\/_\\/ 131 /119 /125 /11 6/*/_\/_\ /125 /13 2/*/_\/_\\/ 119 /125 /11 6/*/_\/_\ /125 /13 2/*/_\/_\\ \\/125 /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

21. Deadfish

Hey there, let me tell you about Deadfish – a totally bizarre language that someone whipped up in just a few hours using the C language. It’s got a grand total of 4 commands, all for outputting things, mind you, but none for taking any input (I know, sounds weird, right?).

Now, this language is a stickler for details. It’s case-sensitive, and when it comes to numbers, it can only play around with integers and add or subtract them.

Here’s the kicker though – its standard shell won’t tolerate anything that’s not a command. Quick and snappy, just like that. Oh, and good luck trying to catch or report any errors while running the code. Nope, the shell just gives you a friendly little newline to let you know something’s gone haywire.

As if things couldn’t get weirder, they even called it “Deadfish” because programming in this language is about as much fun as chowing down on a plate of rotten fish. Yikes!

Just to give you a taste of this madness, let me show you how you can print a classic “Hello, World!” message in Deadfish language:

I am Emmental, a programming language unlike any other. I am defined by a meta-circular interpreter, which means I have the unique ability to modify myself. I operate using a stack-based system, which means I manipulate chunks of data called “instructions” by placing them on top of each other. I only have 13 instructions in total.

But what sets me apart is that my stack can only store ASCII characters. This may sound limiting, but it actually encourages creativity and problem-solving. I believe that sometimes limitations can lead to incredible innovation.

One of the fascinating aspects of Emmental is how it handles conditional branching. While not directly supported, it can be accomplished using the eval instruction ‘?’. This means you can create conditional statements and execute different sets of instructions based on certain conditions.

In a sea of programming languages, I stand out as a truly unique and intriguing option. I am not for the faint of heart, but for those who are willing to dive into the unknown and explore the boundaries of what is possible. Are you up for the challenge?

Emmental is a fascinating language that may look strange, but don’t let that fool you. Unlike other confusing languages, Emmental is actually quite user-friendly. You can do basic math operations, manipulate stacks and queues (yes, it even has a queue!), and much more with Emmental.

Let me show you an example of how to print “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$

Here’s an interesting fact: Emmental gets its name because it’s full of holes, just like the famous Swiss cheese. These “holes” are actually code points, which are represented by numbers in Emmental. So, the example above is a sequence of code points that spell out “Hello, World!” when interpreted.

If you’re wondering how this works, don’t worry – I was confused too at first! But once you get the hang of it, Emmental can be quite powerful. So go ahead and give it a try! You never know what you might create with this unique language.

Whenever is a programming language that has its own unique way of doing things. It doesn’t follow the normal order of operations that programmers are used to. Instead, it does things whenever it wants to, without any specific sequence or urgency.

Imagine the chaos that could ensue if you sent an email to your boss without checking for spelling mistakes first. That’s exactly what you can expect with Whenever – a nightmare scenario.

What sets Whenever apart is its disregard for variables and data structures. It doesn’t care about program sequence, so it doesn’t bother with these things. However, it does have mechanisms in place to handle situations where a certain line of code needs something that hasn’t been prepared yet.

Unlike some other languages, Whenever does support strings and compound statements, which can be quite useful.

Here’s an example of how to print “Hello, World!” in Whenever:

1 print(“Hello, World!”);

24. INTERCAL

INTERCAL, also known as Compiler Language With No Pronounceable Acronym, is a language that pokes fun at various programming languages. This quirky language confuses programmers with strange statements like ‘PLEASE,’ ‘FORGET,’ ‘IGNORE,’ and more. If you don’t use ‘PLEASE’ often enough, the program is considered impolite, and the compiler will report it as an error. (Because programming isn’t programming without a bit of torture, right?)

INTERCAL stands out from other programming languages. Unlike obfuscated languages like Unlambda and Deadfish, INTERCAL actually provides lots of data structures, operators, and control structures. But even with all these features, it remains complex, keeping programmers on their toes.

Let me show you an example of how to say “Hello, World!” using the INTERCAL language:

DO ,1

25. Orthogonal

In the world of programming languages, there’s one called Orthogonal that’s quite unique. What makes it special? Well, in Orthogonal, the flow can go in any direction you want. It’s like a playground where you can move freely.

Orthogonal is a 2-dimensional language, which means it’s not restricted to just lines of code like other languages. Instead, it allows you to write code in a grid-like structure. It’s like a puzzle where you can place your commands wherever you like.

In Orthogonal, you’ll find different types of instructions. There are operators that perform actions, directives that give instructions, and other elements that offer additional functionality. It’s like having a toolbox with various tools at your disposal.

But that’s not all! Orthogonal also gives you the ability to work with data values and variables. This means you can store information and manipulate it as needed. It’s like having a notebook where you can write down and modify your thoughts.

Imagine this: I bet you’ve never heard of a programming language called Orthogonal. Don’t worry, you’re not alone. It’s definitely not your everyday language.

Let me show you an example of Orthogonal in action. Brace yourself for “Hello, World!” written in Orthogonal:

“`js

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

“`

Now, I know what you’re thinking: “What in the world is going on here?” Trust me, I had the same reaction.

Here’s what’s happening: the code starts with a bunch of weird numbers and single characters. But after that, we see a string of characters in single quotes: `’d’ ‘l’ ‘r’ ‘o’ ‘w’ ‘ ‘ ‘,’ ‘o’ ‘l’ ‘l’ ‘e’ ‘h’`.

If we take a closer look, we can see that these characters spell out “Hello, World!” in reverse. So that’s the message Orthogonal is trying to convey. It wants to say “Hello, World!” but in a very peculiar way.

The remaining part of the code is made up of numbers and a few more single characters. Honestly, I have no idea what they mean or how they contribute to the overall message. But the Orthogonal language must have its reasons.

In the end, it’s safe to say that Orthogonal is not your average language. It loves to do things differently and keep you on your toes. It’s like solving a puzzle. You just have to put the pieces together and hope it all makes sense in the end.

So, that’s Orthogonal for you. A perplexing language that challenges our understanding of what programming can be. Will we ever fully grasp its intricacies? Only time will tell.