Introducing Frankie — The Programming Language — “It’s alive!” 🧟⚡

You might or might not, but I like to call myself a Programming Languages Archaeologist, mainly because I like to find and learn old programming languages that most likely nobody uses in modern day 🤓 But I also like learning about brand new programming languages.

If you haven't read it already, I have a nice and ongoing series named Exploring Programming Languages, where I develop the same code in multiple programming languages. Currently, there are more than 60 🥹

But anyway, let's talk about Frankie - The Programming Language 🧟‍♂️

So I teamed up with Anthropic's Claude, and together we created, coded, vibe coded, whatever, a programming language which by definition is:

Stitched together from Ruby • Python • R • Fortran

Why? Because those 4 are my favourite programming languages 😅

The foundation is Python, while the syntax is Ruby-like with commands that come from R and Fortran, besides obviously Ruby and Python.

Frankie is an interpreted language that can be compiled to Python source code.

Here are some features of the language:

• Stitched from four languages - Ruby's expressive syntax, Python's clean semantics, R's statistics and pipe operator (|>), and Fortran's do...while and integer division (//)

• Proudly procedural - functions, data, loops, and logic. No classes, no self, no inheritance

• Built-in statistics - mean(), stdev(), median(), min(), max(), and more, operating natively on vectors

• R-style pipe operator - chain calls cleanly with |>, e.g. data |> sum |> puts

• Ruby-style iterators - .each, .map, .select with do |x| ... end blocks

• String interpolation - "Hello, #{name}!" just like Ruby

• Error handling - begin / rescue / ensure blocks with raise

• Built-in SQLite - zero-dependency database access via db_open, db.insert, db.find_all, etc.

• v1.3 extras - JSON, CSV, DateTime, and HTTP support out of the box

• Zero dependencies - runs on Python 3.10+, nothing else to install

If you're curious, here's the GitHub repo 😇. I would appreciate a couple of stars if possible 😉 I will try to improve Frankie as much as possible.

Here's a small sample so you know what to expect 😁

# Fibonacci
def fib(n)
  if n <= 1
    return n
  end
  return fib(n - 1) + fib(n - 2)
end

puts fib(10)    # 55

# R-style stats
data = [23, 45, 12, 67, 34, 89]
puts mean(data)
puts stdev(data)
data |> sum |> puts

# Iterators
evens = [1,2,3,4,5,6].select do |x|
  x % 2 == 0
end
puts evens    # [2, 4, 6]

# Case/when
case evens.length
when 3
  puts "three evens"
else
  puts "something else"
end

# Destructuring
lo, hi = [min(data), max(data)]
puts "Range: #{lo}..#{hi}"

# Error handling
begin
  raise "oops" if lo < 0
rescue e
  puts "Caught: #{e}"
end

That's it for now. I hope you give Frankie some love and see you on the next Frankie release 🤩

Comments

[Apex Stack]

The pipe operator inclusion from R is a really smart call — once you get used to chaining transforms with |>, going back to nested function calls feels painful. I use Python heavily for data pipelines (pulling financial data from yfinance, transforming it, loading into Postgres) and the lack of a native pipe operator is the one thing I miss most from R.

The "proudly procedural" stance is interesting too. There's a growing camp of developers who think OOP became the default without earning it for every use case. For scripting, data munging, and automation work, procedural with first-class functions is often all you need.

Curious about the Claude collaboration aspect — did you find it more useful for the parser/lexer work or for designing the syntax itself? Building a language is one of those projects where the design decisions compound fast.