Yes, it would always be possible to acquire a commercial license if any of the open source licenses are unsuitable.

I'm thinking about changing the license with the 1.0 release. My current consideration is the LGPLv3 and I was wondering if this would help anyone, but also if this would be a problem for anyone?

Wow, that's aweseome! Thanks for working on this! I'll check it out!

Interesting project! I like the themes 🙂. Side note, though: Why are there only ZIP files of the source checked into the Git repo?

On topic: ObjFW should be a perfect fit for this, given that it supports a large range of very different OSes already, some of them having what can barely qualify as an excuse for a libc 😉. As well as running on embedded.

To get started, I would recommend to run configure with something like this:

./configure --host=x86_64-pc-unknown-elf --disable-shared --disable-threads --disable-sockets --disable-files

(Replace --host=x86_64-pc-unknown-elf with whatever triple your cross-compiler uses)

This should give you an ObjFW that requires no functionality from the OS and only a somewhat working libc for memory allocation etc. If you run into any problems with basically all features disabled, please provide compilation logs / describe errors, and I can see to make ObjFW not use what you are currently missing. It's possible that it currently requires something that all platforms happened to have in common by pure chance, though I think that's quite unlikely.

The next step then is probably that you want files, as those also give you the standard input and outputs. ObjFW currently assumes that there is open(), read(), write() and close() for this, though if it's helpful, I could also let it fall back to fopen(), fread(), fwrite() and fclose(). But so far, I have not found a system that only has the f* variant, despite the f* ones being C99 and the ones without f only being POSIX.

I suppose sockets aren't supported by your OS, so that probably should be kept disabled. Threads either use an OS-specific API or, if it does not know about an OS-specific API, checks if the OS supports pthreads. Shared library support just requires your OS to support, well, shared libraries (it assumes you are on ELF and use .so files if it does not know the OS).

For option 1 - 4, there needs to be a decision between Gtk and Qt. Here's some thought I have, but nothing is set in stone:

Pros for Gtk:

• gobject's object model is inspired by Objective-C, so pretty compatible
• Gtk apps look good on GNOME and KDE (KDE can make it look like a native app), it looks OK on Windows
• Gtk is written in pure C, so we would not need to make sure that our headers contain no C++ (even transitivly)
• There is gobject-introspection that should make it easier to create bindings

Cons for Gtk:

• It looks meh on Mac, but is still fully functional

Pros for Qt:

• It looks good on Windows, KDE, Mac

Cons for Qt:

• It is written in C++ and special care needs to be taken that the GUI framework does not end up with headers that need C++. That means redefining every enum as a C enum and wrapping absolutely every class. It also means often using void pointers and lose type safety.
• It uses multiple inheritance which does not work with the Objective-C object model, so this needs to be hacked around.
• Qt apps still look alien under GNOME, despite some attempts to make that better.

Open questions for Qt:

• Is there something like gobject-introspection that can make it easier to create bindings? Anything else I forgot?

No worries about limited experience / knowledge. I'm personally happy to help. I’m happy to teach and delegate - this is a project for multiple people after all, so any time invested to get someone up to speed will be well worth it in the long run.

On the chat, there is currently a preference for option 4 (the hybrid). I guess it makes sense, as it allows you to have a nice API and also break out of it if something is missing and hence might result in something usable quicker. But nothing is decided yet and you are the first one to commit to joining the effort 🙂. Let’s keep the discussion going and hope that more people are interested to help!

tl;dr: ObjFW needs a GUI framework, there were several attempts in the past that failed, so we need to join forces. Please help, every little bit counts.

One of the things that always comes up over all these years is a GUI framework for ObjFW. There have been several attempts, usually done by a single person, that then quickly died down because the work is overwhelming. This leaves us with the current situation that there is no ready-to-use GUI framework for ObjFW, despite it being one of the most requested things and the lack of a GUI framework probably being what holds back ObjFW adoption the most. It isn't beneficial to have so many projects for a GUI framework (see below) that all ultimately fail - instead, I want us to join forces, and come to a decision which option is the best one to move forward. Please comment on this thread which option you prefer and why, and whether you would be willing to help. Every little bit counts, so even if you think you will only contribute very little, please volunteer and reply here!

Options

There are several approaches:

1. Write bindings for an existing GUI toolkit such as Gtk or Qt, mostly following the original API with slight adaptions for ObjC
2. Write a binding generator for an existing GUI tookit such as Gtk or Qt
3. Create a new API as wrappers for an existing GUI toolkit, so that it feels more like ObjC
4. A hybrid of 1/2 and 3
5. Create an entirely new GUI toolkit

Option 1

Option 1 is probably what has been attempted the most: There is adenosine with it's underlying atropine. There was GTKKit (it seems to have disappeared from GitHub, but luckily I forked it and that is still around). And there still is my own ObjQt. So there have been 3 attempts and none really got that far. Another problem they all share is that they currently need an extra thread or they block ObjFW's run loop. But that can be worked around by swizzling ObjFW's OFRunLoop to use the GUI toolkit's run loop.

Option 2

What all the attempts of option 1 have in common is that they were manually written bindings. I think this is what ultimately made them fail: The amount of work to create bindings manually is overwhelming and the toolkits grow at a faster pace than a single person can keep up with. Which brings us to option 2: Write a generator for an existing GUI toolkit. Gtk has gobject-introspection, Qt has something similar. There were brief looks into gobject-introspection, but that never went far. While it seems like a downside would be that this would have less adaptions for ObjC than option 1, this could be addressed by having tables that e.g. contain renames, manual overrides for certain methods/classes, etc.

Option 3

The downside of both of option 1 and 2 is that an existing GUI toolkit is not written around the dynamic nature of ObjC. Which brings us to option 3: Create a new, ObjC-native API, then implement it using one of the existing toolkits. The downside compared to option 1 and 2 is that it is a lot of work, and an additional downside to option 2 is that you can only use what has already been created and don't get a full GUI framework at once. This has been tried in ObjGUI, but I didn't do much on it.

Option 4

Which brings us to option 4, which is trying to get the best of both worlds: Follow option 1 or 2 to have bindings very close to the original toolkit, then write a wrapper that makes it more native (option 3) using the bindings from option 1 or 2. This allows breaking out of that more native wrapper to do things which aren't in the wrapper yet. As far as I know, this hasn't been tried yet.

Option 5

And finally, we have option 5, which is to create an entirely new GUI toolkit. The advantage is that you do not have to think about how to make an existing GUI toolkit play nice with ObjFW and that it is the most interesting option, as it allows you to create something new from scratch entirely instead of just creating a "boring" wrapper. Another advantage is of course that it could have very few dependencies, so that you can statically link it into your binary and get a single self-contained binary. And of course it will be more lightweight than both Gtk or Qt, so your static binary will not end up being gigantic. I did start this at some point (back then using Allegro as I did not want to create my own backend for every OS and since SDL2 was not a thing yet, and SDL1 can only handle one window), but never released anything. The huge disadvantage is of course that it will take time until you have all the things you need for an app and that it probably will not look native anywhere. I think this is more interesting for writing small utlility apps that you want to distribute easily rather than for apps that you want to use daily.

Next steps

So, first of all, since we already established that this is too much work for a single person, we need people who are interested in making a GUI framework for ObjFW a reality. So I would say that very first step would just be people shouting in this thread "Here, I'm interested!". Even if you can only contribute very little, please shout - every tiny bit helps! Once we have a group of interested people, we can discuss which of the options to pick and go from there, hopefully joining forces in the end fo make a single GUI framework succeed instead of having many single person projects that fail. And please feel free to hop into the chat at any time to discuss as well.