Emacs. I've used to to code in Vim/Gvim, but I switched to Emacs just to try and learn about Lisp. Emacs has tons of interesting "plugins" to add, and actually I'm using emacs as my Organizer (using org-mode) too. Emacs hasn't anything to envy to any of those bloated IDE's like Eclipse or VS. I recommend to you: * http://www.emacswiki.org * http://steve-yegge.blogspot.com/ Steve Yegge has a lot of articles about Emacs/Elisp and it has been a excellent source of information to me.

I was a long time vim user too. I switched to emacs after witnessing slime and clojure. I can't image life without org-mode anymore.

:) Agree. Org-mode is great! It's extremely simple and the best of all is that save everything into plain text files that you can track with any version control system.

Org-Mode can be easily considered a killer app for Emacs http://orgmode.org/

I have something similar for Vim. Plain textfiles under svn are a great organization tool. Need to try orgmode sometime so I can copy its features :)

Vim. Emacs. There's very, very little they can't do. Once you get over the initial bump, you'll find that the main reason why they (seemingly!) haven't changed much since 1995 is simply that they didn't have to.

Gvim/MacVim for me.

I was on the Eclipse wagon for a while. Where Gvim finally clicked with me was (1) when I discovered Pathogen for more easily installing plugins, (2) discovering NERDTree, and (3) when I finally got the idea to use something like github or even Dropbox for storing my .vim folder and my .vimrc/.gvimrc files, and just symlinking them into place on each machine.

Both Vim and Emacs have some very nice features. Compared to a full-featured IDE, yeah they do look a bit old school. Even so, you can be incredible productive in either of them. I use Emacs myself, and I can't imagine trying to live within the constraints of an editor that I can't extend.

Emacs. While it might look dumb or something from the 80s at first, once you discover its true power, you'll be hooked forever.

Using it since the autumn of 2000, never failed me, no matter what crazy thing I wanted it to do.

I've used Emacs for years. In my current job I also have occasion to use IntelliJ IDEA for debugging. It amuses me to note that where Emacs was once derided for being large and slow ("Eight Megabytes And Constant Swapping" was one user's take on it, back when 8MB was a lot), now it is the smaller and faster choice.

I'm in love with ActiveState Komodo, and it works great on both platforms (and mac as well). I'm not sure if it has macros, but everything else you mentioned is right there. The editor is free, and the IDE version is not too expensive.

From the Komodo help:

Creating Macros

Macros can be created by recording keystroke and command sequences, or written from scratch in JavaScript or Python using the Macro API.

Second Komodo Edit. It even has Vi emulation if you want that :)

After years of using fancy 'modern' IDEs, I've gone to using Vim. (GVim/MacVim, actually.) I haven't found any features they lack that other IDEs have... And I suspect if I found one, I could code it up myself, if nobody else did it.

visual c++ debugging ? it has this?

For vim there are some plugins, but it's probably not that mature. Emacs has good integration with gdb.

Emacs, because you do more writing of non-code than you realize. Emacs is good for the sort of prose to code cross-writing; each interspersed with the other, mixed with markup and semantic info (like "TODO") that we all do.

Emacs is the obvious answer, and there's nothing "1980" about it.

F# is going to be tough, but take a look at the Netbeans / Eclipse IDEs. A bit easier to set up, especially if you're migrating from Windows to a graphical linux system like Ubuntu.

Vim and Emacs are great, but I would seriously consider a good IDE. The advantages of built-in project management is not to be underestimated. It's not something that's so ridiculously important later on, as you can obviously use something like git on its own to manage it, but initially it is fairly invaluable.

I use Geany. It's not particularly featureful but it has some code completion, tabs, and highlighting support; the only thing I really miss over classic "power editors" is the deep programmability, which I don't actually like most of the time. I like sensible defaults so that when I reinstall there's zero hassle and I can just work immediately. (but I will admit to envying some of the more whiz-bang stuff that you get by bothering to really learn Vim/Emacs.)

Pick either Vim or Emacs and you'll cover 99.99999% of any possible raw text editing scenarios you can think of.

Here's some F# highlighting for vim: http://www.vim.org/scripts/script.php?script_id=2162

Jedit is ok, but I found it quite slow compared to vim. My own personal favourite is vim (as you can probably tell) but Emacs has some interesting extras that make it worthwhile learning too (such as org-mode).

A lot of people are recommending you learn emacs. I do too but I want to add that emacs is very hard to learn since it feels so foreign at first so don't get discouraged, take it a little bit at a time.

I used to use vim and tried switching to emacs to see what it was about. On my first try I despised it. After my second, I fell in love and can't stand to use anything else anymore.

ps: Control-x-c is to quit ;-)

Another bump for the emacs/vi couple; I use emacs.

I recently switched from TextMate to MacVim. I had used vim and xemacs over the past two decades that I've been exposed to Unix system, but never put in the effort to really master them. I'd used various IDEs and editors, and was pretty happy with TextMate, but the long wait for TextMate 2 really showed me the importance of well-supported core tools; as a developer you can't get more core than your text editor and the emacs/vim communities are second only to Linux in terms of breadth and depth.

The reason I went with vim is because I believe it is as close to an optimal editor for arbitrary code and text as you can get. My first impressions were that emacs was about power through customizability, and vi was about raw efficiency. Customization is important, but personally I prioritize powerful editing slightly higher because it makes it easier to jump into new languages, and is particularly useful with sysadmin duties. Being skilled with vim pays dividends with every single new language I learn and technology I deploy, most of which are not important enough for me to invest in editor customizations. Now for my bread and butter language (Ruby/Rails in my case), investing in customizations is worth it, but even so, I will probably never go down the full-blown IDE road (unless the IDE is built around vim as a first-class citizen).

Not that I don't think true IDEs can't beat vim/emacs in productivity. It's relatively easy to become more productive in specific environments such as Visual Studio or IntelliJ, however that productivity falls off a cliff as soon as you leave the comfort of a properly supported language. At the end of the day, the promise of extreme productivity in producing reams of Java code is little comfort if I will be clumsy jumping into a language like Haskell where reams of code aren't necessary; I just don't want my incentives weighted that way.

Now as to the cross-platform issue, this is one of the most important to me, in large part because of the large number of servers I find myself logging into. However it's not just the MacWinLin axis, but also the temporal axis as well. Vim and emacs aren't going anywhere. They are too well-designed, and have too much mindshare to go away. Short of massive advances in AI and/or raw thought-input no one is going to come up with a more efficient general purpose keyboard editing than these tried and true methods. That's not to say that IDEs or editors like TextMate aren't bringing new advances to the table, but the best ideas will always make their way back to vim/emacs or vice-versa.

The learning curve of vim is indeed steep, and becoming fluent in its rich command set is a life-long project. That's okay because it's one of the few technologies that you can be sure will still be in widespread use 50 years from now. The cost of learning is heavily amortized and the interest heavily compounded. Overall it's the surest technology choice I've made since jumping from svn to git.

I completely agree with you, except that I value customization higher than you do, so I choose emacs.

Have you considered VIPER mode for emacs? I know it's not complete VI emulation but it's pretty close. If I was to start again (with no muscle memory built up) that is absolutely the way I would go.

I'm using NetBeans, which does a great job as IDE and vim as simple code editor.

MonoDevelop

to add some more diversity: i settled on using jEdit.org on mac, linux, windows. it runs pretty much on anything that has Java (like irix). Nice plugin system, solid file/folder handling. Give it a try.

Jetbrains idea

Komodo Edit

Vim is awesome. You can do anything.