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.