We've decided to revive the Language of the Month event. We've also decided to start a new post for nominations. (You can see the old nominations post here.) So let's get to nominating!


A language can be nominated for Language of the Month by posting an answer to this thread. We all vote on the languages we'd like to see featured. At the beginning of each month, the nomination with the highest net vote total is chosen as the Language of the Month. (This nomination process was modeled after Lit.SE's reading challenges.)

The person who nominated the language will post a new question on meta, declaring that language to be Language of the Month, with an answer to collect all related golf submissions, tips, and challenges during the month. (See the previous posts, linked below, for a good format to follow.)

  • If the person who nominated the language is not able to make the post by the 3rd of the month, anyone else can make the post.
  • If there is a tie in the voting, the tied language that was nominated earlier will be Language of the Month.

The chosen language will have a chatroom created for it, if it doesn't already have one. During the month, everyone who wants to participate will:

  • Learn the basics of the language (if they don't know it already)
  • Answer challenges in it (new ones or old ones, doesn't matter)
  • Try to outgolf each other's answers
  • Discuss all of the above in the language's chatroom

Past Languages of the Month will be added to a list at the bottom of this post. Their nomination posts should be deleted (preferably by the person who made the post) to reduce clutter.

What sort of languages should I nominate?

We hope to see a wide variety! But not every language is a good choice for Language of the Month. Some things to consider before nominating, and when voting on nominations:

  • It should be somewhat general-purpose and possible to program in. Bubblegum isn't a good choice, because it's only capable of solving a small subset of challenges. Neither is Malbolge a good choice, because it's prohibitively hard to create a working program in it at all.
  • It should not be one of our most commonly used languages on PPCG. The point of this event is to bring attention to lesser-known languages. We don't need to bring more attention to Python or JavaScript. Suggested rule of thumb: if there are fewer than 10 PPCG users who regularly golf in this language, it's a good nomination.*
  • It should have a freely available implementation. This can be TIO, some other online source, or a downloadable interpreter/compiler.
  • It should be fairly stable. Most languages change over time, even well-established ones, so this is a subjective criterion. But if a language is likely to experience significant modifications in the next month, don't nominate it yet.
  • It can be either esoteric or practical. Of course we like our esolangs around here, but it's also cool to study lesser-known "real" languages.

* Better rules of thumb are welcome. Here are a couple SEDE queries for estimating how commonly a language is used: a strict version (useful for languages with short names that could show up as false positives within other languages' names or URLs) and and a loose version (useful for languages whose headers frequently mention a flavor or version number with the name).

What should I include in a nomination post?

At a minimum, your nomination must include:

  • The language's name.
  • A link to a free implementation (or more than one, if available).
  • A short description of the language, for those unfamiliar with it.
  • Why you think this would make a good Language of the Month.

Ideally, your nomination should also include:

  • Some links to documentation and other good resources for learning the language.
  • A link to the language's question, if it has one.

You can also include ideas for one or more language-specific challenges that will provide an interesting experience beyond answering regular challenges in this language. These can be , , , ... you name it. Good language-specific challenges will focus on some aspect of the language that makes it unique, such as an ability or a weakness that most other languages don't have.

Feel free to re-nominate a language that was nominated last time but never won. You can copy over the old nomination post if you like. Languages that have previously been Language of the Month are not eligible.

List of past and current Languages of the Month





Don't forget to keep nominating and voting on languages for next month!

  • 1
    \$\begingroup\$ By the way, the top few languages have been downvoted, so make sure you look at the upvotes. \$\endgroup\$
    – user
    Dec 1 '20 at 17:41
  • 3
    \$\begingroup\$ @user the language is chosen by net vote score, not by number of upvotes. \$\endgroup\$
    – pxeger
    Sep 1 '21 at 12:58


At first brush Curry just looks like a dialect of site darling Haskell. It has a slightly different basic library, and slightly more powerful pattern matching. If this were all there was to Curry I wouldn't be recomending it here.

But Curry has something that makes it really interesting. Curry can also do logical programming. Meaning that while Haskell always takes the first available path, Curry will take all paths looking for correct result. You can get the compiler to do the search for you. This is the power behind Prolog combined with the clean expressive functional nature of Haskell.

Not only does this make Curry really unique and interesting as a language, this opens up all sorts of opportunities for golfing. Curry can be logical when it's the best and functional when it's not.

If you're into Haskell or Prolog golf I cannot recommend Curry enough. If you're not so into those but you are interested I think Curry is an excellent way to sample both techniques.

Curry has 2 implementations on TIO PAKCS and Sloth, as well as MCC and KiCS2. Each implementation has it's own quirks.

  • \$\begingroup\$ Is this the official Curry website? \$\endgroup\$
    – user
    Sep 10 '21 at 23:13
  • 1
    \$\begingroup\$ @user It's hard to tell who runs that site exactly. I think it's the people who make KiCS2. It is a useful link though. \$\endgroup\$
    – Wheat Wizard Mod
    Sep 10 '21 at 23:14


Knight is a new programming language created back in April by sampersand.


There is a list of interpreters on the official GitHub page. It has been ported to many languages, even itself.

Here is an interpreter on TIO, a patch to a previous commit to c/golf which updates and fixes some conformance issues. (Note that it memory leaks like crazy and segfaults on malformed inputs).

However, the "preferred" interpreter is c/ast, which is the fastest, most up-to-date interpreter and has actual error checking.


Knight is a Polish notation language (meaning x + y is + x y, and everything has fixed arity) which is relatively simple. It has some useful string manipulation tools, eval, shell commands, and type coercion.


  • It is a new language which deserves some attention.
  • It is simple and very easy to pick up.
  • It is surprisingly golfable despite not being a dedicated golfing language.
  • Knight has some qualities/quirks that make it very unique to golf.
    • Polish notation
    • Tokens are separated by their character class. So, for example, WX is WX, while Wx is W x. This makes ordering very important.
    • Only the first statement is executed, everything must be chained (typically using ;).

I have posted some solutions here already.


  • \$\begingroup\$ Food for thought: maybe we have a golfing challenge where people golf knight? \$\endgroup\$
    – Sampersand
    Jun 9 '21 at 20:09
  • \$\begingroup\$ Usually they don't do that here, what some people like to do is create a bounty for the first programs in that language \$\endgroup\$
    – EasyasPi
    Jun 9 '21 at 22:59


Desmos is an online graphing calculator with strong mathematical functionalities. It's not designed to be a programming language, but it can certainly be used as one.


  • Even though it is a graphing calculator, it can be used as a programming language, albeit a limited one.
  • Following the previous point, Desmos has certain limitations that make it fun/challenging to golf with.
    • For example, lists/list manipulation are quite limited; for one, lists can only be 1d, so finding clever ways around that limitation can be interesting.
  • Desmos differs from many of the more popular languages in that the code is based on mathematical(\$\LaTeX\$) formulae instead of purely on executing code instructions.
  • There is an abundance of builtin functions and functionalities(see Resources below) that you can use in your Desmos code.
  • There are active communities on Reddit, Twitter, and even Discord. People there can probably help you with any questions you may have.


  • Strings are not supported whatsoever, meaning any challenges requiring string I/O cannot be done with Desmos.
  • Sometimes tedious to do the simple, but necessary, golfs every time an expression is copied out from Desmos. (c.f. this)
    • e.g.: \operatorname{min}\left(a,b\right) --> min(a,b)
  • Usually very hard to search on the Internet for any questions you may have; you'll most likely have to join one of the communities listed in Resources and ask the question there.




A minimalist Lisp dialect that I (DLosc) invented for an interpreter golf challenge. Because Lisp is powerful, tinylisp's small set of builtins can be combined to solve a wide variety of tasks.


  • The core builtins are one character each, contributing to golfiness.
  • There is a standard library that implements a bunch of more-complex functions.
  • Being a Lisp dialect, tinylisp is pretty good at functional programming and list manipulation.
  • I'm basically the only one who uses it.


  • The only documentation is the GitHub readme, which gives a decent introduction to the syntax and builtins but doesn't cover the library at all.
  • String operations are supported, but not very thoroughly. All numbers are integers--no rationals or floating point.
  • If you don't already speak Lisp, tinylisp might be hard to understand.




PARI/GP is a CAS (Computer Algebra System) designed for number theory. It consists of two parts: PARI is a C library, GP is an interactive shell and a scripting language. Even if you are not familiar with algebraic number theory, GP is still a powerful language for golfing math problems.


  • Intuitive syntax and good documentations. Easy to learn.
  • Built-in types for vectors, matrices, polynomials, power series, and many other math objects.
  • Lots of built-ins, especially for number theory, but also for linear algebra, polynomials, and other branches of algebra.
  • Single byte operator # for length (of vectors, matrices, strings, etc.).
  • Many OEIS pages have a PARI/GP program for the sequence.


  • Not so many built-ins outside of math. On the other hand, this force you to think out of the box, for example, using polynomials to solve array challenges.
  • Very limited array programming. You can add two vector or multiply a vector by a scalar, but there is no built-in to do element-wise multiplication.
  • You need to know some math to master the language.
  • The version on TIO is somewhat out of date.




In my search for peculiar and interesting golfing related languages, I came across a particularly cool fusion of J's modifiers and ruby's metaprogramming called J-uby.

Why J-uby?

  • If you like Ruby, J-uby is effectively a tacit-enabled superset of it.
  • J-uby has complex, highly varied methods of compositional function programming through its operators that apply on functions and arrays.
  • It is relatively unused outside of its creator, Cyoce, so there are many simple questions to practice on.
  • There are many new tricks to be discovered in J-uby due to its unorthodox approach to tacit programming, which is also made even more wonky by ruby's evaluation order.


In June 2021, Cyoce posted a new answer in J-uby, where I asked them about a tutorial beyond the readme on the github page: Link

@Razetime The Readme is it. I might make a better tutorial some time if people are interested – Cyoce

So if you're interested in learning this fun looking ruby contraption as well, do vote for J-uby!



The Nim programming language is a ergonomic general purpose programming language.

A quick list of features:

  • Whitespace-oriented syntax, much like Python
  • Static typing
  • Transpilation to C/C++/ObjC/JS
  • Multi-paradigm memory management (several GCs, no GC, and others)
  • Dynamic & static seqs/arrays
  • First class functions, called "procedural types"
  • User-defined iterators
  • Metaprogramming of all sorts, with everything from text-substitution, to macros that operate on it's AST (Introduction to metaprogramming in Nim)
  • Great C/C++/JS interop

It has a very active community. (Forum, subreddit).

A quick intro, covering only the most basic constructs: Nim basics

  • 1
    \$\begingroup\$ Nim looks like a really neat language. afaik there's multiple GC's to fit your purposes, right? \$\endgroup\$
    – user
    Sep 12 '21 at 18:34
  • \$\begingroup\$ Yes, that is true. See nim-lang.github.io/Nim/gc. \$\endgroup\$
    – Pyautogui
    Sep 12 '21 at 23:39


Arn is a rather new J-like language I designed back in mid-August (2020). It's designed to beat out its inspiration and also be competitive against other, older golfing languages.


  • it does well at what’s it meant to, consistently beating J and APL. I’ve also seen it do better than languages such as Vyxal.
  • The tutorial has been finished, making it easy to start.
  • Done with a major rewrite. TLDR new features, adding new ones easier
  • Has entered a semi stable state. I have a feeling a few larger changes are due in the future, but for now I’ll probably just be adding a few new symbols every once in a while.
  • There are very few (if any, other than me) people who use this language (as far as I'm aware) so this will help spread the language around.


  • Does not currently have a chatroom, as I don't believe there are enough people to warrant one.
  • The online version is out of date and has some bugs.
  • I believe there’s a bug in the lexer that shows when using symbols that take multiple expressions on the same side, which I’m looking into.




Groovy is a static/dynamic language that runs on the Java Virtual Machine. It supports a large subset of Java, but features such as dynamic typing, optional semicolons, and implicit returns allow writing of code that is much shorter than Java (here is a nice demonstration of how short it can be compared to Java). Groovy is also widely used in DSLs, with Gradle being the most notable example.

Why am I nominating it? It is a practical, widely used language in which you can make a program as long as Java, but you are not forced to. This language allows you to remove all the forced stuff (unlike the good ol' public static void main(String[]a) and simply let your juices flowing. It'd be nice to start and end the year with JVM languages ;)


  • Optional static typing; you may declare the type of a variable, but you don't have to
  • Closures; anonymous functions
  • Implicit it parameter in closures
  • Implicit returns
  • Boolean evaluation
  • Optional semicolons and parentheses
  • Command chains: i came i saw i conquered equates to i(came).i(saw).i(conqered)


  • \$\begingroup\$ In addition to code golf, Groovy is amazing for DSLs! I'm looking forward to this one becoming LotM \$\endgroup\$
    – user
    Nov 15 '21 at 21:55
  • \$\begingroup\$ Groovy is a popular language in CGCC and more than 50 people used so don't do that. \$\endgroup\$
    – Fmbalbuena
    Dec 8 '21 at 23:56
  • \$\begingroup\$ How do you measure that? \$\endgroup\$
    – Seggan
    Dec 9 '21 at 2:33

You must log in to answer this question.

Not the answer you're looking for? Browse other questions tagged .