As someone who uses Rust for everything since a few months and really like it, I often thought about learn something else, just to try it out and maybe learn something from it, but I haven't found something that does things different to Rust in a good way or has some really unique features (Except for essential domain-specific languages like JS). I think Rust has set the bar very high for me.
Some examples include:
C / C++: memory unsafety, technical debt etc.
Kotlin: we already have most of the features and cross-platform (sort of) with way better performance
Haskell: Rust is already partially functional and it does not seem to be super alive
Java: OOP, technical debt, etc.
While I do know that some of these can depend from person to person, I hope you understood what I mean. Thanks in advance!
I assume you want to discover something new. Then you should learn Javascript using Deno or Bun runtime. I prefer Deno as it's backed with Rust code and you can experiment the internal. You can also interfacing your Js using Rust with FFI.
Despite you say it is a DSL, you can build complete app with it.
For sure, yes. I meant DSL in terms of "language that is essential for a certain domain". When building an app, I would prefer rust though
Will try it maybe
If you seek similarity, you can learn Swift or Scala. Kotlin also good enough for me. But I don't use these languages.
I often discover unique features of other language through conference videos and blog posts. When it is interesting enough and I have a clear path on when to use the language, I tried it.
this post reminds me of an old but classic article: "beating the averages", by Paul Graham, in which he coined the concept of "The Blub Paradox".
that article is about the "niche" language lisp, specifically, common lisp. you mentioned you felt haskell was not very "alive". but if you really learn and use haskell, you'll find it super relevant for most programming activities, even for rust (or C++) programmers, although not in the way you thought.
functional programming really can change the way you think about programming, about problem solving. languages like haskell, requires abstract thinking, but it might be intimidating for people who don't like mathematical lingos.
if you have not used lisps before, I suggest you also learn some lisp. for example, clojure is a very good and recent lisp dialect. you can watch one (or both) of the "Clojure for Java programmers" and "Clojure for Lisp programmers" talks on youtube as a starting point.
Similarity makes you feel at home but with some difference here and there. I agreed with @nerditation that these differences may or may not be appreciated.
For what it's worth, I was asking myself the same question as yours, not too long ago. My conclusion was that a functional language would be educational, quite different, and very interesting at the same time. It's a different way of thinking, but I think it can bring another perspective to the way of programming in imperative languages.
I looked a little into that, but I'm not very far.
It's true that Haskell doesn't seem as lively, though there's a community. It's a more "theoretical" language in that it's more often used for academic purposes than for products and purely functional. I like the language better than OCaml, however (for the little I saw).
OCaml seems more pragmatic: not pure functional only, more predictable performances, and maybe more approachable for people used to imperative programming. Installing it on Windows is a real pain, though, so if that's what you're using, you'll have to be persistent (DkML would be my advice).
There's also Gleam, which seems more pragmatic than purely functional, too, and which has some remote similarities with Rust. It doesn't compile to machine code, if that's important, but to Erlang's VM (BEAM bytecode). It's a relatively new language / project and seems very active. I barely know anything about Gleam, though.
You sound exactly like me before I finally went with Rust.
I remember that feeling — I was hunting for a language that could give me the same kind of butterflies Go once did… and nothing else came close. Every doc felt dry, nothing clicked - until I read The Rust Programming Language book and I was immediately hooked.
And that’s exactly why I think you should give Go a chance. But skip the surface-level docs — they don’t do it justice. Start with Idiomatic Go by Jon Bodner, then move to The Go Programming Language by Addison-Wesley. You’ll start to see the quiet beauty in how Go thinks: no ceremony, no hidden complexity — just that clean, deliberate feeling of “ah, this makes sense.”
I’ve been using Rust for months now, and I still catch myself missing Go sometimes. Rust makes you feel powerful.
Go makes you feel at peace.
As for programming languages, I'd recommend Python, Scheme, Pascal and Java, just to broaden your pallette.
For practicality, I'd recommend C, C++, Java and Python.
C - Because Rust's foreign function interface is tuned to it and there is a lot of C out there to interface with.
Assembler - Because it's good for the soul for every programmer to have some idea what goes on under the hood, basically what their compilers do for them
Javascript - Because it's essential if you want to get anything to work in the browser. Even your Rust compiled to WASM. Because JS is the only language I know that offers genuinely different ways of programming. Everything depends on the event loop.
Verilog - Because if you want a language that makes you think differently that is it. Being a hardware description language everything is parallel, all the time. Designing your own logic hardware is a lot of fun. You'll need at least an FPGA to really reply your code but they can be had cheaply. There are open source simulators that make testing your designs on your PC as easy as running JS or Python.
Here are some ideas for kinds of languages you might find interesting if you are looking to broaden your mind:
something Lisp-ish
something Prolog-ish
something Forth-ish
something APL-ish
something Shell-ish
something Assembly-ish
something Prover-ish
Since you use and like Rust, you might find Steel an interesting Scheme/Lisp dialect, in part because it was designed with Rust interop in mind. You might actually find a use for that someday.
Learning an assembly language will teach you a lot. I'd go straight for RISC-V -- it is straightforward and -- because of its extensibility, potential power efficiency, and lack of license fees -- rapidly gaining traction. It is suitable for quite a range of systems, from tiny 10-cent processors to powerful 256-core clusters in the datacenter.
You might find Uiua interesting -- and useful, since it can be embedded in Rust programs as a library. It's a modern array language (APL-ish) that is also stack-based (Forth-ish); it emphasizes function composition and tacit style.
Nushell is a modern shell that you might fall in love with if you work with lots of data, since (unlike traditional shells) it was designed to deal with structured data rather than just lines of text. You can write plugins for it in Rust.
Agda might be interesting if you have a math background, because you can use it to prove theorems.
Scryer Prolog is written in Rust and can be embedded in a Rust program as a library.
