What type of fun are you after?

https://images.prismic.io/sketchplanations/281df432-3a48-4e78-ac58-1ff835091f99_SP+582+-+The+fun+scale+-+revised.png?auto=format%2Ccompress&fit=max&w=1920

Type 1 is probably python.

Type 2 is probably rust or c.

Type 3 is one of the esolangs. Uiua. Or assembly.

I don’t need something practical. I just need something fun to keep me motivated.

People have already mentioned Lisps. So, I wont repeat that. So, let me tell you about this great one.

Forth. And the best way to learn forth is by implementing one for yourself. There are lots of forths out there, almost as many as prolific forth programmers, I suppose. You are supposed to find your own forth. Forth is one of those rare languages (along with Lisps) where you build the language upwards to fit the problem you aim to solve, than convert the problem down to code. Here's a blogumentary on forth for your perusal.

It is not an easy programming language to learn. The concepts you need to understand is quite low-level. "Real" forths are usually implemented in assembly. If this sounds fun to you and you have time and patience to take the challenge, have a try.

If you’re looking for something fun to write you might want Ruby. Literally built from the ground up with developer satisfaction as the primary goal.

Very expressive, plenty powerful. Not my absolute personal favorite but I can’t deny it’s satisfying to use.

Haskell or Clojure (or Common Lisp) if you want something weird but neat as alternatives.

I've seen a lot of technical recommendations, but what I found most fun to experiment with is visual/art/music stuff, so here are some recommendation if that's also your thing. It's not strictly programming, because most of it requires learning more skills than just that, but I see that as an advantage. YMMV, though.

The Book of Shaders is and extremely good introduction to some basic shader stuff. Especially thanks to the interactive editor they have in their tutorials, and web tools like Shadertoy, experimenting with shaders is easier than ever. It was the tutorial that made me finally get past the "super confused" part of learning shaders.

It's kind of math heavy, especially once you get into 3D stuff, but I find it fun to learn, plus it's a rabbit hole and you can do some pretty cool stuff once you get into it. In general, anything technical artist related is interesting.

Another thing I'd recommend is looking into Algoraves. Algoraves are live performances where both visuals and music is performed by people live-coding their tracks and projections in some kind of language that's made for the task. TidalCycles, one of the libraries/languages that's commonly used, has a web editor, and there's also Sonic Pi, although I've never tried that one.

Processing is another language/tool used for making visual art. It also has a web edittor (with a lot of tutorials), and can make some cool visual stuff that can be fun to learn.

And one last recommendation, this time not about art, but about learning/building your CPU, your own assembly language, and learning to do stuff in it! Turing Complete is a puzzle game, where you will learn how to build your own CPU, starting from a single NAND gate, slowly combining them into registers, memory, adders, ALU, up until you have your own, complete and working CPU. You then create your own instruction set and use your CPU to solve a few puzzles.

It's super fun and engaging, and I'd consider learning logic gates and building a CPU as kind of also programming.

since you mentioned Rust, it can also be a matter of how you approach learning it – maybe learning a game might be more comfortable – as an example, Reddit’s r/roguelikedev links to multiple tutorials in multiple languages (with at least three Rust based options):

• Roguelike Tutorial - In Rust – also available as a book if you want something more physical
• Roguelike Tutorial in Rust + tcod – uses libtcod from the original Python tutorials they started with
• Roguelike Tutorial 2020

So, I can't answer the question of "what's the most fun language to learn" because that's highly subjective and my answer almost certainly wouldn't align with your experience. What I can do though is share my thoughts about different languages I've used over the years (in no particular order).

• Assembly: the bedrock upon which all other languages are built. If you want to understand how a computer really works, this is a great language to learn, and it's honestly not that hard to learn. Writing something in assembly much more complicated than hello world is incredibly painful because of just how much you need to do and really makes you appreciate how much you get out of the box with other languages, but it's not hard in the "I don't get it" way, so much as "oh god, that's only 1% of what I need to do and it took me an entire day". This is also a great way to develop a deeper understanding of pointers and memory management.
• C: assembly on steroids. Not quite as painful as assembly because you get a lot of libraries that take care of things for you, but still quite tedious compared to most other languages. The type system such as it is is practically nonexistent so your ability to design APIs is highly limited, and it's incredibly easy to introduce subtle and hard to find bugs. Relatively easy to learn, hard to master, and an act of masochism to use for large projects. At a minimum probably worth learning because C is the de facto interop language any time you want to interface two different languages together.
• C++: C with the entire kitchen sink of comp. sci bolted on top of it. There's a good language in there somewhere, it's just buried under decades of terrible ideas and half baked experiments. If you know which are the "good parts" and which are the parts to ignore it's not bad, but figuring that out is far from a trivial task and everyone you ask is going to have a slightly different answer. I'd honestly say avoid this one unless you want to spend a couple years exploring all its dark corners and forgotten nooks.
• LISP (and derivatives like Scheme): ye old functional language. This is basically the assembly of functional programming. It's "simple" to learn, but the lack of features is going to start to grate on you after a while, and the syntax is just horrible. Absolutely worth learning to learn to think functionally, but once you do I'd move to a better language.
• Haskell: Like LISP but with a masters degree in set theory, a MUCH better syntax, and one of the absolute best type systems ever created. Amazing language that will expand your mind just from learning it but might kill you from a brain aneurysm in the process. To abuse a meme, this is the dark souls of functional programming.
• JavaScript: A badly designed scripting language that was thrown together from a box of scraps in a cave, but rather than making it better over the years everyone just said "eh, good enough". Its original sin was that in an attempt to make it "beginner friendly" they made the syntax incredibly sloppy which means it's very easy to introduce bugs on accident and then very hard to actually find them because they don't error, they just silently do the wrong thing.
• Typescript: A better JavaScript in every metric. At the end of the day under the hood it's still JavaScript at runtime so it can only do so much, but the addition of a real type system goes a LONG way towards making JavaScript more bearable to work in and helps eliminate a ton of bugs.
• Perl: What LISP is to functional programming, Perl is to basic collection types. Scalars (single values), Lists, and Maps are your building blocks in Perl. It's not a bad language exactly, but these days other languages do almost everything it does but better. If there's one significant criticism you could level on Perl it's that the syntax is really easy to abuse to write some truly obtuse code. This is effectively a dead language these days, but it does live on a little bit by being the gold standard in regular expression design that everyone else just copied.
• Lua: One of if not the best scripting languages currently out there. It's very similar to Perl except it went all in on Maps. It's simple to learn, and simple to master, although that comes with the downside that it's nowhere near as powerful as other languages. Out of the box you don't really get much with it, but since it's designed to be embedded it's really easy to extend and there are versions of it that come with all the bells an whistles you need to use it directly for writing apps. I'm not sure I'd recommend it over another language in general, but if you're looking for a scripting language to embed in something else it's my top pick. The web ecosystem would be a lot less of a mess if Lua had been the language picked at the dawn of the internet instead of JavaScript (to be fair I'm like 99.9% sure Lua didn't exist back then but I'm too lazy to verify that).
• Python: A competent language. It's not a particularly great language and definitely has some warts, but there's not really anything in the language that makes me go "ewwww" except maybe the significant whitespace, although Haskell does the same thing so it would be hypocritical of me to ding Python for that. It's a solid middle of the road language, nothing really amazing about it, but nothing really bad either. It's biggest flaw is its duck typing system which really limits your ability to write APIs in it. If you want to crunch some numbers it has some really great data analysis libraries and frameworks, although performance isn't anything to write home about either.
• Ruby: The train wreck that happens when Perl crashes into Python and the mangled remains crawl from the wreckage. It's the terrible syntax of Perl crossed with the middling type system of Python with a sprinkling of bad choices all its own. Performance is horrible and the language has a lot of features that make it easy to write obtuse code. Like Perl this is an effectively dead language. Just use Python or something better.
• Go: Created in part by one of the guys involved in the creation of C and set out to be a "simple" language that anyone could learn. It does succeed in being simple, but the tradeoff is that it pushes all the complexity that most other languages handle for you onto the programmer to handle. Go programs are going to end up being a lot more verbose and filled with boilerplate than they would be in another language. It also still suffers from an early decision related to its generics system that leads to them being largely useless. Not unsurprisingly working in Go feels a lot like working in C, you often find yourself wishing the language handled a bunch of things for you or at least gave you some syntactic sugar to handle them more concisely yourself.
• Java: Has a reputation for being verbose but that's more to do with the community than the language itself. Also has a reputation for being slow, and while startup times are certainly a problem at runtime it's surprisingly fast these days. Not a great language, but nowhere near as terrible as its reputation would make you think.
• Kotlin: Java alternative. Solves some of Javas problems, introduces some of its own. At one point it was the clearly superior choice compared to Java, but since then Java has closed the distance and honestly it's a coin flip as to which is the better language between the two.
• C#: Microsoft Java. Seriously, everything you can say about Java applies equally to C# and vice versa. It's not a better or worse language, it's just different. Criticisms of C# are less about the language and more about the company behind it.
• Rust: A type system nearly as powerful as Haskell's, low level primitives that let you write bare metal code, but advanced abstractions that let you write high level code as well, and a truly unique approach to addressing concurrency and memory safety by way of the ownership system. One of the more interesting languages out there and my personal pick for "best" language because it gives you tools to solve some of the hardest problems to deal with in programming.
• Zig: A better C. Has a somewhat powerful type system a bit like Rust or Haskell as well as a pretty unique and interesting macro system, but ultimately lacks some of the higher level features that something like Rust would give you. It's similar to C in that it it can be somewhat tedious to work with but on the whole not a bad language.

take a look at one of the “fantasy consoles”, can do quick scripts and see results immediately:

• TIC-80 – primarily uses Lua but they’ve added in support for Ruby, JS, Moon, Fennel, Scheme, Squirrel, Wren, WASM, Janet, and Python as well
• uxn – virtual machine using uxntal, a kind of Forth/assembly hybrid

for an actual language, don’t discount Lua – simple, fast, tiny – “real programmers” like to ridicule it, and yet it keeps turning up everywhere from video game scripting to text editor configuration to databases to web servers

• Learn X in Y Minutes – a good introduction to a lot of languages, gives you a good idea of their look-and-feel
• Rosetta Code – LOTS of languages with LOTS of code examples

Easy: CircuitPython running on an RP2040 or RP2350 microcontroller. Being able to write a simple bit of code and have it control something in the real world is sooooooo satisfying. OMG: You'll jump for joy the first time you get it controlling some LEDs, a display, a servo, a motor, etc.

Programming a microcontroller for the first time was definitely the most fun I ever had when programming. CircuitPython makes it so easy, too! Oh if only it had existed back when I started learning electronics.

Elixir. Especially with OTP to write distributed systems. Or with phoenix and liveview for web apps

It's a functional language based on Erlang with a nicer syntax

Learn what makes LISP LISP (lambda calculus), then start creating LISP-like interpreters in. every. language.

This video might pique your interest in the topic - William Byrd on "The Most Beautiful Program Ever Written" [PWL NYC] (tldw; he explains and shows how to build a LISP interpreter in LISP)

Probably Python. It’s very accessible.

Lolcode:

HAI 1.2

HOW IZ I FIZZBUZZ YR INPUT
    I HAS A RESULT ITZ A YARN

    I HAS A FIZZ ITZ MOD OF INPUT AN 3
    I HAS A BUZZ ITZ MOD OF INPUT AN 5

C and assembly if you like learning how computers work

Python and typescript if you want to make blinky lights

If you really want to immerse yourself, also use it as the config. language for your Linux distribution.

Write GTK app.s with it.

Stretch your project legs with writing a simple web app. with it.

Explore the sheer joy and consummate beauty of minimal syntax.

Python is one of the more forgiving and extremely versatile.

I highly recommend checking out the game “The Farmer Was Replaced” on Steam as it might be the best way to introduce yourself to programming concepts outside of a classroom. (Not affiliated, just love the game XD)

Then in no particular order:

• Rust (and understand C++ and all interops)
• Typescript
• Bash
• DotNet (Java that works)

And as always - learning the anti patterns is more important than learning the patterns.

I had the most fun learning Haskell. Mostly because it was so different from the languages that I knew. Also, learning Lean was fun. But I guess that's kinda niche since it's not very relevant for anything but pure mathematics.

Logo. Turtle graphics spirographs go weeeeeeee!

At least, that's the most fun I had programming as a kid. There might be other good options nowadays, like Scratch or whatever they use to program those Lego robots.

I am having the time of my life with Clojure. Lisps in general. They really change how you view software. I was showing how clojure works to my Java coworker and showing her the REPL and powers of Clojure, and we both almost teared up :)) It's tgat good.

The most fun languages to learn that I have learned so far, are Haskell, Factor, Prolog and Agda. Each are quite different from mainstream programming and each other, and it is really satisfying when concepts "click"

Fun? Lua, Odin, nim, zig.

Impractical? Brain fuck.

So, if you're brand new and want to learn concepts of how to write code, I might suggest a game. There are a lot of programming games. Obviously it's never a one to one about learning something useful, and a lot of them even make "bad" things useful (though not bad enough to think it's going to teach you bad habits you won't be able to unlearn). I really enjoyed Exapunks, but it's sort of unrealistic. The Farmer Was Replaced looks fun as well and uses a "simple Python-like" language, but I haven't played it.

If you sort of already understand the concepts and want to dive into a real language, well, it's hard to say what will be fun. Chase your fun. It might be easier to think about what's not fun and avoid languages at the start that deal with that. For example, if setting up an environment to code in is the problem, then maybe something like JavaScript would be a good place to start. It runs in your browser! Press F12, click "console", type alert("Hello, World!"), boom, done, you just did Hello World in JavaScript without downloading anything at all.