I just want to have fun programming again

This thread has a lot of language suggestions, but I think you need a fun problem to solve. Pick a toy app and work on it. Learn embedded programming with an Arduino. Write an iPhone app to track when you feed the dog. Make a karaoke app for Android. If you pick a project you'll enjoy, the language won't matter. Use whatever is best for the platform. The fun doesn't come with the language, it comes with seeing your project come to life, or others' reaction to the cool thing you made. Every language sucks and every language is the best depending on who you ask. Don't focus so deeply on that part. Solve cool and fun problems.

I've had a long time dream of getting a broken jukebox and gutting it for a Raspberry Pi, but keeping the external interface in tact. I know next to nothing about hardware engineering, and can't write more than ten lines of Python without needing to Google something, but I finally got a broken juke in need of fixing, a multimeter, and a hard drive full of music ready to go. The fun isn't the Python or learning GPIO, it's that eventually I will have a cool retro jukebox with hardware and software I wrote in my basement.

I found fun again in two easy steps:

(1) Unlearn the "large team workflow mindset" and embrace the "single developer mindset" again. You don't need a plan, a Kanban board or a bug database, just an idea in your head. Get rid of "big languages" which are good for team work, but just a hinderance when working alone. In my case this meant: dropping C++ and embracing C (today that would be: Zig). Focus on getting shit done like when you started out with programming instead of agonising over design decisions. It's better to throw away something that doesn't work than wasting too much time upfront with planning (and then it still won't work). At least you still learned something valuable. Try to do the 'planning' part passively in the back of your head out in nature while taking a walk or some other outdoor activity.

(2) Pick a challenging problem where you have no idea yet how it works, but which you would like to know. In my case this was "home computer emulators".

...well 3 steps, step 3 would be: don't set yourself any deadlines for this sort of "fun stuff".

You seem to have two very conflicting wishes here:

1) To have fun 2) To write a cross-platform web-base app with good HTML canvas inter-op ...

If you really want to deliver this cross-platform app, then it seems that's going to be more work than fun, although no doubt good tool/framework choice can help minimize the headaches.

For a fun project it seems better to avoid all of the things that you already know are going to make it not fun!

My current fun project is writing a compiler to run on an old 8-bit system (initially targeting en emulator) ... 99% useless, but fun, and I get to choose whether to implement the bits that are stupidity on behalf of the language spec, or extend the language to make it better, etc, etc - no practical considerations forcing requirements on me, since it is purely for fun.

> while I very much like Swift and working in the UIKit world, it's not so portable to platforms that many use.

Your title says you just want to have fun programming but your post is full of other requirements. You need to decide if having fun really is what you’re after—in which case it seems you’ve found your answer—or if it’s secondary to some other metric such as customer reach.

There is always a compromise. No solution is all good things at once, including easy, performant, and cross-platform. If that existed we’d all be on it. You’re clamouring for a past which I’m doubtful truly existed.

This will probably get lost in the noise. But I think what sucks the fun out of side projects is where your agency is taken away by the ‘right way’ to do things. That’s what makes embedded and a lot of Raspberry Pi projects so fun. There isn’t a large collective telling you to use X build tool plus Y framework, and if you don’t, it’s because you’re doing a bad job and don’t care. And if you ask a question like ‘how do I…’, the response is Y takes care of that for you, you should really use Y.

Pick up an Arduino and there’s no one right answer. It’s still very hobby oriented, so a lot of people do fun an wacky things. The learning curve is fairly short. What I call the ‘book count,’ or how many books you need to read to be productive, is pretty low. On the other end of embedded, it gets very formal, very quick, but that’s for professional embedded developers.

Or, pick a ‘dead’ language. Go to some vendor like thrift books, or hunt used book stores, for books on that language. You might find some for $5. There’s no pressure, and you have full agency to make the greatest or the worst decisions you want. And a lot of the communities around these ‘dead’ languages are a lot of fun.

Some recommendations for fun (web) programming:

- Forget about the JavaScript ecosystem, don't even touch it, it's a monster

- Use htmx on the front-end (https://htmx.org/)

- Use plain-old CSS with minimum dependencies (sanitize.css)

- Use lightweight CSS framework if you need one (bulma or purecss)

- Use Go on the backend (all other modern languages are bloated)

- Use AWS Lambda

- Use DynamoDB if you don't need data processing

- Use Postgres if you hate or don't want to learn DynamoDB

- Compile SQL to type-safe code (https://sqlc.dev/)

Left my job late last year with the intention of striking out on my own.

Instead I realized quickly that what drove me to quit had been the fact that the joy of coding had left me. And so for the last two months I have been working towards regaining it.

And at this point I realize I have gained it back.

The only projects I have been working on are small libraries and apps whose ideas had written down over the years but never touched.

The longest project has been 3 weeks. Others, like the library I worked on today, have only taken a couple of days. Also done some open source contributions here and there.

I would now recommend it to anyone, given if their financial situation allows for it, to step off the hamster wheel on occasion and work on the things that really motivate them.

When I re-enter the job market, it will be with renewed vigor and plenty of new know-how.

If you want to have fun, dig into some subfield of computer science, like databases, ray tracing, etc. Something that has been studied rigorously. There, knowledge actually compounds and builds on itself, rather than being thrown out every two years for no gain. Build something small and see if the subject gels with you. If it does, go deeper. If it doesn't, try another one and see if it works. Once you find something you like, you can start self-studying more with books and harder projects.

"But it's hard!" That's the point: surmounting the challenge is where the fun comes from. And then you have skills that 90% of devs don't even attempt because they believed it was "hard."

Pure JavaScript is fun and simple. If you want a hobby project, ditch all the frameworks, and go vanilla.

I started https://wordsandbuttons.online/ looking for something fun and meaningful to do. I wanted to practice interactive writing and wanted to involve the bare minimum of technology to go forward. So I use rudimentary HTML for layout, JavaScript for interactive illustrations and UI elements, and Python for massive code changes. I have a bit of CSS, but I don't use "cascading" feature of it so whenever I want to change a style overall, I write a Python script for that. On the plus side, every page is entirely self-contained, and my CSS is outrageously simple.

There are no dependencies not external no internal, so the workflow is entirely stress free. Well, rather stress isolated. If I break anything, I know that the breaking change is exactly in the thing I am currently working on and not anywhere else.

If you don't care about productivity and want to enjoy programming with as little tools and dependencies as possible, vanilla JavaScript is the way to go.

May I recommend making a simple game? Developing small games is a lot of fun, and you have complete control over the complexity you'd like to delve into, as well as the scope.

I've been making games with varying degrees of seriousness. I even released a full solo game last year, which was a wild ride. I'm lucky enough to have a job I'm satisfied with, but even so, creating games has never failed to introduce super interesting challenges, it's just a great creative outlet for code and art alike.

I think Godot (Python-like with C# support) is in a very interesting place right now, and it's easy to get into and start making some prototypes. If you want something more involved, try Monogame (C#). There are always Unreal (C++) and Unity (which IMO is getting harder and harder to recommend due to their business model and decisions as of late).

Plus, game developers have some of the best online communities on virtually any platform you can think of. You can always find someone to consult or even join a project, from modding to rev-share game development.

For UI I do think JS is your best option atm. You don't have to write JS to generate JS, you can use Typescript or go more exotic to things like Rescript.

In terms of CSS; you'll need some form of styling in whatever language, there are plenty of abstractions on top of CSS if you want [something not css].

I would suggest having a look at Next.js if a web app would work, React Native (use Expo) if you want mobile, or Tauri if you want to focus on desktop (Electron, but in Rust, more performant, smaller size, more secure).

Another thing worth checking out is Flutter. I'm personally not a huge fan for irrelevant reasons but it is cross platform, and it's compiled not-JS (Dart).

I also want to say FE has come a long way, the web platform is much more stable, there are great frameworks and libraries, the tooling is amazing, and above all it's really fun and productive. Give it a shot, you might enjoy it. (Do use TS, or Rescript, or something, JS is better with types).

https://elm-lang.org

https://elmlang.slack.com

Static FP lang targeting the web as a runtime environment. Wonderful people. The nicest compiler in the game. Tight dev loop. Good tooling.

No JavaScript knowledge required. Join us.

I had similar feelings, and I get the same feelings looking at today's front end development which looks increasingly like embedded C++ development. I had always tinkered with Lisp but expected it to be forever marginalized given how good Common Lisp was, and how poorly it had been adopted by industry. But Clojure changed that for me. The fun seems to come from agency, the ability to affect outcomes with reasonable amounts of time and energy expended. Agency is the ability to change one's circumstances, and modern tool chain's vast incidental complexity takes such agency away. But restore agency, and fun will follow, I suspect.

Now I don't mean to imply there are not good uses for tool chains like C++'s etc. Only I will say that the disconnection from the end result caused by the long write-debug-ship cycle leads to a certain programmer malaise. The same is true for things like coding chips with Verilog. The production chain is so long with respect to the creative endeavor itself that motivation and satisfaction is hard to get.

So, for me, doing SaaS software, which ships "all the time" with Clojure, has restored my ability to 1) read the std library and most others easily to understand them, 2) Create control, preprocessing and IO primitives myself for special purposes which easily rival standard ones, 3) use interop to access large libraries written in another long lived language (Java), 4) build and use tools that simply introspect the code, producing my own tool additions and automations without AST's, and elaborate tooling, after all, code is just data.

Obviously YMMV. One blog post documented someone who changed from C++ to Clojure and did not find satisfaction. But he was attempting to do something, embedded I believe, that is not well suited to a JVM. So changing to Clojure does involve changing to an area that favors one of the two big Clojure host language machines, JVM or Javascript based environments.

I'm very happy with Dioxus, a Rust UI framework. It might tick most of your boxes, except that it is still quite unfinished. On the positive side, the source code is easy enough so you can create PR's for missing features or bugs that you run into. Here's what's interesting

- You write everything in Rust. Dioxus runs by patching the output from your Rust code onto a VirtualDom in a Webview. So your code runs native, the WebView is just one big canvas that you use to display your UI. It's using WebKit/Tauri not Chromium, so apps are much smaller.

- It is super cross platform (macOS, Windows, Linux, Terminal, Wasm & (very unfinished) iOS/Android)

- You still need to understand some CSS but you could also use an existing framework like tailwind.

- BUT: The way Dioxus is structured, you don't have to Render to a WebView. You can plug in a custom renderer which gets told which elements should be placed in the UI with which parameters. That makes it easy to write a native AppKit or GTK renderer which just places widgets and uses a Flexbox system to figure out the sizing.

Most importantly, working with it is kinda fun. It also supports hot code reloading and so on.

https://dioxuslabs.com

I'm going to suggest Clojure. It is a very opinionated language made a person who was about to quit professional programming because of an explosion of complexity (both accidental and incidental).

Check out the talks by Rich Hickey to see if you have the same sentiment or perhaps this paper: https://download.clojure.org/papers/clojure-hopl-iv-final.pd...

The community of the language largely follows this philosophy, the ecosystem is very stable and there is little churn. The most common implementation is on the JVM making the language very portable.

The headaches historically were with getting your environment setup, but there are amazing tutorials and good tooling or VSCode, IDEA, Emacs and vim.

It's not "fun", but it's perhaps best to start with the problem you're trying to solve rather than the tools you want to use.

As for "fun" for UI, I found doing UI in Dear ImGui strangely liberating. It sounds like a web front end is part of your requirements, maybe, but if not, try one of the "immediate mode" UI toolkits like that. They have their limitations, for sure, but they come with a lot less "normative lifestyle assumptions" and it's strangely enjoyable to toss a UI together in them.

Also I started having a lot more "fun" once I start doing my hobby projects in Rust rather than C++... once I got past the initial learning curve... I say this not so much for the language side of things -- which can be a little straightjackety -- but for the fact that I was no longer fighting all the sharp corners in the C++ ecosystem (CMake, different 3rd party lib packaging styles, dubious 3rd party library programming styles/standards, etc.). Rust+Cargo simplifies a lot. And the third party crates are generally of pretty good quality and consistency.

Or learn another language, like Zig. That looks fun, too.

Nim is a fun language to program and also meets some of your requirements. It can compile to JS and has some libraries to interop with html. Admittedly it’s a bit limited on those packages but they exist.

HTML template: https://github.com/juancarlospaco/nim-html-dsl

SDL on emscripten: https://jipok.github.io/Nim-SDL2-and-Emscripten/

It is awesome to see all the comments in this thread recommending some form of embedded programming as a side project. I strongly recommend it too.

Here's my own fun embedded programming project... it's been 5 years now, so I should really do something like this again:

https://foundrytechnologies.com/relay.php

It didn't too well commercially, perhaps because the 3d-printed case I designed for it in looked a bit cheap. But the embedded coding was very fun, as well as putting all the pieces together (embedded coding, website & web app, PCB design, CAD and 3d-printing were all involved).

I did sell a few units, and shipped them worldwide. I still see them checking in with the server for updates every 5 minutes from around the world, and there's about half a dozen working around my house today, including one outside by the front door bell. That one's been exposed to the Texas elements for 5 years now and hasn't missed a beat, except that it needed a new case last year to keep it looking fresh.

Might I recommend instead of looking for a way to make things easier, instead you look for a way to make them harder.

There's more than one way to skin a cat, and for a project with even minimal complexity there are going to be tons of perfectly legitimate choices for how to bring it to fruition. In theory this is great, it's so easy to find a tool that works for you, but it's also very easy to get into analysis paralysis. If that's something that really bogs you down and makes the experience unpleasant, then you need a way of easily reducing the number of options. If you set out from the beginning to make a challenge out of it and add some stupid requirement that you have to satisfy, that can do the trick. You're no longer looking for the optimal choice, just an acceptable option.

There are other benefits: a handicap makes doing boring routine things stimulating and forces you to think about problems in new ways. If you choose a handicap that forces you to use something you don't have a lot of experience in, then it's a great way to learn. You tend to develop a deeper understanding of the fundamental principles underlying what you're trying to do. You can also be a bit easier on yourself about the quality of the end product since hey, it's pretty amazing that you could get it to work at all.

Your long list of desired features and properties, especially cross compatibility, is sucking all the fun out of the project. I also suspect the hobby project you chose (whatever it is) has so much idealism in it that it implies a lot of toil, e.g. a cross platform messaging app or one-storage-system-to-rule-them-all or The Next Great MMORPG.

The goal is too big and you are but one person with a day-job.

Don't quit your day job.

If you want to finish a project and have fun: Do not attempt to solve world hunger or censorship or any big problem, because you will find it is big and thorny.

Do: make a list of tiny projects. Extra tiny. Make sure they are fun, e.g. asteroids or Snake or displays-a-random-emoji or something silly.

Make a list of non-goals for your project: e.g. it will not be cross-compatible, it will not be multi-threaded, it will not support multiple users, it will not be scalable, it will not support multiple resolutions, etc. Try to make it so dang simple you think you can knock it out in 2 days. (It might still take a month)

If you need a framework or library, pick one and only one library. (write the rest yourself) Pick the smallest one you can find that covers the part of the project you don't wanna do, whether that's game physics calculations or databases or whatever.

And then write your project, preferably all in one big ugly file that does not meet anyone's definition of organization or documentation or quality.

That's when it's fun, when the scope is small and understandable, and there is no expectation of having to fix anyone else's bug reports but your own.

(To be clear, these rules are only for personal projects, I do not recommend this level of anarchy on a team or a "real project", just a project where the goal is to have fun.)

I've made snake, asteroids and Galaga clones in JavaScript. I had fun with them, and I threw the code over the wall for other people to look at; but for personal projects I am not promising anything other than that I had fun writing the code and playing the game I wrote.

You don't need much expertise in CSS to build common web UI patterns. It's been around a long time, and tropes like "it's hard to center a div" aren't really true anymore.

It's absolutely possible to build JavaScript apps in a single page with no external dependencies. All you need is a single .html file and a simple development server (I use python http.server).

Writing in typescript is a easy as a single dev dependency to compile the code. There's no multithreading but first class async support.

Additionally, JS / TS are very flexible. You can implement almost any programming paradigm you want to learn. I love doing FP in typescript personally.

>> I just want to have some fun writing something without headaches, and that is seemingly less and less easy to achieve today

Pick something that sounds refreshing and fun to you. A few recommendations for you: make a game for a fantasy console like pico8, walk through an adafruit embedded project, or get interested in the front end / design part of web development (look through dribbble for inspiration). You don't necessarily need much CSS and it's not hard to learn anyway.

>> I feel like there aren't really any good options in software development any more. It's always one big compromise with lots of possible decision fatigue. Every direction has drawbacks.

It seems most of your dissatisfaction comes from whining about the tech stack. Either focus less on the technology stack and more about the end product, or stop attaching emotion to decisions that are best made logically. It's okay if you choose options that have drawbacks if every option has drawbacks. There's no such thing as a silver bullet. Choosing the wrong option is rarely going to kill your project and you can always change directions later so breathe easy.

Write it as a CLI first, if you can. Python with rich (for output formatting) is a great choice. But if you have appropriate tools, working with what you're comfortable with is a great choice too.

Until recently, I was in a similar situation. I had an idea of what I wanted to do. I had some prototype code written up as a web app in JS. It was going to be this beautiful thing that would help so many people.

But then I realized it was too much pressure. I wanted this for myself more than anything else. So I sat down and hammered it out in python in an afternoon. (Full disclosure, python is my main language, and I already knew exactly what this thing needed to do. I also found a library that did the Hard Part for me.)

And the best part: when I tell certain people about what I built, they don't care that it's a janky CLI. They're just happy they don't have to build/commission it themselves.

Embrace jankiness and get something working. You'll have fun.

C#/.NET is cross platform. I find it more fun than doing things like php or node. But I also don’t follow the whole “everything needs an interface” crap, or the insane level of abstractions people seem to implement.

I’m sorry learning rust tho. Like it a lot.

My go to language for the last couple of years has been Dart, and I stuck with it because it's the first language I really enjoy.

Dart's "Rails" is Flutter, it lets you write apps for mobile on iOS, Android, web, desktop on Windows, Mac and Linux, and it's used on large enterprise projects, startups, and solopreneurs / pet projects.

Dart is a very consistent language (compared to others, at least), super easy to learn, null safety, great type system. You can write web apps with it even without Flutter (it can also compile to js), churn out command line tools, run your server, and write user interfaces for desktop, mobile and web apps with Flutter. It feels like it has the best parts of Java, Javascript.

It's been a fun couple of years for me and I created some fun stuff with Flutter and Dart, so if you want to try something new, consider taking a better look at them.

Pick a language that speaks to you and use it. Ignore any technical bike shedding in your head. I like Rust and continue to hack on projects in it, but my happy place is Go. It is safe enough, productive enough, and checks all my boxes for serious hobby work. Find your own happy environment and projects

C# with maui can natively compile (on most things), otherwise you can just ship the .net runtime with your app, you can target a webview on "any" platform with the same codebase and same tools using Blazor. Blazor has it's own syntax that works similar to Angular, but ALOT different. And you can pretty much do straight up C# in it. You also have super easy multithreading. And since all the frontend code is baked into your backend, it's super easy. You can also build webapps which function pretty much alone with no backend. Or have a backend linked into it. It also works in the browser and can target WASM, with the exact same codebase and UI as Linux, Windows, Iphone, ANdroid, etc(Assuming you use the webview with blazor)

> I feel like there aren't really any good options in software development any more. It's always one big compromise with lots of possible decision fatigue. Every direction has drawbacks.

You just gotta pick something and go. I know nothing about your app, but there's plenty of general purpose languages out there that wouldn't be a bad choice. Over-optimizing is gonna kill the fun and you'll get nowhere. Choose some tech that solves your immediate problems and maybe keep things modular so you can break out the pieces that aren't working later.

Remember the fun part is building things. So go build something.

I'm a many year old programmer myself.

The one thing I'd say is: Let the project select your tools, not the reverse.

Take your time, select your tools and libraries... and it is amazing things just seem to come together. Not every problem will fall to what you know today.

Yes, there will be compromise, but step back, and ask yourself... just how thankful you'd be for any of these options 10+ years ago. If the answer is not... don't use that tool. But many times, what we face is really a plethora of great decisions, and we try to look for the best... not realizing it doesn't exist today, only in retrospect.

Try a Lisp. I got seriously into Lisp because of Guile, a Scheme -- but Common Lisp is also a great place to start and the Portacle environment is an easy way to jump into that.

Lisp is the easiest, most fun language I've encountered to work in. It's like clay out of which you can sculpt a solution. Every programmer should give it a go.

For an even easier way to get started, consider building an app in Emacs Lisp. It needn't be huge, it could just be an automation for a pain point in your daily work. Emacs is easier, and more fun, to extend than just about any other editor.

If you want UI, there currently is no good solution. In my opinion, AppKit/UIKit is the only well-designed UI with any currency at the moment, but as you point out, it is not cross platform. If you're okay with using Dart, Flutter might be an option. Qt is well-designed, but last I worked with it they were embracing JavaScript, and why would you want JavaScript if you're using a C++ library? C++ is too philosophically opposed to JS. But Qt just feels slightly foreign on a Mac, anyway. GTK is in C, which is not really how I want to use an object-oriented design, plus its cross-platform feels buggy. And HTML is just simply not designed for user interface; writing a UI in HTML + JavaScript is basically equivalent to writing an app in MS Word macros. Plus, it's hard to take the NPM ecosystem seriously when you're old-skool enough to think that left-pad is the equivalent of fizz-buzz and putting it in a package should not even cross one's mind, let alone actually using said package.

I'm writing a cross-platform UI library (C++, but I hope to add Swift, Python, and maybe Rust bindings), because I'm in the same boat: https://github.com/eightbrains/uitk. It is usable, but still under development, and while the .h files are fairly heavily documented, there are no examples yet.

Javascript isn't complex. It was implemented in 2 weeks. React is also simple (in concept, not implementation).

I suggest programming with chat-GPT. I got it to help me to get started, research and break down very ambitious project that alone I just couldn't muster.

You didn't specify exactly what you problem is but if you are looking for easy UI that's canvas based then I guess https://flutter.dev/ might be just for you.

Write some C for your own pleasure and fun on an undead platform, like AmigaOS.

Due to the constrained nature of the undead platform there is no real possibility of decision fatigue, since the ways of solving a problem are few.

You may not realize it, but frameworks and libraries are your enemy. Write something with minimal dependencies. Take a language you already know and think of a simple, fun thing to make from scratch (for an arbitrary definition of 'from scratch').

You rightfully complained about the complexity of JavaScript or C++, but you don't have to use the majority of the features. With minimal external dependencies and no other programmers in the mix, you can choose a subset of the language and just stick with that.

It sounds like C/C++ would be a good fit if doing low level things is fun for you. Javascript/HTML/Canvas is also not a bad choice per se, you just don't need externalities such as bundlers, wasmers, deployers, dependency managers.

Whichever environment you decide to go with, start with an empty directory. NO package managers, either. If you absolutely must use an external library, copy it in deliberately and manually.

See how few things you actually need to make something fun and worthwhile!

Maybe play around with PICO-8? (https://www.lexaloffle.com/pico-8.php)

The highlighted programs are mostly games, but people have made all sorts of fun things like 3D CAD, music synthesis, text editors, etc.

It is certainly a break from complexity. And it is easy to export your program as a webpage.

I was getting a bit bored of c++ a few years ago and learned Haskell http://www.learnyouahaskell.com/ I used Haskell stack at the time and it was zero hassle to get coding. I did nothing practical, learned a lot and had a great time. My C++ is now way better.

I don't know of a current way to do front end dev without CSS. The frameworks which allowed you to do that, like Flash, Java Applets, Silverlight are long gone. You could try Blazor, it's statically compiled in C# and can run either on the server or in the browser, using WebAssembly.

I just discovered and it seems enticing: https://github.com/raysan5/raylib

> no fancy interface, no visual helpers, no gui tools or editors... just coding in pure spartan-programmers way. Are you ready to enjoy coding?

Employ a risk containment strategy, “how can I get the next micro-piece to MVP in the least time/energy/resources/money.” I enjoy that challenge, it gets a lot of my what I call “head crap” out of the way, and reveals new ways to approach problems. I call that fun. Constructively I’ll say it appears you may have some “head crap” in play. I say that because your stated goals of the perfect app, with fun, and simplicity are totally at odds. Risk containment, you might choose to flesh out your idea as it is. If it flies and starts making cash, then tackle more platforms. Rewrite from the ground up in a different language/framework if necessary AFTER getting traction and money. Because making the money is the real fun.

>If I could write an app in a good static-compiled language that did not require extraneous expertise in CSS but that shipped on a web page and looked good using tools only in that language, with good interop with an HTML Canvas, that would be one possibility, but it is again a compromise -- no easy multithreading, dealing with all the front-end baggage to bundle or deploy such an app, etc.

Rust/Yew may be what you're looking for. It takes all the good ideas of web UIs (namely declarative FRP) and works cross platform natively, as well as compiling to WASM for the browser.

https://yew.rs/docs/concepts/function-components

I feel like there aren't really any good options in software development any more. It's always one big compromise with lots of possible decision fatigue. Every direction has drawbacks.

This has, literally always, been the case. You need to pick where you want to compromise, because there is no "one-fits-all" solution.

- Use Electron/Typescript/React/Tailwind or some similar stack if you want to pull together something quickly that works across multiple platforms

- Use Flutter if you want to do that but don't mind it's kinda poor re-implementation of platform-native widgets

- Use Qt if you don't mind the C++ dialect and complexity

- Keep it simple and use Dear Imgui

- Use something like Blazor to build a web app in C#

There are loads of options with different tradeoffs.

I'm on the same boat since months...

I created a little SaaS product with some HTML, VueJS 3 and Laravel for fun. No code reviews needed here. Also not my daily stack. Was quit funny ;). I have to mention I don't like JS very much and I was never a Frontend guy, but I gave VueJS a try. And I think somehow I finally found something to build nice Webpages without digging into React or using jQuery for now.

It was great relief and somehow I became a little aware that programming in the corporate world is relatively often just no fun. No idea what I'm doing with the knowledge currently. Cheer up and try to do some sports. I know, an often used advice, but it helps.

At work I program mostly in Python. But if it's for fun, I strongly recommend Pharo. It's a language in the Smalltalk family, forked from Squeak: https://pharo.org/

The whole environment makes the programming experience much better, and it's self-contained, so you don't need to spend a lot of time wrangling dependencies just to get started. Also there's a MOOC for it: https://mooc.pharo.org/

You can also use golang + go:embed to ship the assets that are e.g. needed for a webview.

This way you can start very easy and learn about the cross-platform UIs later (if you by then still stick to the commitment to the project).

Learned golang last year, decided to refactor many projects in it. It makes cross-platform development a lot easier, except for native UIs (as of now). But fyne and others are getting there very quickly.

The core strength of golang is its build toolchain, with cross-compilation from Linux to anywhere, basically. Additionally it makes you "think in structs" due to how the language is designed, so serialization/deserialization can be pain at first but once you realize the benefits of un/marshalling, it's amazing.

The batteries-included approach of the golang core libraries + golang.org/x is a nice dev experience, there's all kinds of libraries in there that you could ever need, already available in pure golang (with zero C dependencies, so CGO_ENABLED=0 makes it as cross platform as it can get).

Have you ever programmed a video game? It is a nice experience. And weird, if you are used to apps.

> I'm not a fan of the complexity

That is a very frequent trap many devs fall into when doing a video game. You start with the intention of programming a video game and you end up spending all your energy building a video game engine first. Resist that with all your might. I recommend trying to make a little game that "works" from the start, and then doing small improvements gradually while making sure that what you have is still a "working game". If you spend more than an hour with your game in a non-runnable state, revert to the previous commit and reassess.

Second problem complexity-wise is ... just incidental complexity. In general, 3D games are one order of magnitude more complex to do than 2d games, so I would recommend the later.

You could try doing something in PICO-8 [1]. It's a game dev environment with artificial limitations. Like the number of colors (16), the screen resolution (128x128) and others. It's programmed in a dialect of Lua, which is in itself a very tiny language. It is possible to make something overly complex with those limitations, but you have to try really hard. And it is fun.

[1] https://www.lexaloffle.com/pico-8.php

Everyone is different, I suppose, so ymmv.

I went back to coding stupid small games in a scheme-like Lisp on 8 and 16 bit cause.

I started out with Lisp in the 70s but followed the money to C, C++, Java and DotNet with side-trips into Smalltalk and Self. And a metric tonne of x86 16 bit assembly.

But I always had a fondness for Lisp and FORTH.

One thing I remember from the old days was (as Sussman pointed out) we used to build larger programs by composing smaller programs. Now we use monolithic blobs where you spend a lot of time writing tests to see how the API works because there's very little documentation (and it's a black box where a LOT of functionality is hidden behind a single API instead of smaller components you combine how you see fit. Look at any Microsoft Crypto API for an example.)

So my fun is now had on personal projects.

I have moved some professional projects over to Erlang and Elixr. Others use closure, and I get a similar feel. I feel like I'm in control. JavaScript used to give me that feeling, but my management chain insists we do things like import packages to test whether an object is null (and it turns out it does the comparison wrong.)

Your sense of "fun" will no doubt be different, but I guess my point is... the freedom to choose your development environment can provide a bit of happiness to your life. Not just what you work on.

If frontend stuff is fatiguing just use Bootstrap. You barely have to touch CSS with it (beyond using its classes on elements) and it is extremely polished and capable. Sure the stock output is a little corporate and bland but who cares, just get stuff done with it and worry about making it look unique later.

edit: Material design is another good frontend option that lets you stop worrying about fiddling with design and CSS. There isn't as nice of a single framework for it like bootstrap though.

Have you thought about learning new technologies? Maybe if you vary your tech stack, you would feel more motivated :) I recommend this article, if you're interested in Blockchain: https://www.ratherlabs.com/post/the-roadmap-to-become-a-bloc...

Let me know if it was useful for you! Good luck with everything!

> where I am not facing loads of incidental complexity

This is my dream. Unfortunately there is no easy path to get there. We have to replace all the languages. Build replacements without the noise.

> looked good using tools only in that language

I think you can have a universal syntax, but not a universal language. I think Racket's term "Language Oriented Programming" is the holy grail. You need lots of DSLs because you almost always work across different domains.

It is possible to have a universal syntax, however ;)

I am currently writing a small app for my partner. I asked friends what should I use. Decided on react native. It is literaly a slideshow of a praticular pdf (rules for a new dog-sport), just as dedicated app. It is maybe 100 lines. Maybe I will add some anki-like functionality if I feel like it. It was fun.

The crucial thing was, speed of feedback-loop? And the expo stuff is good. It does the bundling, it has hot reload. I don't mind typescript and the embedded xml.

Generally when this happens it is because of context. You are clearly setting out to have fun and searching for the joy you did find originally. Most of the time this context is either the problem space, team/political issues or the random tooling in the ecosystem that complicates a solution for better or worse.

I'd say your best bet is find something cool you would like to build. Ideally, there will be some part you have to deeply focus on a tech problem that will require you to stop thinking about anything else and really immerse yourself. This would count even if it is only a few hours.

I've found it fun and useful to have a small list of tools/utils or mini projects that I could use day to day or even something I could just randomly say I built. It is also usually the case that for tech people the most joy comes from the idea and early stages of creation and then finally shipping it. I'd say it would be best to have one or two small projects you can definitely wrap up instead of a massive one that becomes a drudge.

Also focus on truly how much power we have with computers. It is one of the only disciplines where the biggest and almost only limitation is what you can imagine and design.

Qt/QML? I have been doing cross-platform development with Qt for a few years now [1]. It does have a learning curve, but I do like the split of C++ logic and Qml for the UI. I can recommend the qml book [2].

[1] https://screen-play.app/

[2] https://www.qt.io/product/qt6/qml-book

Many seems to enjoy Elixer + Phoenix. https://www.phoenixframework.org/

Crystal is what you are looking for.

https://crystal-lang.org/

- Human friendly syntax

- Static compiled

- Type inference

- Incredible standard library

- Easy concurrency

- Incredible performance.

Sorry if this has been said elsewhere, but - Makepad! You should check out Makepad!

https://github.com/makepad/makepad

It's a Rust library for developing cross-platform apps. It's not 1.0 yet; there's still things to finish, but it's being actively developed (https://fosstodon.org/@rikarends#), and it's already pretty fun to play with. And the fact that it compiles and runs with the same widgets on Web as it does for Windows and Mac (Linux and Android are imminent, according to the dev's updates) makes it very appealing for my "write once, deploy anywhere" sensibilities.

Fast, easy, and free. Just waiting on it to be "live", for now! Don't forget to check out the demos.

https://makepad.nl/makepad/examples/fractal_zoom/src/index.h...

https://makepad.nl/makepad/examples/ironfish/src/index.html

https://makepad.nl/makepad/examples/simple/src/index.html

https://makepad.nl/makepad/examples/numbers/src/index.html

Modern OS's are to blame. If it's not your cup of tea but you still want to release on them I'd look into a framework, toolkit, or game engine.

I don't know what project you have in mind but what about targeting an older platform? If it's purely for fun/satisfaction try making an Amiga or DOS program. Plenty of emulators for modern platforms to help you run it on a Mac or Windows machine.

Depending on your project one route to consider is to build your UI with an immediate-mode style library (or write one yourself, it's not terribly difficult). You'd be sacrificing accessibility likely but it would get something out there fast that's pure code and doesn't require a ton of fiddling to get going.

Another "fun" area is to try Common Lisp or Emacs; both have options for UI and graphics programming and all usual facilities on modern systems. The benefit is that you can stay in warm-and-fuzzy parentheses and get a highly interactive development environment that you rarely have to leave.

How about Unity? https://unity.com/products/unity-platform

Or Racket? https://racket-lang.org/

---

I only have a little experience with the suggestions above; I personally like SvelteKit, but it doesn't fit your requirements.

Go with Flutter. If you want, you can use Riverpod + GoRouter.

You will need a week or two learning curve if you are really good at picking up things. After that, the noise will fade away. You will be able to fully focus on building stuff and have fun.

If you are trying to interact with native platform in very advanced way, the non-fun parts will be back for a bit. It is still better than others.

I write lots of small shell scripts and aliases (using bash. I have only one script in zsh that does some globbing that zsh is better at out of the box) to do various things, like managing my music collection (on top of what git-annex does), converting and remuxing files, generating files etc.

The other day I wrote a little shell script to make a command-line radio player, which was rewarding.

I have a little shell script I wrote that is now a cron job on my laptop (running Arch GNU/Linux) that backs up my important files to a cloud using borg. That little bit of automation (a few dozen lines really) has been nice and fun to write, and gives me some good peace of mind.

Admittedly, some of shell script syntax (like that for hash maps) get take some time getting used to and is rather arcane, but I find running little scripts to do various day-to-day things around my life and the house rather fun.

If you're looking for the type safety afforded by swift I recommend two languages:

Elm and elm-ui for the front end. Elm is so safe that with the exception of the FFI and OOM it cannot have runtime errors.

Rust for the backend. You already know C++ so borrowing (move semantics) references and whatnot should be pretty familiar. Rust is like C++ but without all the horrible baggage and swift esque type safety.

Other people are like build stuff with this! Build stuff with that! They don't get it. I know what you're looking for: type safety in a good language without the garbage. Look into the two things above^^^^

Anyway the thing that's sort of related here is functional programming. Swift and Rust both share the same creator and the type systems from both are derived from Functional programming languages like haskell and OCaml. Elm derives its syntax from the same family, but elm is strictly functional while rust is not.

From the way you write, I get the impression that the project idea you have in mind isn't fun for you to implement.

If dealing with "front-end baggage" doesn't sound like fun to you, don't do a project that needs (much) front-end. Maybe you can build a bot (discord maybe?) instead? Or try some other interaction paradigm?

Or maybe abandon your project idea, and ask yourself what kind of project would be fun to implement, not fun to have finished implementing.

> I feel like there aren't really any good options in software development any more. It's always one big compromise with lots of possible decision fatigue. Every direction has drawbacks.

The beauty of a hobby project is that you can decide what's important for you. You can decide to screw portability, or accessibility, or security (as long as it's just on your device/home network), or whatever else feels like a burden to you.

I was looking for a tech stack like you describe and came up with this: https://github.com/hollingsworthd/micronaut-libgdx-teavm

It uses Java 17 and LibGdx for graphics, compiled to JS (Canvas) by TeaVM, and served by Micronaut.

I'm writing a book[1] with a variety of coding projects.

Programming is not always about building the app foo with the language bar. You can have fun by recreating and understanding how existing stuff works.

[1] https://build-your-own.org/b2a/

    I'm also attracted to implementing my app cross-platform.

    I just want to have some fun writing something without headaches

Building cross-platform native apps is like consuming the contents of a bottle labeled "CONCENTRATED HEADACHES". Those two goals are fairly incompatible...

I relate to this so much!

What I’ve been enjoying A TON lately is embedded development for hobby. Not Arduino, but bare metal, flipping registers and configuring devices in a STM32, writing linker scripts and scripting gdb.

It feels awesome to understand a system completely (sort of). I’m writing C but I also wrote the assembly that bootstraps my C environment and calls main()

That combined with some reverse engineering to figure out the MIDI protocol and a buzzer and LED and I’ve made a little instrument that I can play with my keyboard!

Next I’m planning to understand how USB works and maybe make the little instrument controllable over USB? Who knows!

I’ve realized that what I enjoy about programming is the puzzle, the thing that I don’t know, and then learning it, and then doing something fun with it.

Wish you the best and tons of fun in your journey!

Find out which sort of language features you find really cool that apply to your project. For example I have this idea in my head of writing ML stuff in Haskell, since everything is lazy and you could run models off disk. That would be really fun not only because of the end goal but because writing Haskell code is a borderline psychedelic experience. Using core language features tends to give you that feeling of using divine tools as opposed to writing a textbook in a second tongue.

Other than that I'd recommend C. It's ubiquitous and can be as simple as you want it to be. With macros or source to source transformation you can have your cake and eat it too by picking how you want your code to be written then figuring out how it would compile to C.

There is no purely fun way to build a production app. If there were everyone would do it. The hard part of building an app is the slog through the tedious parts. If you just want to build a toy app for fun, I recommend you just mess around with processing or pygame.

Best way I found to "have fun programming" is to not do it "for work"

That's personal experience, of course, but the most "fun" I have in almost any task/topic/field is when it's not 'forced' on me by $WORK

For me the fun of programming came back when I allowed myself to do things that are completely useless, apart from the fact that it brings me joy. It started with 6502 assembly programming for a breadboard computer I built. Right now I am programming C using old Borland tools on an old MS DOS computer. Again, super useless, but oh so fun.

And who knows, maybe this new knowledge will be useful professionally one day (I learned a lot about very low level computer concepts, and I didn’t know C before), but that is totally not the goal. Just the absence of the pressure to be useful brought back all the fun for me.

I remember I had the most fun when my code sucked. I made all sorts of silent tradeoffs because I didn't know that I was trading things off.

"Look! I built a whole App that does the thing! Isn't it cool? Oh, yea, you need to use this gnarly url and - crap - yea, use chrome. Refresh it... Hold on, let me restart the Raspberry Pi... Got it! Look at that! So cool! Wait - did someone HACK this?"

The grown up version of this might be just building for one platform, and one happy path. Who cares if lots of people can't use it? If it's popular, you can turn it into a job then. But until that happens - just make the computer do something cool!

Spend a while building a template for a Phaser game that has display and controls working nicely on mobile and in the main browser, package that up, and then start cranking out game prototypes. That’s what I do, minus the cross platform stuff since I don’t know or care much to do it for pet projects. The results have been fun as hell though. Examples:

https://explorerdude.net https://novagame.net https://choreomania.net

The premier cross-platform UI toolkits today are definitely:

- QT in C++

- Electron in JS/TS

But if you want to avoid those then you could try the Rust GUI ecosystem. That gives you a few options:

- gtk-rs which uses GTK but allows you to write in Rust rather than C

- Dioxus which does use CSS layout (renders using Tauri webview under the hood) but allows you to write the code generating that in Rust. And the "backend" code is entirely Rust.

- Iced which is pure Rust with it's layout system. But tbh it's still pretty immature and you'll be writing a lot of widgets yourself.

You could also look at Flutter which works cross-platform and works completely within Dart.

I am finding NextJS (React) + Tailwind + Typescript a great fun platform for side projects. Some investment in time is needed for each of those buzzwords, but once learnt and passed the painpoints and footguns its a cool way to develop fast web apps. But if you are not used to web there may be a few months to get proficient enough until it becomes enjoyable. And I think that is key for me: joy comes from proficiency with the tools and creating not from learning then tools themselves.

One thing that I like to do to keep motivate me building something is share how I do it. All comments, questions, and appreciation from the others keep motivate me working on something so I keep have a new knowledge to share.

People start build in public on Twitter. You might want to try it. Share your work, how you solve a problem, find a similar project that might be related with your work, have a discussion with the others to gain more ideas. I hope it help!. Good luck!

Come help us build a quantum physics game engine: https://github.com/quantumlib/unitary

I give remote math courses (GoStudent 4h per week). I also have a student in computer science. She sends me her lessons and I explain to her what she didn't understand. I help her to do her lab work. If a subject doesn't suit me, I tell her. The level on the theoretical courses is excellent. To explain something, you have to know the subject well. This allows me to progress on all subjects at a very fast pace without spending much time (it is in addition to my usual work).

> I don't mind challenging work, but I like an environment that feels sane and logical and where I am not facing loads of incidental complexity along the way.

> I'm not a fan of the complexity...

My recommendation that helps me having joy: Just do something other than writing code for that particular app. Write a decent (build scripts)|(CI/CD pipeline) that will abstract away that complexity and will reduce cognitive load of building/testing/deploying an app. That's a good feeling.

For any bored programmers here, I'd recommend donating some time towards open source projects. For some examples: Gnome, KDE, and Cosmic DE are all looking for contributors.

> I feel like there aren't really any good options in software development any more

Totally empathize. Why we ended up this way when "tech" has been eating the world for so long is another story...

One little corner that might be worth exploring is KDE apps based on QtQuick / Kirigami. You can leverage your C++ and deploy on android too.

https://develop.kde.org/frameworks/kirigami/

Top (currently) comment is, IMO, the most correct. Find a fun project, probably with Pi and/or Arduino.

Otherwise, my 2 cents is that I pretty much always have fun programming in Ruby.

> I like an environment that feels sane and logical and where I am not facing loads of incidental complexity along the way

You should try my (esoteric) programming language (theorem prover), Budge-TP :)

You might find useful my recent write-up about https://bor0.wordpress.com/2023/02/05/writing-your-third-pro...

The nuclear option is to transition to a job that isn't programming. Then let it rest a bit and most likely the itch to write some code will strike you, so go ahead and do it. Solve problems you care about the way you like. Treat it as a hobby again.

Of course, if your most marketable skill is programming, then that strategy will likely involve a reduction in compensation. Whether or not that trade-off is worth it is something only you can answer.

I found fun, recently, in helping out non-profit organizations or places that could use a programmer but just don't have one for whatever reason it might be. I am building a Digital Signage solution that can swap to a live seating availability chart for a performing arts theatre, I'm working with some local theatre groups on helping flesh out some cool custom QLab integrations, etc.

You can find some fun projects in places least expected.

Julia has agents.jl* with which you can do fun stuff like this: https://juliadynamics.github.io/AgentsExampleZoo.jl/dev/exam...

* https://github.com/JuliaDynamics/Agents.jl

Might be interesting.

My day job is boring to me but I build hardware projects on my own time. These I just code up/go at free will, no tedious testing or CI process.

If you want happiness and instant gratification try Ruby. https://www.ruby-lang.org/en/

If you want reliability, perpetuity and still some fun try Rust. https://www.rust-lang.org

Try using Jupyter Notebooks or another notebook based programming environment. Good way to change things up and very enjoyable to use :-)

"I just want to have fun programming again"

You can... just not as a professional. Work kills the joy. As only a hobby it could be fun again.

Not sure about the cross platform side but I am here to mention Elixir : I started learning some days ago and I am having a lot of fun so far doing exercises on the exercism learning platform.

My background is C and C++. I had tried fp before but it didn't stick. It gets awkward really quick. No such things with Elixir.

I'd recommend dropping your requirements to run on the web, and try out the fast, easy to use local GUI builder that is Lazarus/Free Pascal. It's cross platform, compiles to native code, and damned fast.

You build a form by dropping GUI elements into it, and hooking up events. It's almost trivial to build a CRUD application.

My two cents would be on F#.

Yes, isn't a mainstream language but there are a lot of interesting things with it:

- build for .NET or languages supported by Fable (JavaScript, Dart*, Python*, Rust*, PHP*) - I did build a proof of concept Flutter app with it

- multiparadigm - FP or OO, you choose

- clean syntax - based on indent just like Python

- Type providers, type inference, ...

* These are on Fable 4.0.0-theta-018 at moment

haskell, fp, ocaml, elixir/erlang, f#, racket, common lisp/scheme [for general enlightment] to broaden your horizons

monads, type-classes, pattern matching to get out of the imperative mindset from cpp, java,python, ruby

[to be clear avoid java, cpp,python, ruby]

c is needed for performance,

elixir/erlang for concurrency/parallelism,

haskell/racket/common lisp for enlightenment

I'm sensing that engineering compromises are what you'd call work, not fun? You may be asking for elegant cross platform tooling that may not exist because of the compromises it would require to hit a common denominator. I would pick my favorite platform and make something uncompromising using its strengths.

Last time I was in a serious rut I formatted my Thinkpad and setup an environment to fresh. Doing this alongside a small project was a good way to relearn some tricks and discover new workflows. Ultimately leaving me more proficient and happier.

I should probably work up the motivation to do that again come to think of it.

Find something wacky and fun project! I did this: https://github.com/curzel-it/pet-therapy Desktop pets for macOS, and having lots of fun.

Btw, I'm looking into porting it to Windows and Linux, if anyone is interested... :P

I wonder if you can pick your favorite language/framework and write a daemon that serves as the "backend". Then, write a UI in whatever you like, and send calls to the backend to modify state. It's the same concept as MVC, but implemented in different processes

If your true goal is to have fun while programming, why not just play a Zachtronics game (TIS-100 or Shenzhen I/O)? Same difficulty as programming a piece of software (if not more difficult), but no dealing with all of the complex annoyances of programming languages.

Maybe not a popular opinion, but after I bought a new MacBook, I decided to try out some iOS and Mac apps development. After years of frontend and backend development, it felt like fun thing to do. No more endless npm modules, css files, javascript quirks. Things just work.

Fun would be to build utilities for your own use that would actually enhance it. I can think of home type projects with embedded system that interfaces with HomeKit. It could be anything actually, maybe work with another person with similar needs on that fun project.

I've been building with Remix + Supabase with Chakra for my side projects. It feels great. I haven't open-sourced it yet, but I'd be happy to share it with you if you want to take a look.

There's no CSS. No useEffects. No BE vs FE. It's almost beautiful.

I’ve found that writing in Rust has re-ignited the spark of programming being fun for me again if you derive fun from writing some elegant and sexy code rather than finishing something per say, but that’s true of anything with coding

https://go-app.dev/ + https://github.com/ipfs/kubo

easily deploy wasm full-stack p2p apps

Seems like Haxe (https://haxe.org/) might be fun for you.

Per others, though, perhaps it's the motivation that's required. Do you want to write games?

> I'm also attracted to implementing my app cross-platform.

Depending on your project, you might consider working on the backend and API to drive this app and contract/partner with somebody who can do a killer job on a great frontend.

Qt?

https://www.qt.io/

For me its not the language its the tools. Writing code is getting easier but to deploy and monitor microservices on a cloud requires dozens(!?) of little tools, scripts, config files all different.

Do internet-of-things stuff on embedded devices. It's fun and you can run on bare metal or a minimal stack, but you don't have to compete with the entire internet on the same computer.

I've really been having fun with go compiled to wasm for the browser. Ebiten is a nice engine for pixel graphics/game stuff, but there are also more traditional canvas libraries.

Ruby on Rails is desperately waving hello. Though it's not x-platform...and I don't think the magical x-platform tool/framework you're looking for really exists.

You can achieve something useful and enjoyable at the same time if you don't set a goal too large.

Start with something you think is interesting and that you can do in an evening.

Do a little bit at a time.

Zig sounds logical to me if you already know C++.

It has grest WASM support, too.

Stuff like Bun.sh which is an entire JS platform is built upon Zig with a very small team. That speaks of Zig complexity.

Learn to love JavaScript. Then you'll always have fun building side projects.

Sounds snarky, but I'm serious. You can build anything with it, and it can be fun to use too.

In programming, the sky is literally limitless. But you have to find it within yourself to find what's "fun".

No one could possibly suggest "fun" to you.

Ok so basically how we have fun nowadays is

1) write some random control plane 2) create yaml interface for that control plane 3) watch how your users lose will to live

That is fun by definition

For me personally it helps to build something directly with my customers. Wow them with my solution, think of better ways to solve their problems.

For me personally it helps to build something directly with my customers. Wow them with my solution, think of better ways to solve their problems.

Honestly - if you like UIKit and Swift then build in that. Better to make progress and exercise the idea than hem and haw about the perfect tool.

Stop doing it professionally.

Try a project that's either completely useless or at least wildly impractical. Don't be afraid to throw away code.

Note down the good things you find in programming languages, and build your own language writing its compiler. That will be a good exercise.

F# via Fable or Webassembly. Rust via webassembly.

Write something for yourself. When you're the user, the motivation to continue working on it is much stronger.

Languages aren’t worse, you’re just better than you were. You’re aware of all the warts that you didn’t know before.

Try Flutter, it lets you build multi-platform apps without any HTML/JS/CSS and Dart is a pretty nice language

For fun use something you already know. Download needed stuff and offline documentation, then cut the Internet cable.

https://github.com/iced-rs/iced

Sonic Pi - code-based music creation and performance tool is quite fun. Gentoo is fun, Funtoo is fun too.

Nothing in life worth doing is easy.

Make apps--however you want regardless of current trends--that you will use and find useful.

You might be interested in a role change where you are coding less

I love browser add-ons and p5.js for artistic stuff.

Zig looks logical, It has amszong WASM support.

try doing GPU shaders, I have seen you could get decent ROI on effort.

you can try out your own shaders in a browser here: www.shadertoy.com

If something ceases to be fun, automate it.

Pico8

Check out Flutter?

Fun? C++? Bruh.

Well, I'm going to chime in with Java and JavaFX. Yes, its still used. Yes, its still active. Yes, its still updated.

Java is Java. A nice aspect of Java is that you can find pretty much anything in Java. Not written in something else and integrated with Java. Written IN Java. That helps limit the long running impact of "dependency hell". Of course you'll have dependencies, but in the end you have a static distribution, and its the same code, across the platforms. I'm currently working with Apache Jena and RDF (and this has nothing to do with the semantic web). For my purposes, RDF is a hoot, and adding Jena to my project was drag and drop.

There are exceptions. JavaFX is one in itself, as it does have a platform dependent binary component. If you're lazy on tooling (I'm lazy, I hate tooling, I should say I hate fiddling with tooling), just bundle all the platforms everywhere. But you can also make platform specific builds. In the end though, you don't have any environmental dependencies. All of them are brought with you. You can static link lots of things, but in Java, its routine.

Java is evolving into a multi-paradigm language. Still dominantly OOP, but it has the low hanging fruit of others as well. All of it is imperfect, but it's pragmatic as all get out.

JavaFX is a pretty solid piece of kit. It's modern, it's STILL modern. As old as it is, its held up really well. It's different, it's not Swing by any measure. My hurdles picking it up was taking preconceived notions learned from older frameworks and trying to square peg round hole them into FX. FX is opinionated enough to make that kind of effort frustrating.

But it comes with a scene graph. It comes with CSS. It comes with animation. It comes with 3D. It even has boolean 2D geometry operations. It comes with a bevy of layout containers. It has GUI screen builder. It has FXML, which is an XML based format for specifying scene graphs. With a bit of boiler plate, you can actually do entire screens and logic in an FXML file with embedded JavaScript, if you're so inclined. Perhaps not the greatest idea, but for certain applications the idea of being able to have an end user add a screen to your application can be very interesting.

I really like the Property and Binding mechanic. It's one of those things that's compelling and can lead to abuse and trouble. But that's OK. Just dial it back and it sings. It can also be used for simple rules, or as a simple constraint system.

Make no mistake, there will be battles. But for me, someone who hates Fiddly. Who tolerates tooling. Having everything underneath the one overarching canopy of the JDK is useful. But, it's still Java. Java can be wordy, to be sure. This doesn't bother me so much. Even my Common Lisp is wordy. CLOS isn't a poster child of terse coding. You still have your setters/getters (that can be sort of mitigated with the lombok project, but it doesn't have support for the JavaFX property idioms).

I do have one complaint about FX. The components and such are pretty locked down. It's really hard to extend them in ways they're not designed to be extended. Which means if something you're working with won't work for you, its baby out with the bathwater.

I've been playing with it all year. I have several half baked projects floating about. It's all been mostly fun for me. Desktop GUI work has a lot of minutia, which I've never been very good at. It's also a GUI, which is about presentation, and make this blue, and that 3 pts bigger and line all this up and can we have a shadow here. Most of which I hate. But that's an inner conflict unrelated to the environment. That's just GUIs and bike shedding. I've suffered this since they offered color to smart terminals.

GUIs also have a bunch of things that have nothing to do with your application per se. Global state, where do you put the logs, preferences (dare I mention Java has a cross platform preferences API built in?), perhaps capturing window layout on close, etc. I wish I could point to simple framework that supplies all that, but I can't. They exist, they're not simple, they come with a lot of baggage. That may or may not be "fun" for you.

You're over thinking minor stuff