An Almanac of Assorted Atypical programming languages

2026-02-03

There are certain features that are almost expected to be in a programming language these days - numbers, characters, strings, mathematical operations, objects. For people who grew up programming in python(or worse, javascript), any non-object-oriented programming language will feel unusual and strange. While I have included some functional programming languages, they are not the main focus. Here, I mostly document programming languages which require a really unusual approach to how you structure algorithms and organize your data.

1. Golang

https://go.dev/

A programming language with a similar syntax to C. There are no objects as such, however, you can create Structs and create methods to operate on these structs, so it does not(from my limited experience) differ much from object-oriented programming languages.

2. C

https://www.c-language.org/about

C has no concept of a class unlike python. There is also no built-in way to create inheritance. Some interesting solutions are needed to approximate an object-oriented language, such as anonymous structs.

3. Pico-8 flavoured lua

https://www.lexaloffle.com/pico-8.php

The PICO-8 fantasy console uses a variant of lua as its programming language. From my limited testing¹, it does not support object-oriented lua features, and instead relies on metatables to achieve something close to object-oriented programming. The console’s limited feature set requires a different way of thinking. Instead of writing as you would in programming languages like python for today’s processors, you again have to think about the balance between storage and memory².

4. FFL

https://github.com/frogatto/frogatto/wiki/A-Gentle-Introduction-to-Frogatto-Formula-Language

FFL - Frogatto Formula Language - is a language used in the open-source ‘Frogatto & Friends’ game engine anura. To sum up, most game logic is composed of lists of functions which are then called. Data types like strings, numbers, and lists still exist, but the approach to writing game logic and calculations takes on more of a mathematical spin.

5. Lisp

https://lisp-lang.org/learn/first-steps

From what I have heard, a programming language which extensively uses lists and parentheses.

5. Simple!

https://pistolshrimp.itch.io/simple

An engine and programming language designed for the game Free Stars - Children of Infinity. Actions which I am used to from python/C like functions and pointers do not exist in the traditional sense³(please do not quote me on this, I am still learning the language), and writing game logic requires you to carefully consider the parent-children relationship of objects.

6. Ludii player game rules

https://ludiitutorials.readthedocs.io/en/latest/lud_format_basics.html

Ludii Player is a game system designed for playing board games. The rules for each game are written in .lud files. The syntax looks to me like a set of rules defined in a tree-like structure, and would require some thinking to write in. The description for a tic-tac-toe game looks like so:

(game "Tic-Tac-Toe"
   (players 2)
   (equipment
      {
         (board (square 3))
         (piece "Disc" P1)
         (piece "Cross" P2)
      }
   )
   (rules
      (play (move Add (to (sites Empty))))
      (end (if (is Line 3) (result Mover Win)))
   )
)

7. Brainf***

For this item in the list, I have moved away from practical programming languages, and moved on to the borderline insane.

A language which operates on a infinite-length strip of memory. Each value is set to 0 to begin with, and can be increased, decreased, read from, and written to. You can make a program to add/subtract/multiply numbers, but it gets very tedious very quickly.

I first saw it on the Hypnotic Owl website here.

8. Most(if not all) esoteric programming languages

Niche programming languages which are made to push the boundaries of what is considered a programming language.

Rockstar and Piet are two really cool languages. Rockstar programs are designed to look like rock ballads, while Piet programs are designed to look like abstract geometric paintings.

For a list of more esoteric languages, take a look at the wikipedia page on esoteric programming languages, or if you really want to sift through an extremely large list, the esolangs wiki.

Writing the following code and hoping it will run:

pico-8 cartridge // http://www.pico-8.com
version 34
__lua__
x = 64  y = 64

rectangle = {x=0,y=0,w=0,h=0}

function rectangle:new (o,x,y,w,h)
		o = o or {}
		self.__index = self
		self.x = x or 0
		self.y = y or 0
		self.w = w or 0
		self.h = h or 0
			
		return o
end

function rectangle:printarea ()
   print("the area of rectangle is ",self.area)
end


r = rectangle:new(nil, 10, 20,10,10)
print(r.x)
function _update()
  if (btn(0)) then r.x=r.x-1 end
  if (btn(1)) then r.x=r.x+1 end
  if (btn(2)) then r.y=r.y-1 end
  if (btn(3)) then r.y=r.y+1 end
end
	 
function _draw()
	  
  circfill(r.x,r.y,r.w,r.h)
end
__gfx__
00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
00700700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
00077000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
00077000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
00700700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

↩︎

More precisely, between running calculations every cycle(or frame), and pre-computing the calculations (and running the only once), and using the cached result. The long forgotten art of optimization and managing tradeoffs. ↩︎
To approximate a function call you can:
- Write an if inside the update loop of an object to constantly poll the value of a variable.
```
UPDATE
	Evaluate counter = 1
		// This will only run when 'counter' is set to 1
		Assign counter = 0
```
- Create an object which extends Base (which is destroyed after spawning, and only exists for a single frame), with the function body placed in its INITIALIZE section
↩︎

Tags for this post: Programming

Prev: Trine fan-art