11 cutting-edge programming languages to learn now

A clean slate. A fresh start. The new broom sweeps clean. The folk sayings are in agreement. Sure, your favorite old programming language is comfortable and easy to use. You know the APIs and libraries backward and forward. But you also know all the glitches, bugs, and failure modes that go with it. What was once perfect has gone a bit stale.

A new language is just the thing, and it seems dozens of great new ones launch every year. Programmers love to innovate and one of the fundamental strategies of innovation is creating something new that wipes away all the old problems. The new syntax and semantics provide a better foundation because they promote constructing good, solid, relatively bug-free code.

Here are 11 cutting-edge programming languages that are notable and possibly worthy of your time. Some are just a year or two old. Some are a bit older but still gaining traction. All of them offer a solution to some nasty issue older languages somehow never solved.

Even if these new science projects don’t solve every problem, you’ll still learn something by studying them that you can use with your current standby language. Many older programming languages are refreshed and reinvigorated by new approaches that are first tested and refined in experimental projects like these. The curators of the old recognize the genius and borrow—nay, steal—it for themselves.

The best way to experience a new language is to dive in and use it for something small, say a skunk works project or a small utility. Build it. Test it. Fiddle with the new features. That’s how you’ll find out what a new language can really do, and why someone created it in the first place.

Coq

Much of the confusion for developers is trying to sort through all the words for more or less the same thing. Do we write “functions,” “subroutines,” “methods,” or something else entirely? All are pretty much the same—at least if you’re being abstract enough. Coq takes this game a bit further and asks you to specify problems in a theorem about a hierarchy of types. Then it works on finding and verifying a proof of the statement. Of course, this proof is also the answer you’re looking for, at least if you get the hierarchy correct.

Yes, it’s very nerdy. You might think embracing the deep mathematical foundations of programming is unnecessary for building, say, a version of Pong. But it can be useful when the problem is more complex. Coq’s structure is helpful for working with problems with complex combinations or multiple levels with lots of restrictions or rules. It’s not for everyone or every problem, but it’s a good way to handle some of the more complex problems that appear.

Observable

Is Observable an actual language? The documentation says you can write your instructions in “any language”—a promise that would seem to make it a box that can’t be boxed in.

Observable is really a mechanism for building data-filled displays or dashboards. The point is you can use it to stitch together many libraries and other bundles of code that run as services or APIs. The top level is written in markdown. The charts use JavaScript because they rely on D3, Leaflet, and several other blobs of code that run in the browser. The lowest levels can be anything but many use SQL, Python, or R.

Some might call Observable a domain-specific language. The documentation calls it a “framework.” Or maybe we should think of it as a “stack”—one that’s been polished enough so the blocks run with relative harmony to deliver active telemetry.

Plang

Everyone knows large language models do a pretty good job of creating the first draft of some code. They’re rarely perfect, but it’s clear that the models have learned something from scraping all of those websites filled with coding help.

Plang is the next logical step. The creators bolted the LLM directly to the compiler and arranged for it to run code without waiting for you to cut and paste it. You just type some basic, handwavy instructions, and Plang does the rest. Or, it tries to.

It’s dangerous to promise too much about a system that doesn’t have a rigid set of semantic rules with an obvious mapping to machine code, but Plang’s output often seems miraculous. And if it doesn’t solve the problem completely, it might get you 90% of the way there. That leaves only 10% of the work left to do, which seems like a good bargain to me.

Python supersets: Mojo and Eng

Python is a powerhouse language that has a large community that knows and usually loves it. Sometimes some people want it to be more than that, though, and a few of them are actually willing to do something about it. Mojo and Erg are two languages that start with Python and add extra features like static typing and memory safety to speed up the end product and make it more robust.

Mojo is a strict superset which means that your old Python code should still run, so you can slowly enhance your code by rewriting the parts that need a bit more speed. Erg is said to be largely compatible with Python, meaning not everything will run perfectly, but the syntax should be as familiar as an old pair of slippers.

The two languages differ in important ways. Erg’s team has implemented a more complex and ambitious strategy, which is also a bit stricter. This is a language that wants to push functional programming more, so it departs from the standard Python approach. Mojo sticks closer to standard Python. The Mojo creators also seem to be targeting system-level work. The compiler focus on memory safety enhances Mojo’s ability to deliver fast performance and, as its website proclaims, “scale all the way down to the metal.” The AI community already uses Python for many applications and Mojo wants to support the better performance that’s necessary for larger models. Both languages are a good way to leverage your Python knowledge and tackle more complex chores.

Programming at the edge: MoonBit and Wing

Developers who write code that runs on the edges of the Internet often use standard languages like JavaScript, Java, or Python. Many edge computing platforms leverage the old standards, and that’s fine.

However, there are limitations to trying to teach an old dog new tricks. Some are building new languages, like MoonBit and Wing, that try to deliver better performance for the often tiny tasks at hand. These languages make it easier for developers to craft executable code that starts up in a snap and finishes as quickly as possible.

MoonBit emphasizes the size of the executable that is ultimately delivered as WebAssembly. It offers a lightweight and statically typed mixture of object and functional approaches, then relies on a smart compiler to optimize the entire program at once, squeezing out every opportunity for speed. Some describe it as “data-oriented,” which in this case means that it’s aimed at processing endless streams of bytes.

Wing focuses on helping the cloud programmer by offering many abstractions that handle the chores and scut work that cloud computing entails. Ideally, developers don’t need to worry about things like defining the network, identity management, and regulating access. The code ends up being compiled down to JavaScript, which is then run with JIT compilers.

Memory ownership: Rust, Zig, Jakt, Odin, and Mojo

Juggling variables and data structures is one of the perennial challenges for programmers who’ve relied on techniques like reference counting or garbage collection. Lately, languages like Rust are gaining attention with a memory model that gives each value one and only one official owner. Others can access a value by “borrowing” it, but the control remains with the official owner. When the owner dies, the memory is recovered.

Rust’s approach, sometimes called memory safety, and sometimes just “ownership and borrowing,” is found in other languages like Zig, Jakt, Odin, and Mojo. All present the memory ownership concept wrapped up in their favorite syntax. Jakt, for instance, transpiles into C++. Zig is a systems language that looks quite a bit like C. Mojo, as previously noted, is a superset of Python.

For now, Rust is probably the flagship language for memory safety. Programmers report that their Rust code avoids many of the race conditions and null dereferences that keep other developers digging through stack traces looking for a culprit. The strict rules about ownership produce more reliable system-level code that doesn’t crash, lock up, or leak memory.