Languages that Gamed

The following is my break down of languages based on how well I think they support desktop/web/mobile game development. These are my own observations and feelings. Things will likely be updated as time goes on (or people send me angry post on mastodon about how I misrepresented their fav language). This list mostly serves as a means for me to remember what I have looked over already.

Also, keep in mind this list is mostly looking at desktop and browser game development. Server-client based games are out of scope. Additionally, factor such as ease of distribution are a factor (do you need access to the host system to make a game for it? Does it have web support? How hard is it to distribute the runtime?)

Definitely Gaming

This section is for languages that have notable support for working with games. Be it a rich collection of libraries, a long history in game development, a major framework that has seen multiple releases, or a library that I feel is reliable enough to lean on.

Languages

• C

  • A long history of being used to develop games. Lots of projects still using it with many of core libraries developed in it. Not as popular of a choice these days (I think).

• C++

  • The current reigning king of game development. Backed into the fabric of the industry. It'll be a long long time before it's crown is ever taken.

• C#

  • Made popular by Microsoft's XNA framework and later Unity. Well known and well worn throughout game development.

• Dart

  • Apparently there is a dedicated engine for 2D game in Dart maintained by the Flutter developers. Seems quite well supported and fleshed out.

• Go

  • A weaker entry on this list, but there exist pure Go frameworks and libraries. This makes cross-compiling extremely easy. Frameworks such as Ebitengine have seen multiple commercial releases.

• Java

  • Java has mature, well-maintained, and well-known tool-kits for game development such as LWJGL (which is used by Minecraft) and LibGDX.

• JavaScript & TypeScript

  • JavaScript is the first-class language of the web. While it might not be most peoples "first thought", it is definitely ubiquitous for HTML5 projects. Tho, that has been challenged thanks to WASM.

    TypeScript being a strict superset of JavaScript doesn't need it's own section. Valid JavaScript is valid TypeScript.

• Lil

  • Lil is an embeddable scripting language. The main application it's embedded into is Decker.

    Decker can be used to make application, games, and other ineractable utilitize which can be easily distributed.

• Lua

  • A common scripting language with many framework enabling whole games to be created with the language.

• Nim

  • Nim seems to have many frameworks and engines to choose from. Additionally, multiple projects have been published using Nim.

• Python

  • I was debating where to put Python. There are many example of using Python for game development successfully. Additionally, it's the backbone of tools like RenPy. I don't think Python is a good choice for many reasons, but I'll stick it here anyways.

• Ruby

  • Ruby has been used by older version of RPG Maker. Additioinally, the creator of SDL2 has co-authored a Ruby game engine (DragonRuby). It's pretty solid.

Languages that Can Surf

Languages in this category do not have a robust game development story, but they can however surf atop another language that does.

Languages

• Clojure (Surfs on Java, .NET, and JavaScript)

  • A lisp developed by Rich Hickey that enables dynamically typed functional programming on the JVM and CLR. The dailected ClojureScript allows for JavaScript related development.

• F# (Surfs on C#)

  • It's worth noting that manyh projects integrating C# are designed in a way that is incompatible with F#. For example, Godot has C# support but in 4.0 introduced the usage of partial class. This is not and likely will not be supported in F# as it is a compiler feature of C#.

• Fennel (Surfs on Lua)

  • A lisp built over top of Lua that allows you to leverage it's ecosystem. Some projects have been written in it. Fantasy consoles such as the TIC-80 support as a "native" scripting language.

• Flix

  • Flix is a functional, imperative, and logic programming language. It combines a wide array of features such as pattern matching, extensible records, type classes, hgher-kinded types, and more all running utom of the JVM. This language can import any package on Mavin giving it some access to LibGDX. However, you'll have to do a ton of binding work.

    This language is quiet early in development. Could easily be listed under "You Are On Your Own".

• Haxe (Surfs on many and itself)

  • Haxe was designed from the ground up as a language that targets other languages. It has the ability to surf on JavaScript, C++, Lua, C#, Python, Java, formally Flash and ActionScript. It additionally ships it's own VM and bindings to SDL2.

    Unfortunately, I feel that Haxe ecosystem has langished since the death of Flash.

• Kotlin (Surfs on Java)

  • A language developed by JetBrains that surfs onto of the Java ecosystem. Projects can intermix Java and Kotlin code allowing for usage of Java depedencies in a Kotlin project.

• Scala (Surfs on Java)

  • Like Kotlin, it surfs over top of the Java ecosystem. Intlope with Java is also a priority with Scala. Thus, it can be used in place of and alongside Java in projects.

Game Oriented DSLs

This category is defined by languages that exist as engine-specific language, in-studio created language, or some other DSL created specifically for making games.

Languages

• GameMaker Language (GML)

  • Proprietary language of GameMaker.

• Game Oriented Assembly Lisp (GOAL) [Historic Inclusion]

  • A Lisp formerly used by Naughty Dog studios during the development of the Jak and Daxter series. Additionally, it's predicessor GOOL was developed for Crash Bandicoot.

    While no longer in usage by Naughty Dog, I include it as an example of building your own tooling in a style of language you prefer.

• Event Sheets

  • This is a programming system employed by the engines GDevelop and Construct. It allows its user to write games a visual scripting system based around events.

• GDScript

  • The primary scripting language of the Godot game engine. It has python-like syntax, no garbage collector, and a gradual type system. It was developed do to issues embedding languages such as Lua nd python.

    It's currently the primiary choice among Godot users.

• Inform7

  • Inform7 is a scripting language used to develope interactive fiction. It uses Natural-language programming to allow a user to write code in a narative fashion.

• PuzzleScript

  • Was a programming language developed to lower the bar for people looking to develop puzzle games. It uses a rule based system to define interactions between objects.

    There is an ammusing argument that it's a purely functional logic language to some degree.

• Scratch

  • No, I'm not joking. Scratch even has a high-preformance implementation called TurboWrap that can even handle raytracing. It's a good example of a visual scripting system.

• Twine Story Formats

  • Lumping all these into one group. They all generally sure the same perpose with different design goals. Each one provides a way to script the Twine engine. Allow the users to use advanced macros to effect the logic of an IF. Examples of story formats:

    • Chapbook
    • Harlow
    • SugarCube

• Unreal Engine Blueprints

  • Unreal Engine's visual scripting system.

Has the Parts, Bring Your Own Glue

This is a category for languages that have a limited set of tools to make games. Many libraries are early into development or lack dedicated maintenance. You'll likely need to write your own libraries and bindings.

• Crystal

  • Some raylib and SDL2 bindings exist. However, the tooling around the langauge is still immature. Additionally, this platform support is still under development.

• Common lisp

  • Additionally, there is work for a full Common Lisp powered tool-kit called Trial. Provides a whole horse of utils to develope games with.

    However, you will have a lot of engine work to do. Likely a good experience if you are adept with Lisp.

• Factor

  • A stack-based concatenative programming language. It has some bindings for various game libraries and toy examples. However, you'll be left to put it all together.

    Platform support is limited. And the community is miniscule.

• Haskell

  • There seems to be some kind of dedicated interest in using Haskell for game development. There are also well maintained and mature libraries for working graphical applications in Haskell.However, you will definitely have a lot of framework building to do.

• OCaml

  • There exist some game-oriented bindings for OCaml. Additionally, some people have made games using OCaml.

• Odin

  • A data-oriented language heavily focused around graphical development. It has numerous features around game development and graphics programming, a rich set of vendor bindings, and even production projects. While the community and tooling are young, you'll likely have many folks with a shared interest in game development hanging around.

• Rust

  • Lots of interest in using Rust in game development. Not may projects reaching the finish line. I know one game, The Gnorp Apologue, has made it to full release.

    Projects like bevy are working to bring ECS and data-driven development to Rust. Additionally, there are engines like Fyrox that has a fully featured editor.

• Scheme

  • There exist some tools and frameworks for developing games in lisp such as Chickadee. Additionally, there are buindings to common libraries such as Raylib and SDL2.

• Uxn with Varvara

  • Not totally sure where to put this one. It's has all the parts you'd want to make a game with. But it's low-level nature means you'll be relying on your own tools and design to pull through. It's well tested being the backbone of The Hundred Rabbit software collection.

You Are On Your Own

This is a category for languages that will require substantual work from the user to develop in. They have quirks that make binding existing libraries hard, languages that are quite young, lack robust tooling and/or have a small community.

• Elm

  • You can kinda surf on JavaScript's enviroment. However, the ecosystem has languished some after development of Elm slowed down. A major struggle with using Elm will be its restrictive FFI

• Forth

  • Forth is more of a design pattern that a language. There exist some tools to build graphical games using ANS Forth. However, you will largely be left to your own devices. Additionally, the community is very small and very niche, so finding assistance with issues may be hard. But, some games such as Death Road to Canada have invented their own Forth dialects. So, it's not impossible.

• Idris

  • A depedently-typed purely-functional programming language. It has the ability to surf on C and JavaScript. However, you'll will be building a lot of glue code and framework building.

• PureScript

  • This language can technically surf on JavaScript's tool kit. However, you'll be on your own for almost everything. Additionally, PureScripte has a tiny community.

• Wren

  • Wren is a small, class-based, concurrent scripting language. It claims to be inspired by SmallTalk (OOP), Lua (VM Size), and Erlang (Concurrency). I know of exactly one game engine thatembeds Wren: Dome. If you are interested in this langauge, you'll be largely on your own.
    However, Dome looks pretty solid as a toolkit.

• Zig

  • As far as I can tell, it's game development ecosystem is extremely nascent. Seems like it's more popular as a build system than langauge currently.

You Can Try

This the section for languages that will likely be a struggle to make a game with. Some of these languages not only lack tooling, but are designed in a way that might make developing such applications a challenge. Additionally, some languages in this category may be too young for game devleopment.

• Agda

  • It seems like there has been UI frameworks developed in Adga, so maybe it's possible. It can also surf on top of Haskell, but that is a very limited ecosystem already.

• BEAM Languages (Erlang, Elixir, et al)

  • I may be over confident when I state these languages were "never designed for game development". No language really is aside a few niche projects.

    There exist some bindings for Raylib, but Your Mileage May Vary. Additionally, I'm not sure how well you could distribute a BEAM-based project.

• Cyber

  • In development scripting language with JIT, concurrency, and gradual typing. It is too young to be put to useage, however the developer is interested in game development.

• Grain

  • A very young language that compiles to WASM. Has no DOM API nor JavaScript FFI. Far to young to make a game with.

• Koka

  • A in-development language with an effect system. Doesn't seem to offer a publically documented FFI system.

• Perl

  • Perl is surely old enough for people to have made games with it, written bindings, and even engines. But, it seems like it'll be a struggle.

• PHP

  • This language could be made to develop server-client type games. But you'll definitely struggle to do desktop game development with PHP. I'm sure many people would tell you to stop.

• Raku

  • Similar story to Perl. I'm sure there are bindings hanging around, but you'll be working alone for the most part. Distrubtion would also be a challenge.

• Roc

  • Has promise. But I have no idea how to actually *use* the language. It's extremely early into its development. You better be willing to contribute to the language's development alongside building your game.

• Uiua

  • A stack-oriented array programming language. Not sure if you could even do interactive graphics with Uiua.

• BQN

  • I have seen one demo of a basic game being made in BQN. One.