I didn’t bother reading the other answers, but few things I can say:

• netbeans is crap, intellij is much better
• if you go with python, please do bundle the runtime and do not use the system one. No one will if your software is 5mb bigger, but they will care if they need to manually create the python environment (if they have both the patience and knowledge to do so, the intersection of which is rather small I reckon)
• if you go with Qt, use QtCreator, the integration is great. Please do not use visual studio (especially if you’re going to use qt). It’s slow, expensive, unstable, dumb, slow, both too complex yet missing trivial features, and slow.

Umm… Keep in mind that I lack experience. Take the following with grain is salt.

I understand your pain with Swing. Not sure how to help other than change to another GUI framework. I think maybe eclipse does thins thing where it allowed me to make code GUI changes. Maybe?

Change GUI framework?

Consider doing a web base where the server does the folder structure?

I know nothing about Dart.

Finally, super personal opinion, but go with C++ and wxWidgets. I love this library.

I’m familiar and usually working with .NET, and am a strong advocate for it.

• The language is similar to Java, so not that difficult of a switch language-wise. Visual Studio makes good suggestions introducing you to newer and more concise syntax too. If you install the VS SonarLint extension it’ll guide you to good practices.
• Excluding the GUI for now; you can target cross-platform.
• GUI is somewhat of a mess like anywhere else, but you have decent options and you certainly have more viable alternatives compared to other languages. If your target is cross platform, check out MAUI for the recommended/officially suggested approach. I find the XML GUI coding irritating and inconvenient, but it is well-established and popular. Although I haven’t implemented a noteworthy project with it, I prefer coding UI in web tech, so I like that you can embed a WebView2 and connect and bind between the C# code and the HTML rendering. Using WebView2 for program GUI requires a container app window. Targeting Web/Browser-rendering directly is viable too with Blazor and more broadly ASP.NET with multiple alternatives and openness to web frontend UI frameworks and libs.
• With one project structure the project can be worked with with dotnet CLI (leaving users open to use their own IDE or text editor choice), Visual Studio, or Visual Studio Code. NuGet packages as dependencies are automatically handled within the default build toolchain.
• .NET is well-established and popular.
• Official documentation is great. It is exhaustive, with guidance, references, examples, and tutorials. It is open to feedback and change requests/suggestions.

As for what you tried, how I would personally react to a project:

I don’t like python. For anything that is not a script, I would likely skip considering contributing. It is an overall popular language though. Prevalent as a language, and at least reasonably popular / niche-popular for apps with UI.

C++ is a mess to set up and manage. Qt is huge. It’s popular and powerful. But in the aspect of low-barrier, it is the opposite.

Thanks a lot for the suggestions!

I’ll be trying at least some of the options that were brought up and see what works for my project, I’m still open to feedback, but I’ll report back and mark the thread as solved once I find a solution.

Have you tried Qt but with QMake instead of CMake?

Use Qt Creator instead of Visual Studio.

It is much much easier to manage the project with QMake in my personal opinion, and Qt Creator blends beautifully with the Qt Framework with the kit manager, and the form designer, qmake/cmake integration…

Qt (Framework) manages so much behind the scenes that cross platform is trivial.

Also

I’ve exhausted every EXE-generating option I could find [for python]

Unfortunately software is one giant mess right now. You’d think things like compiling to an EXE for python would be standard. They’re not. One day, maybe 15 years from now, we will have Nix be user friendly, a single line installer for everything, and have it all “just work”. But until then, almost everything is hacked together.

Overview of (basically) all GUI systems

I believe Flutter and android studio are the only major ones I don’t have experience with.

• Yes as far as I know theres no good exe maker for python. Python without dependencies (or async) is great, a nice little scripting lang for prototyping or data analysis. Python with dependencies is terrible, truely awful for packaged user-applications.
• C++ / C are and effectively will always be miserable IMO. You’ll basically never be able to automate it without nix. Make, cmake, autoconf, pkg-tools, ant, etc they’re all a mess. For example, biggest blocker to python packaging is that many python packages are wrappers around C/C++ packages. The most annoying thing about one of the tools I’m about to mention (electron) are the dependencies that secretely use C++.
• The most modern, consistent, and cross platform graphical systems right now are Electron and Tauri, which are literally browsers with URL bar/buttons removed. Electron is what Discord, Spotify, and VS Code use. Its bulky but theres a lot of support/tutorials. Tauri is the new, faster/cleaner kid on the block and uses the Rust language, which has good dependency management. But Tauri doesn’t have the tutorials or ecosystem yet. Also Rust is a very hard language. For both you’ll need to learn Javascript/HTML/CSS, which is probably good. But you’ll also need the terrible npm ecosystem, and get introduced to javascript frameworks which seem great until theyre not. That said, basically every cross platform not-browser GUI I know of (JavaFX, QT, TCL/TK, WxWidgets, FLTK) has exactly the miserable experience you’re getting; lots of dependency hedaches, and weird graphical differences between operating systems. Also that list is in order, with FLTK being untouchable garbage, and JavaFX being the least-bad in my experience.
• Even if you’re okay with using a broswer, (which solves lots of dependency/setup problems, and is the most useful/flexible UI system I’ve used) it still has stupid API problems because HTML was originally made to display documents (like microsoft word documents). It wasn’t meant to be a full blown UI system; it just became that over time. Stuff like styles and positioning in HTML has edgecases, like “fixed” meaning absolute and “absolute” actually meanting “relative to parent” and “relative” meaning “relative to where the element would normally be”.
• Unity game dev (uses C#, which is similar to Java, but better IMO) might actually be worth looking into for your case. First check the unity API’s for your images and GPS tasks. The good news is they support packaging up applications for every OS. The bad news is you can’t automate the setup because its proprietary. The (very good) open source alternative is Godot.
• The final alternative is, just don’t go cross platform. This is the only not-mess, not hacky, intentionally-designed toolset approach I know of. MacOS has Swift and XCode, Microsoft has Visual Studio and C#. Neither are great but they’re both the “this is how we expect you to do it” approches. You might be able to adapt these to other platforms (swift has been gaining some cross platform support and the .net runtime for C# can be cross platform).

My perfect setup would be Tauri (with all security disabled), with Deno accessible on the front end, all installed/setup by Nix. But alas, that doesnt exist yet. Even with +3 years of nix experience I can’t even get Tauri running in Nix.

I’d like directions on how to set up a software project with dependencies, so that future contributors can pitch in with the least amount of set-up required when they clone the repo

Unforunately that kind of task, with our current tools, is not a junior level task. I have worked on automating project setups for almost a decade; creating a single command that is cross platform install of all dependencies, project ENV setup, and in a way that doesn’t break the users existing system(s), or causes the project to bitrot. The only real way at the moment is through Nix (nixpkgs), which is unfortunate because Nix is very difficult to setup and use. If you start a small project in nix its not too bad, but adapting an existing project often is, especially anything with graphical tooling.

I made Deno gulliotine to help with first step of cross-platform setup, but once the setup begins to install packages/languages it all needs to be done with nix to be reliable.

Also FLTK is miserable. I’m not a huge fan of QT, but it is at least definitively better than FLTK. Wx Python is also miserable, avoid it like the plague.

There’s a few different things, I think, that are wrapped up in this.

• Generated UI code is unmaintainable
• Finding (and using) a good cross-platform UI library is hard
• Setting up a new project and packaging for it is hard

To start with the first, yes, generated code can be useful to quickly get something started. After that, in general you’ll need to adapt it and grow it be coding from there on. Round-trip (going back to the design tool from code) tends to not work that well.

There’s good UI libraries, but cross platform tends to be difficult. Oddly enough, a lot more work has been done to create good cross-platform UI on mobile than for desktop. Interestingly enough, flutter seems to also be bridging that towards desktop. Another ecosystem, another language (dart), but much clearer about how you should build, and plenty of documentation on easily building, from code, user interfaces.

Taking a small step back, I’d like to say that one thing you might want to start with is to look at your current code and try to restructure it in such a way that you separate the core of the functionality from the user interface. This can be a tricky process, and reading up on refactoring techniques is going to be useful. It might also really help in this process of potentially moving to a different language, because it will be so much clearer what you are moving, and what is incidental and just related to the framework you are working in.

Usually, unless there’s a specific reason to rewrite a project in another language (like performance, maintainability requirements, skillsets of available developers, dead ecosystem, etc) I wouldn’t do it. Java is perfectly suited for your goal of “least amount of setup required for future contributors” and many contributors will know Java well.

In general, it is much much easier to make existing code readable than to create new code already readable while maintaining the same feature set. So if you have a problem with FLTK, I would just switch to another GUI library. In the process of changing your code, you’ll actually start to understand how to separate layers of concern. Because theoretically, if your code were set up properly, it should be relatively easy to replace GUI libraries. It is likely not set up properly with lots of interdependency between UI concerns and application logic.

Netbeans is also a pretty terrible IDE imo. With an open source project, you can apply for the open source license of intelliJ, which is the gold standard.

That being said. If you really don’t want to use Java anymore just to learn something new, I would suggest a JVM language that can even use Java dependencies, like Kotlin or Clojure. Especially Clojure will teach you a lot of new things that will make you more productive as a programmer. However, every language will come with tooling-related quirks, it will be impossible for you to find a language that doesn’t have any problems at all like you describe. Why do you think there are so many languages in the first place? Because people didn’t like something about the other ones, often also tooling related.

That seems like an interesting project. I’ll probably take a look at the repository later.

Your question is about code packaging and tooling and that’s a messy topic in for any environment. It’s not my area but tbh these days, there’s a tendency to just throw up your hands and wrap the entire app and tooling as a Docker container.

Can I ask what platform(s) you are targeting? Linux? Windows? Mac? Mobile?

I saw a very wise remark a while back, that a lot of making code stability amounts to minimizing the depth of the dependency tree. Unfortunately, ecosystem maintaners have not yet taken this to heart.

GUI code is inherently messy but after you’ve done a few of them, some patterns do emerge. I think it’s an especially bad situation with Java but I don’t use that.

First off, cause you are programming under windows, a lot of things will be harder for you. As seen on your problems with Python.
Most Linux installs have it right from the get-go and everything else is as simple. So giving directions for developers on other platforms might be much easier than what you had to go through. (Maybe use WSL?)

Let’s get to your real question: How does one organize dependencies in a way easy for new contributors?
Since you will use Python, I will use that as example.

Most languages have a way to automagically import dependencies. Python has the requirements.txt file. Installing dependencies is then really easy. It is also a widely known way to do that, has lots of explanation online etc. so seasoned pythoneers will know what to do and younglings will get to know a good standard right away.

Bonus tip: If you don’t have a GUI library yet, maybe also search for game engines. They provide all the necessary tools as well, oftentimes have good GUI add-ins and are (mostly) for all mayor platforms.

NetBeans??? In 2024??? Intellij has a free community version which I’d recommend over literally anything else for JVM langs.

If you really do wanna swap languages (tbh I’d recommend you just stick with Java) of those choices C++ is probably the best one? Python definitely isn’t a good choice for what you want. I haven’t used dart but I’m pretty familiar with Java, Python and C++. C++ build systems are frankly very pooie. Cmake is hard to get into because it’s purpose is to generate make files which are essentially files which store a bunch of commands to run in the terminal. You can have Cmake generate stuff for ninja (recommend) but it’s still just kind of a mess. Since you want to support cross platform C++ might be a huge pain.

You could use a different JVM lang like Kotlin. If you want a compiled language you could maybe do Zig? I’m not very familiar with it outside of knowing the tool chain is much better than C++ or C. I’ll toss in the obligatory Rust mention but you’ll need to dedicate quite a lot of time and effort before you’ll be proficient. The tool chain however is fantastic.

Kinda long rambly response hopefully it’ll be helpful somehow