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!

  • \$\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
  • 2
    \$\begingroup\$ Now that it's Dec 2020, should it be renamed to 2020+ edition? Or will there be a new one for 2021? \$\endgroup\$ – val says Reinstate Monica Dec 4 '20 at 17:55

10 Answers 10



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.


  • 5
    \$\begingroup\$ I think Jelly works like that, according to your description. \$\endgroup\$ – user96495 Aug 31 '20 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 '20 at 1:15


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 '20 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 '20 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 '20 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


  • 3
    \$\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 '20 at 16:46


The Factor programming language is a concatenative, stack-based programming language with high-level features including dynamic types, extensible syntax, macros, and garbage collection. On a practical side, Factor has a full-featured library, supports many different platforms, and has been extensively documented.

Factor is the modern stack-based practical language. If Forth (LotM of November 2020) was too hard to use because of its low-level-ness and nothing else, Factor is probably the right language for you.

Why Factor?

  • Factor is functional and object-oriented. Any object or function can be pushed on the data stack. The "object" includes containers (arrays, hashmaps, and the like).
  • Factor does not use syntax (if..then..else, for, while) for control flow. Instead, it extensively uses quotations (equivalent of anonymous lambda functions) and higher-order functions. For example, an equivalent of if-statement looks like boolean [ true-func ] [ false-func ] if.
  • The standard library includes lots of higher-order functions that act on the stack or arrays, which can give a feel of working in Haskell.
  • The functional idiom for reusing stack item(s) can give the feel of APL trains or Jelly links.
  • When the stack shuffling gets extra cumbersome, you can get away with local variables.
  • Stack safety is enforced by checking the written stack effect against the actual one. It may be a hindrance to golf, but it makes Factor functions easier to debug.
  • Despite the verbosity of syntax (space-separated words), Factor is often on par with other practical languages (JS, Python, R) byte-count-wise, thanks to the rich set of library functions.


  • It is recommended to install the Factor binary locally to search for the library functions. (Factor binary is available for Windows/Mac/Linux.)
  • TIO seems to have a version different from the current stable (0.98), and some things that work locally may not work on TIO. e.g. tuck ( x y -- y x y ) is missing, and count does not load with auto-use.




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!
  • 3
    \$\begingroup\$ Should add in that it includes traditional programming constructs as a golfing language \$\endgroup\$ – Razetime Oct 16 '20 at 12:35


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's newly introduced, so it barely has any users

  • It has reached version 1.0, so all heavy development has been completed


  • 5
    \$\begingroup\$ This language seems to be under heavy development (several major features were added this month). \$\endgroup\$ – Zgarb Aug 30 '20 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 '20 at 22:37
  • 1
    \$\begingroup\$ @Zgarb the language is now at version 1.0 \$\endgroup\$ – Lyxal Jan 19 at 0:54


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.


  • \$\begingroup\$ I think MUMPS is a much better candidate than this - syntax shorthands, competitive, comprehensive docs. I haven't used MUMPS yet though, not sure about other potential reasons. \$\endgroup\$ – 2x-1 Jan 19 at 7:23


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.




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




jq is a lightweight practical language for querying JSON files. It's like sed for JSON files.


  • Streams in jq can be very powerful. Operators see individual items in strings when applied:
range(4) -> 0, 1, 2, 3
range(4) + 2 -> 1, 2, 3, 4

# Sometimes, a cartesian-product-like output can be produced with

range(2) + range(4) -> 0,1, 1,2, 2,3, 3,4
  • Piping - Outputs of the previous expression can be piped.
3 | .+2  #  -> 5

[3, 4, 5] | max   # -> 5
  • Compact syntax
[1, 2, 3] | map( . + 1 ) # -> [2, 3, 4]

# (This could also be achieved as [1, 2, 3][]|.+1)
  • It has grown out of interest of the Code Golf community.


New contributor
2x-1 is a new contributor to this site. Take care in asking for clarification, commenting, and answering. Check out our Code of Conduct.

You must log in to answer this question.

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