Ok ok I've changed the title so people will quit bickering over the fact that I couldn't think of a better word than "compilers".
But I suppose the real interest here is in figuring out which development platforms to support, by providing ready-made project files for the IDEs, makefiles, etc.
If that's the case, I suggest going for CMake, since it can generate Makefile-like files for pretty much any of the platforms mentioned here, and all the IDEs mentioned here can import a Makefile-like file to generate a project.
In any case, handing out ready-made project files for IDEs may not be a good idea because it's a lot of work (maintaining several platforms instead of just one) and you can never figure out the details of each person's configuration (include directives with the right directories, executable names, etc), so it's better to just let the IDE generate the project from a Makefile and be done with it.
You've hit the nail on the head.
I personally don't like the typical OSS-mindset of "here's some software, it's your job to figure it out". It is always a pain the first time you run into a new project and have to track down dependencies, figure out the configuration, fix the obligatory errors and set everything up the one way the development team intended to work. I want to attract users, not push them away, so I do my best to make the code as simple to get up and running as possible, even if that means more work for me just for less work for the users.
But it's become a bit annoying lately with the growing amount of tools that require exact lists of files instead of just "src/*.*". People tell me "oh it's ugly to specify your source files like that", you know what's uglier? Having your file structure redundantly repeated over a whole bunch of extra files that we have to edit everytime we need to add/remove stuff because it's the "proper" way. It's a fact, the more steps you add to a software's maintenance, the less encouraged you are to maintain it. And we don't wanna be discouraged.
So now that we have things like CMake, my plan was to just drop the least-used projects and let people generate them themselves (plus there'll be a wiki where everyone can share their own howtos soon). The reason I don't completely
drop everything but CMake is because:
1. It's an extra step whenever we just need to add/remove files. Close everything, edit the CMake, regenerate everything, restore all our little project tweaks and get everything back on track.
2. It's not something I'm too familiar with configuring myself, and I don't wanna have to rely on third-parties to keep my code up and running.
3. Invariably, some people just don't like CMake.