Here's one more vote for QtCreator + CMake.

I've been using it on my project and it's pretty nice, and easy to learn too. I actually had problems using Qmake (.pro) files, and have had no problems whatsoever since the switch to CMake. It also makes it pretty easy to divide your project into submodules/libraries that it will almost automatically link to your final binary.

Using CMake has lots of advantages too, like:

• generate project files for major IDEs
• configure system to enable/disable features at build time
• easy to configure the builds for each OS
• lots of documentation online
• really fast
• detects modified files and only recompiles what's needed

And probably a lot more I can't remember right now.

I just wanna make sure from the get go that my IDE won't leave me hanging somewhere later close to release. I narrowed it down to these three because they all had relatively good things said about them and each seems pretty close to having a working version of Clang ready for them which seems invaluable for the debugging process. Is there something I'm missing, or should I just suck it up and straight up use vim with the normal GCC compiler and just do everything by hand because I'm so paranoid XD

What's this about "sucking it up and using vim and gcc"? It's one of the best text editors around, and you aren't tied to any particular compiler with it either.

I'm a long time vim user for general text editing, but have never taken the time to properly set it up for C++ development because I have been essentially forced to use VS and other IDEs at work. This thread finally kicked me to action. So I spent a few hours trying out a bunch of plugins, booting out ones I didn't like, and wrote my configuration from scratch. The result is that I have the clang_complete plugin automatically running clang in the background, offering namespace and object member name completions as I type, and popping up syntax error highlighting with error and warning messages. ("Pretty close" for some other IDEs? Here today for vim.) I can jump to definitions with vim's built in tag support and ctags; vim has had that particular capability from the beginning since it was a vi feature. You can also click on stuff with a mouse to jump to definitions; I think that became possible in 1996 when vim first got a GUI.

I have used a little bit of Qt Creator and Eclipse, and used Visual Studio for years to do paid work, and the actual editors on all of them are honestly pretty bad compared to vim. VS became more bearable by using a paid plugin for the Professional edition, but still not good.

To my mind, having never been taught or learned as a kid/teen how to use vim or emacs, it seems a lot simpler to just do everything in a Notepad like editor and have the terminal up near by... even if it is an extra click or two.

These editors have a certain level of knowledge that you need to gain before you can use them. It's really not that much info at all, but it feels like a lot because, in addition to learning, it takes practice using something that might seem bizarre at first.

Once you understand something like vim, those "simpler editors" become too simple, way too simple. e.g. I used to not care about moving around text with the arrow keys, but now I feel crippled without an edit mode.

I recommend reading this post on understanding vim: http://stackoverflow.com/questions/1218390/what-is-your-most-productive-shortcut-with-vim/1220118#1220118

Extending is just a part of it, bare-bones vim/emacs is already a serious development tool. What's wrong with "fancy key commands" if most of what you do in the editor is type? When you sit in the editor, you want efficient manipulation and navigation. Not having to leave the keyboard with your hands is one part of that, but the commands in emacs are more reliable and understandable than an out-of-the-box indexing editor. If I do a recursive file content search in emacs, I know that's what I get. And I have very fast ways of navigating the results. Why complicate it?

Also, compiling in emacs: M-x compile. The first time you issue that command, it asks what shell command you want to execute. Type 'make', 'gcc main.c' or whatever. Bind compile to F5 with M-x set-global-key. Navigate the errors from the compiler with some other keys. It's smart and simple.

I'm trying not to argue against the larger IDEs, but they tend to give me claustrophobia.

Question though: what amount of work does it take to make vim from just a text editor with some fancy key commands, and being able to turn it around and make it a serious development tool? Seems like the biggest reason people prefer vim or emacs over just... text editors is because you can extend them to include very basic development needs (like compiling, for instance).

I guess that depends largely on what works for you.

I use vim professionally and so do my fellow team members. We're all working on Linux, though (embedded systems and networking application software). I haven't seen people using things like auto-completion or pop-ups, but some people like to use 'cscope', which integrates with Vim pretty much out of the box. But that's kinda C-specific.

I make heavy use of tabs, copy/paste/cut with markers, search and replace, and regular expressions in Vim, along with formatting features, navigation strokes, etc... I also have my vimrc set to do things like color column 81, color text past column 80, underline the line the cursor is currently on, color trailing whitespace, number lines, etc... That's pretty much it and that, for me, goes a long way. Except for the vimrc stuff, it all comes with Vim. To get the coloring, you can just google and copy someones vimrc, or I can post mine, etc...

Side note:

I consider a bash shell to be my IDE (at work) and all the command-line programs like vim, grep, sed, awk, less, cat, gcc, make, git, etc... are like plug-ins for my IDE. So, this is why I don't really super-size my vim. Instead, I focus more on how to improve my shell usage via learning/writing new programs, shell scripting, etc... The other nice thing about those tools I listed is that they have a similar "dialect". Basically, they play nice with each other.

I remapped my hotkeys for gnome-terminal so that I can easily spawn new windows (in tabs or separate), move the tabs around, and move between the tabs. When I want to build, I just spawn, move over, and run make. I just like having the output separate like this. (e.g. ctrl-n: new tab ; ctrl-N: new window ; ctrl-[,]: move to prev,next tab ; ctrl-{,}: move tab left,right) My coworker really likes terminator, which is pretty nice with split-panes, broadcasting to all panes at once, etc...

I have tried this in Windows too, with powershell, vim, cl.exe, nmake, git, etc..., and it works fine, so I do that sometimes. I just find bash easier to use than powershell (maybe I don't grok ps, yet). I think it's important to be flexible, though. I really like the look and feel of visual studio, for example, especially with a Vim plug-in. I also really like Eclipse with a vim plug-in, but I don't work with Java a lot (and I ran into some technical bumps with CDT, not sure how smooth it is now, though).

To say something about the last remark, I prefer Vim over other text editors, not because it does things that other text editors don't, but because it does things better. I know this doesn't sound right if you are new to Vim or you don't get Vim because I was both those things at one time and another. At least, this is how things went for me.