We've decided that we like the idea of a "Language of the Month" event. The main idea is to get more exposure for less-frequently used languages, and to have fun learning and golfing them together. The next question is, what languages shall we choose? And that's where you come in.


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 is modeled after Lit.SE's reading challenges.)

The chosen language will have a chatroom created for it, if it doesn't already have one. We could have a community ad to promote it, changing the ad each month to reflect the new featured language. (Does someone want to volunteer to create an ad?) It can also be featured as a site-wide event in the Community Bulletin Board sidebar; a mod would need to create the event.

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 really 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 would also be cool to study some lesser-known "real" languages.

* Better rules of thumb are welcome. I made this one up after thinking about it for ten seconds.

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.
  • 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.

List of past and current Languages of the Month

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

  • \$\begingroup\$ Writing.SE used some kind of "event" for that purpose. (Can a mod, or somebody else who knows the StackExchange system better than I do, speak to that?) – In order to create a chatroom event you have to 1) Be a room owner 2) Click on Room -> Schedule Events 3) Add the event name and a short description 4) Choose a time and date (and optionally a repetition pattern). \$\endgroup\$
    – Mr. Xcoder
    Commented Feb 2, 2018 at 10:16
  • \$\begingroup\$ There will be a "LotM:February" post later? With a compilation of questions and answers that originated from this event? The questions/answers could also link back to it. \$\endgroup\$
    – Rod
    Commented Feb 2, 2018 at 15:24
  • \$\begingroup\$ Could the rule about number of users be the number of users with more than X posts, it might be fairer on languages that have slightly more users, but a lot of them have only made 1 post. \$\endgroup\$
    – jrtapsell
    Commented Feb 2, 2018 at 16:18
  • 5
    \$\begingroup\$ Updated the rue of thumb to be the number of users that regularly golf in the language to eliminate those users who only tried it a couple of times. \$\endgroup\$
    – Shaggy
    Commented Feb 2, 2018 at 17:15
  • \$\begingroup\$ @Rod I'm not sure that's necessary. If this event is successful, there may be a lot of answers. Is there a real benefit in cataloging them? \$\endgroup\$
    – DLosc
    Commented Feb 2, 2018 at 20:49
  • \$\begingroup\$ @DLosc the idea is to increase the event visibility, so everyone that see the answers / questions wiht know that there is a ongoing event about language and will (?) be inclined to participate \$\endgroup\$
    – Rod
    Commented Feb 2, 2018 at 22:06
  • \$\begingroup\$ You can check the users of a language by visiting http://data.stackexchange.com/codegolf/query/793250/top-language-golfers?Lang=<LANG>, for example Java \$\endgroup\$
    – jrtapsell
    Commented Feb 3, 2018 at 16:32
  • \$\begingroup\$ @DLosc I am trying to make it better, my main limitation at the moment is that a lot of answers have either no header, or a header that does not match the leaderboard format (I am trying to improve answers manually at the moment). I might try making a version that only returns headered answers, but that would mean ignoring the unheadered answers \$\endgroup\$
    – jrtapsell
    Commented Feb 3, 2018 at 18:04
  • \$\begingroup\$ @jrtapsell I took the liberty of making my own from a fork of your query: a strict version (useful for languages with short names like J that could be substrings of other languages' names and/or URLs) and a loose version (useful for languages like APL that are frequently cited as Dyalog APL or APL (Dyalog) or whatever). The results are a lot more accurate, though there's probably still room for improvement. \$\endgroup\$
    – DLosc
    Commented Feb 3, 2018 at 20:19
  • 3
    \$\begingroup\$ Suggestion: Instead of selecting languages based on net votes, we count upvotes only. Reasoning: If Language X is +10/-9 and Language Y is +2/-0 then, clearly, 5 times as many people want to see X selected as do Y but, based on net votes, Y would be selected. \$\endgroup\$
    – Shaggy
    Commented Feb 5, 2018 at 10:08
  • 10
    \$\begingroup\$ It might be worth prohibiting nominations of your own language. If a language is genuinely interesting, it should be possible to find someone else who's willing to advocate it; and if you can't find anyone else to advocate it, you're going to be a bottleneck to answering questions in chat etc. \$\endgroup\$ Commented Feb 5, 2018 at 12:10
  • 1
    \$\begingroup\$ @Mr.Xcoder I meant the site-wide events described here. (Currently, the upcoming mod election is being advertised via this method, which prompted me to track down the concept on Meta.SE.) A mod would have to set the event up, it appears. \$\endgroup\$
    – DLosc
    Commented Feb 7, 2018 at 6:33
  • 1
    \$\begingroup\$ We should have a clear policy on how the new language of the month is announced. A meta post for each? Who should post it, and when? \$\endgroup\$
    – Luis Mendo
    Commented May 2, 2018 at 10:23
  • 2
    \$\begingroup\$ It’s time to announce Cubically as LotM isn’t it? \$\endgroup\$
    – JayCe
    Commented Sep 5, 2018 at 3:46
  • 1
    \$\begingroup\$ @Razetime It hasn't been a thing for a couple of years, but I'm all for reviving it! I think interest waned after SMBF--partly due to a lack of enthusiasm about SMBF, partly because I got busy and wanted others to run the event, which led to confusion about who was posting things and when. I can't promise to be consistently involved, but if there's interest, I'll be happy at least to make a post crowning R as Language of the Month for September 2020. \$\endgroup\$
    – DLosc
    Commented Aug 21, 2020 at 1:26

8 Answers 8



R is a free software environment for statistical computing and graphics. It compiles and runs on a wide variety of UNIX platforms, Windows and MacOS. It is available on Try it Online!

Why is it a good candidate?

  • It has a small community of active golfers. There are no more than 6 or 7 members who regularly post answers in R. There ought to be more!

  • It is a general-purpose language, meaning it can be used to answer all questions on this site. Though to be honest processing strings requires a bit of flexibility.

  • Its vectorized syntax allows for concise answers in case for multiple input.

  • R is a functional programming language - almost everything is a function - including things that you would think (thanks to the parser) are just operators. This can yield some very powerful golfs, as displayed here.

  • Environments, combined with lexical scoping are a power feature of the language.

  • It is really good at plotting stuff.

And most importantly: Golfing R is fun :)

Here is the R golfing tips post.

Resources to learn R:

Online Interpreters



Cubically is an esolang created by me, MD XF, designed to work with Rubik's Cubes.

Interpreter - Documentation - GitHub Organization - Chatroom - Try it Online!


  • Cubically is very easy to use. No, it's not easy to perform simple tasks such as "Hello, World!" in, but it's really very easy to get started writing code. The syntax is simple for the most part, and the docs are fairly easy to understand.
  • Cubically is powerful. Its 3-byte 3x3x3 solver finishes in under a second and in very few moves; it uses a nearly optimal algorithm.
  • Cubically is fun. It forces its users to find algorithms and crazy code snippets to achieve simple tasks, like obtaining the integer 1.
  • Most of all, Cubically does not get a lot of attention! It was created over six months ago and it gets more and more useful every commit, but as far as I know, only four people have ever used it in something that wasn't a polyglot.
  • \$\begingroup\$ ... because it wasn't useful at all few months ago. \$\endgroup\$
    Commented Feb 3, 2018 at 13:47
  • \$\begingroup\$ 4 months isn't a super long time for it to get a lot of attention... \$\endgroup\$
    – Riker
    Commented Feb 28, 2018 at 22:15
  • \$\begingroup\$ @Riker where do you find four months in this post? \$\endgroup\$
    – MD XF
    Commented Mar 1, 2018 at 0:10
  • 1
    \$\begingroup\$ @MDXF *six, I'm an idiot. I knew it was six but I just can't raed. I confused that with the "four people". \$\endgroup\$
    – Riker
    Commented Mar 1, 2018 at 14:27
  • 3
    \$\begingroup\$ I guess this is the LoM for September? \$\endgroup\$
    – Giuseppe
    Commented Sep 4, 2018 at 0:28


Interpreter | Documentation | Online Interpreter

Gaia is a stack-based golfing language created by PPCG user Business Cat about a year ago, in late May 2017.

There are a couple of things that make Gaia a very good competitor for the Language of the Month event:

  • Terseness and Ease of Use – It is stack-based, so it is particularly easy to learn and understand. It has some powerful one-byte built-ins, which are pretty well chosen, and also some two-byte ones that perform more complicated tasks.

  • Features and Forte Points of Gaia – This language excels at date-time manipulation, having over 30 operators dedicated to it. Other than that, the meta operators combined with the separate functions and blocks make solving non-trivial tasks, which require loops, sorting, filtering or something else very easy in Gaia. Moreover, the input is implicitly pushed to the stack, so you might not need @ explicitly in some situations.

  • Turing Completeness – Gaia is undoubtedly TC, and it is not hard at all to prove it.

  • The Gaia community is very small – Albeit being well-suited to code-golf, there are just a few answers in it and only two users have ever used it on a regular basis (one of which, its creator, is no longer active).

  • Golfing in it is fun! – I can't demonstrate this unless you try it yourself, but (at least in my case) this entirely true. Go check it out!

Currently, Gaia does not have an SE chatroom, but one can be created in case others are interested too. Alternatively, Esoteric Programming Languages can be used instead, as I expect the traffic not to be too high. (While Business Cat is inactive, I'd be happy participating and maintaining it)

Pro tip: If you are trying to solve an challenge (taking arrays as input), you should note that the array syntax is [elem1 elem2 elem3 ... elemN], and that e↑ added to the footer makes it easier to parse input.



Try it online! ~ Documentation ~ In-progress tutorial ~ Chat room

Attache is a practical language most similar to Mathematica in terms of basic syntax, but features much terser syntactic elements and enables practical, easy, functional programming. (No, purists, it's not state free.)

Why would this be a good language of the month? If for no other reason than to give it exposure, Attache is a favorite tool of mine for completing high-level tasks within a reasonable time frame. It features a plethora of built-in functions (perhaps not rivaling Mathematica) which minimize boilerplates in programming. It is actively developed (yours truly), and I'm open to suggestions regarding the language and its functions.

Attache features many function-oriented operators and functions, which makes fixpoint programming realistic and fun to golf with. Some of the fun in golfing is figuring out whether tacit or fixpoint programs will be shorter.

While the language isn't entirely bug-free, it's at a point in development where such bugs are rarely encountered in conventional programming and golfing, and the language isn't liable to change drastically.

(also the language has like one consistent user and it's lonely)



Z80Golf Machine | Z80 Assembly Materials | Z80 Opcode Reference (.txt)

Esolangs | Assembler | Try it online! | Chatroom (N/A) | Tips (N/A)

Z80Golf is a machine code language for "Z80 Code Golf Machine" by mokehehe, originally designed for anarchy golf. While Z80Golf has been used for several years on anagol, it was only recently introduced to PPCG by Lynn this year.

The specification of the Z80Golf machine is as follows:

  • Z80Golf programs are binary files (.z8b). On initialization, the binary is copied to the address $0000, and the rest of memory (up to $FFFF) is padded with zeroes. All the registers are zero as well: AF, BC, DE, HL, IX, IY, SP (stack pointer), and PC (programming counter).
  • Whenever the PC reaches $8000, the value in the register A is written to standard output, and then a RET instruction is simulated. (In other words, call $8000 is like putchar A.)
  • Whenever the PC reaches $8003, the machine tries to read a single byte from standard input. On EOF, the carry flag is set and A is left unchanged. Otherwise, the carry flag is cleared and A is set to the value read. Finally, a RET isntruction is simulated. (In other words, call $8003 is like getchar A.)
  • The program keeps running until HALT is executed.

Since every submission is a binary, xxd output format is used in TIO.

Why Z80Golf?

  • This is the first machine code nomination.
  • Unlike x86 and other architectures used for machine code golfing on PPCG, Z80Golf machine has absolutely zero boilerplate for writing full programs.
  • While its instruction set is identical to e.g. TI calculators, complete lack of peripherals gives greater room for creativity. For example...
    • You can underflow your own stack into code,
    • You can write $76 in the code region to halt your program like Befunge and ><>,
    • You can manipulate somewhere in memory to do something entirely different each iteration,
    • ...and so on!
  • Unlike many other nominations, this language is quite old (several decades for Z80 itself, and at least 8 years for Z80Golf machine), yet it was introduced recently to PPCG. As a consequence, PPCG has only 21 Z80Golf answers by only 3 users so far as of writing (Aug 17, 2018). Since Z80Golf is capable of lots of convoluted things, we desperately need more intra-language competition.




Keg is a tiny language designed by Jono 2906 that is astonishingly 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.
  • And perhaps most importantly, only a few people are using it!


Sesos is a language largely based upon brainfuck, but it has some extra features:

  • Unbounded signed integers (can be disabled)
  • I/O with numbers (input and output must be enabled separately)
  • Conditional jump based on whether the input's EOF has been reached
  • Conditional jump, with the code before it having been executed at least once.

Additionally, it has a difference from brainfuck: While brainfuck's + and - increment and decrement the current cell respectively, Sesos's add and sub take an argument determining how much to add or subtract respectively. The same difference also applies between brainfuck's > (go one cell right) and < (go one cell left) and Sesos's fwd and rwd.

Another important difference is that you can't put certain instructions next to each other, due to how the program is encoded into a binary file. More specifically, add/sub, fwd/rwd and jmp/jnz are pairs of instructions which can't be put one after the other. Also, get can't go after add or sub.

The final difference is that jmp and nop can't be the last instructions of a program.

Programs are written top-to-bottom, instead of left-to-right, before compilation. There are 10 instructions and 3 assembler directives.

The instructions are:

  • add <n>: Adds <n> to the current cell.
  • sub <n>: Subtracts <n> from the current cell.
  • fwd <n>: Moves <n> cells forward.
  • bwd <n>: Moves <n> cells backward.
  • put: Prints the content of the current cell.
  • get: Takes one input character (or integer) and replaces the current cell's content with it.
  • jmp: Sets an entry point, and jumps to its corresponding exit point (i.e. the closest following exit point that doesn't belong to any following jmps).
  • nop: Sets an entry point.
  • jnz: Sets an exit point and, if the current cell is non-zero, jumps right below its corresponding entry point.
  • jne: Sets an exit point and, if STDIN's EOF hasn't been reached, calls get and jumps right below its corresponding entry point.

Leading jmp instructions can be omitted, as long as their corresponding exit points are explicitly present in the code. The same is true for trailing jnz, where their corresponding entry points must be explicitly specified.

The assembler directives are:

  • set numin: Take input as integers instead of characters.
  • set numout: Print as numbers instead of characters.
  • set mask: Use 8-bit unsigned integers instead of unbounded signed integers.

In the source code, those directives can be put anywhere, and the result will be the same.

Extra whitespace is ignored.

Details about the compilation process can be found over the GitHub repository.

I'm nominating this language because interest was always little and gradually faded away. I think it's a very interesting language, and it definitely has golfing potential.

Tips for golfing in Sesos

  • 1
    \$\begingroup\$ Ugh...looks like there wasn't any tips question about golfing in Sesos yet, so I made one. \$\endgroup\$ Commented Mar 21, 2018 at 17:06
  • 3
    \$\begingroup\$ That's because it's basically BF \$\endgroup\$
    – mbomb007
    Commented Mar 23, 2018 at 21:00


Bit is a stack-based language created by myself, it is similar to Cubically in that it forces users to think of intuitive ways to do simple things (see examples below), the specification, documentation and interpreter are available at the link above.


Adding to the examples in the GitHub link, heres a Truth-Machine program (If input is 0, print 0, if input is 1, print 1 infinitely)


BYTE var $$ creates a variable called 'var'
IN $$ Read input, stack = [[I, N, P, U, T, B, Y, T, E, S]]
INTO $$ turn [[something]] into [something]
PUSH var $$ Sets var to the user's input in bytes
IMPORT var $$ Reads the value of var, and searches for a file called 0 or 1 depending on user input, then executes it




BYTE one $$ Variable called one with value 1
IMPORT one $$ Recursion


I think bit is an interesting language because of the type of thinking you need to program in it.


Programming in Bit

Chat room:

(none yet)

Interesting questions

Some interesting questions to be asked about this language:

  • A cat program (actually quite easy)
  • Input adder (Possible but hard)
  • Split input by commas and print each item
  • Quine

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