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.

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

Perl! It is a language with a lot of soul and the llama book is actually fun to read.

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)

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

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.

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.

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.

Just pick a thing you want to work on. If it's a website it's JS/TS, if it's a terminal app then python (or JS/TS). If it's a desktop app then I'd personally say C# but opinions vary wildly. If you want to do something embedded (microcontroller) then C, Zig or python. If it's a mobile app then Swift for iOS, Java/Kotlin for Android or Dart/Flutter.

Honestly, python is IMO the best to get going unless you want to make a website then it's JS/TS.

Web frameworks can be fun to learn but it might be a bit much to start out but making an Astro blog is easy and fun. If you want to spice it up to a Web app then I recommend Vue even though I work with angular and know react.

But yeah, I recommend python to most beginners unless you want your first thingy to be a website.