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!

| |

10 Answers 10



Scala is a general-purpose programming language that combines OOP and FP and improves a lot on Java. It mainly runs on the JVM, but there's also Scala Native and ScalaJS.


  • Concise (and pleasing) syntax that sometimes makes it feel like a scripting language (here is a comparison between ScalaJS and ES6 and TypeScript.
  • The standard library is amazing. Not only does it have useful methods such as combinations, collect and builtin tuple and function types, the collections hierarchy makes it super easy to do all sorts of operations without explicitly declaring types or converting them like you would in Java. This, I think, is one of the best ways Scala helps with code golf.
  • Implicits are super powerful and can be used for everything from simply reusing values to doing logic programming at compile time.
  • Type inference means you don't need to declare types explicitly, except for method parameters (and sometimes for return types in recursive methods).
  • For comprehensions are a lot shorter than using multiple flatMaps and filters, and you can even create variables without using the val keyword inside them.
  • Pattern matching is convenient, and helps in destructuring declarations.
  • User-defined operators save bytes. list1.concat(list2) can be replaced with list1 ++ list2. Infix and postfix (the latter is deprecated) also save bytes.
  • Its type system is Turing complete, and using literal types and a couple dependencies, you can even do compile time operations on primitives and such.
  • It runs on the JVM, so you also have access to Java's standard library (java.lang._ is imported by default).
  • There's a research compiler called Dotty that adds a ton of features to Scala and is slated to be released as Scala 3.
  • This doesn't help a ton with code golf, but Scala makes immutability really easy - all you have to do is use val instead of using final SomeType, like in Java.

Despite being an amazing language that's been around for a while and has a big user base, I almost never see Scala used here, and I think more people should try it.

Here is a list of users using Scala. You'll notice that most of them have used it for less than 5 posts, and only 3 have used it for more than 15.


Some nice Scala answers:

| |


Verbatim from their homepage:

A language empowering everyone to build reliable and efficient software.

It may not be a language built for golfing, but it sure is a language built for writing robust applications!


  • It's a language designed to prevent memory-unsafe operations at compile time, to the point where (using safe Rust), "If it compiles cleanly, it's memory-safe". It does so by employing move semantics and references tagged with lifetimes, which also leads to writing programs that don't require a garbage collector

  • As a welcome side effect from its memory safety, Rust programs can easily be parallelized due to data-races being eliminated

  • It has a robust type system (which is interestingly also Turing complete provided limits are removed, similar to Prolog) which handles null using an Option type and program exceptions with a Result type, forcing exceptions to be handled explicitly

  • It has a very consistent toolkit, with cargo managing dependencies and working as a build, test, benchmark and documentation system, clippy providing suggestions to help Rustaceans of any experience level write idiomatic Rust, and more

  • It has excellent documentation and ensures examples provided in docs are tested as part of the test suite

  • It can run on a variety of environments, all the way from bare metal to WebAssembly

  • It has zero-cost implementations of iterators and asynchronous programming


Part of why Rust isn't suited for golfing is the verbosity needed to deal with errors (due to its type system)


| |
  • \$\begingroup\$ errors do not matter at all in golfing so long as the program does the thing. \$\endgroup\$ – Razetime Aug 30 at 13:24
  • 1
    \$\begingroup\$ @Razetime The problem is, Rust forces explicit error handling, the shortest way to say you don't care is by saying .unwrap() on the Option or Result xD \$\endgroup\$ – K3v1n Aug 30 at 13:41


Vim is a text editor that is meant to be an improvement over vi.


  • It's very concise - usual operations only take one or two ASCII bytes.
  • It's really good for string manipulation challenges ( is our second most popular tags), so you are going to find chances to use it very often.


| |
  • \$\begingroup\$ I don't know if Vim all by itself can be considered. Is it possible to use it as a general purpose language? \$\endgroup\$ – Razetime Aug 30 at 9:39
  • 6
    \$\begingroup\$ @Razetime All Vim answers on this site. Vim supports VimScript, an easy to use language that's probably general purpose. \$\endgroup\$ – user96495 Aug 30 at 10:38
  • 1
    \$\begingroup\$ Furthermore, TIO can be used as V is entirely backwards-compatible with Vim (any Vim program can be run in V): TryItOnline! \$\endgroup\$ – caird coinheringaahing Sep 4 at 12:44


ARM is probably the most successful architecture for the digital world. From mobile phones to supercomputers, ARM is everywhere!

As of 2013 more than 10 billion ARMs were shipped, as compared to 0.3 billion 80x86s. -- ISSBF


  • ARM has a much better design than e.g. x86. It involves a lot less concepts, making it more beginner-friendly.
  • ARM has a very low learning curve. Due to its RISC nature, ARM has less than 100 highly generalized assembler directives that perform tasks in a very compact way.
    • To some extent, it makes ARM easier to learn than its competitors.
    • The RISC architecture also makes programs faster to execute, since it takes less time on decoding the instruction opcodes.
  • The ARM instruction set is very compact.
    • Most instructions allow for conditional execution. This saves instruction cycles since no conditional jumps are necessary around conditional blocks.
    • ARM also has the barrel shifter (which means that you can perform bitshifts to some value before using it).

    The following shows an example:

    ARM (8 Bytes)

    cmp   r0,r1
    addhi r0,r2,r3,lsr#4

    x86 (11 Bytes)

    cmp eax,ebx
    jna skip 
    mov eax,edx
    shr eax,4
    add eax,ecx


| |
  • 1
    \$\begingroup\$ ARM has a much better design than e.g. x86: this is probably opinion-based. Also, ARM is not a language; the proposal seems to refer to ARM assembly \$\endgroup\$ – Luis Mendo Nov 15 at 16:46


Vyxal is what one might term the "new kid on the block" when it comes to golfing languages. It's made by me, Lyxal, and tries to make golfing a pleasant experience.


  • It's got potential to actively win against languages like 05ab1e, Jelly and Pyth... it managed to beat Dennis in fizzbuzz

  • It has features designed to make it feel analogous to practical languages while remaining concise

  • It has potential to adapt with the addition of new built ins over time

  • It's newly introduced, so it barely has any users

  • Although it's still got a bit to go, most of the key features are implemented and the essence of the unimplemented features has been determined. It's just a matter of adding built ins

  • By the time it'll even have a chance at becoming lotm (2+ months), it'll be a lot more stable


  • 5
    \$\begingroup\$ This language seems to be under heavy development (several major features were added this month). \$\endgroup\$ – Zgarb Aug 30 at 12:51
  • 1
    \$\begingroup\$ @Zgarb the heaviest of development has been completed... that's the heaviest it will be for a long time now. \$\endgroup\$ – Lyxal Aug 30 at 22:37


Whispers is a rather unique programming language in how it executes a program. Rather than running line-by-line or command-by-command, Whispers only executes the last line in the program by default. All other lines are only run when referenced by either the last line, or by a line referenced by the last line (and so on).


  • It is, to my knowledge, completely unique. I'm unaware of any programming languages like it. Additionally, I'm the only consistent user of the language.
  • It's heavily optimised towards math-based challenges, but is fairly easy to use across all types of challenge, once you know how it works
  • It's strict-yet-lenient syntax rules make it super easy to use in polyglots
  • Especially with the latest version, Whispers is very powerful, including a built in calculus engine, along with the ability to run and evaluate arbitrary mathematical expressions. Furthermore, it now has support for common sequences, a massive builtin library of functions and a large collection of builtin operators and constants
  • Versions 1 and 2 are available on TIO, with all 3 versions able to be downloaded from the Github repo, and are all written in Python, a widely available programming language.


It does not currently have a chatroom (easily created), and I'm currently working on documentation, so that's missing, as of time of writing.


| |
  • 4
    \$\begingroup\$ I think Jelly works like that, according to your description. \$\endgroup\$ – user96495 Aug 31 at 1:14
  • 1
    \$\begingroup\$ @hi. One crucial difference between Jelly and Whispers is that Jelly can have arbitrary code on each line, where as Whispers can only run one command per line \$\endgroup\$ – caird coinheringaahing Aug 31 at 1:15


Plumber is an esolang I made, based upon packets moving around in a 2d space. This space consists of a grid of 2-character wide units, of which there are 16.

It has no stack, queue, or tape. Information is only stored and moved by pushing, pulling, and dropping these packets between parts of the program.


  • There are only four answers in it
  • People I talked about it with in TNB seemed to like it
  • It's very different to use compared to most other 2d languages:
    • There is no instruction pointer or stack
    • Rather than a linear order of operations, you can have multiple parts of an operation running next to each other to save time or space
  • It can be really fun to get a Plumber program working
  • The many ways to use each unit makes interesting golfing much more possible than in some of the more straightforward languages


| |


Keg is a tiny language designed by Lyxal that is relatively very powerful for code golfing. Try it online!


  • It is very easy to learn, with well-thought of built-in utilities that are very powerful.
  • It have unique golfing features that other languages have not implemented; e.g. the auto-pushing mechanism, that makes representing large numbers using a few bytes possible.
  • It is fun. Golfing in it is very easy, as it provides a lot of ways to code-golfing programs. Also, if you golfed it hard enough, you will find that it can compete with other well-known golfing languages.
  • It includes traditional programming constructs as a golfing language
  • And perhaps most importantly, only a few people are using it!
| |
  • 2
    \$\begingroup\$ Should add in that it includes traditional programming constructs as a golfing language \$\endgroup\$ – Razetime Oct 16 at 12:35


Add++ is a language that combines both short commands and other golfing features with general usability and practical language features. For example, I've written a programming language in Add++, and most solutions in Add++ are easy to understand for users of both practical and golfing languages.


  • There aren't many languages like it. In my experience on the site, I don't recall seeing any languages with a similar model to Add++
  • It is widely usable. I would describe Add++ as a practical language with one- or two-byte commands, so it's easily accessible to all golfers
  • It's somewhat used across the site. Primarily by me, but there are multiple answers by other users, and we already have a chatroom
  • Due to it's wide range of builtins, it is very powerful, and so can complete most challenges competitively with other golfing languages.
    • Closer to Pyth and CJam rather than Jelly and 05AB1E however
  • It has version tracking, and each version can be run via command-line flags
  • It's docs are fairly comprehensive, thanks to Razetime


The docs do not contain a comprehensive list of commands, and it is somewhat strict in its syntax, which can lead to a lot of errors. Furthermore, Add++ still has some bugs in the code, along with some confusing behaviours.


| |


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


  • While not necessarily the best language at golfing, there are certain tasks it excels at
    • In particular, math, ranges, mapping, folding, and other such operations.
  • Designed to beat out APL and J-like languages, it succeeds at this almost always.
  • Still new, there is room for improvement. New features are constantly being considered and added.
  • There are very few people who use this language (as far as I'm aware) so this will help spread the language around.
    • Also, more users means more feedback. I'm pretty new to golfing, and there's a lot of things I'm not sure about, or features that should exist but don't because I'm not aware of them.


  • Does not currently have a chatroom, as I don't believe there are enough people to warrant one (also, I'm new to Stack Exchange still and am not sure how).
  • There are most likely still a few bugs I have not spotted yet in the main interpreter.



You must log in to answer this question.

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