Ian Bicking: the old part of his blog

Other Editors?

So, I've used Emacs as long as I've used Unix, and it's generally treated me well. But sometimes I wonder if there's something out there that might be better for me. Remembering that I spend a lot of time in a text editor, is there something else I should be looking at?

Some features I require:

Some features I want but maybe don't need:

And of course:

I actually kind of doubt I'll drop Emacs, since I usually realize that Emacs has features I didn't even realize I'm constantly using. But I thought I'd give it a try. I'm not sure I'm up for Eclipse, though, and if Emacs is showing its age then Vim is just showing a different sort of age.

Maybe to be helpful, these are things I don't care about:

Created 13 Dec '05


You can try NewEdit for a test.


I'm the only person developing the software. I hope it can fit you. There are not so much English documents now.

# limodou

I've tried playing with NewEdit, it looks promising, but it still has quite a few rough edges. The thing is, I don't see an easy way of feeding back to you the problems I'm hving, the issues I'm getting, and so on.

But yeah, it could be quite good.

# Moof

Sometimes I use Eric3, but I prefer Kate.
# zgoda

Eric3 However there's a bunch of python editors on the net mostly made for personal use.

# Lehalman

I hate to say it, but after going back and forth between Vim and {,X}Emacs a number of times I have to recommend Vim. It's Open Source and Python scriptable, although I'm not sure if it's handling of multiple files and windows would fit your needs. There's Vimacs_ which provides Emacs keybinding for Vim (such an odd concept...). Works over ssh, works on Windows and Macs, does smart indenting, has lots of Python-specific plugins. As much as I loved Emacs, I find Vim (as opposed to vi, which is awful) a treat to work with.

# Shahms King

I'm not sticking to a single editor, but I am sticking to a single key-binding. That key binding is Vi(m). I'm not saying it works for everybody, but here's my reasoning:

  1. Vi is everywhere. If I ever need to edit text on an obscure platform, I can be productive.
  2. It may not be for everyone, but I've found that modal editing works for me. I find it easier to switch modes and use simple key strokes than chording keys for even simple tasks like saving.
  3. 99% of my development is on Win32. I use Vim for simple stuff. For the .NET development I do, I'm evaluating ViEmu. This gives me all the functionality of Visual Studio (intellisense, build management, etc.) For Java (and possibly Python in the future, via PyDev), Eclipse has viPlugin. Both of these add-ons cost $$$, but the productivity boost is worth it to me.
  4. Vim has much better support for Unicode than Emacs, at least at this point in time.
  5. "The Pragmatic Programmer" says "Learn one editor." By knowing the Vi(m) key bindings, this lets me be productive in all the editors I use on a daily basis.

It took a long time for me to come down to this. I realized I wasn't going to be fully productive in any one editor, so learning common key bindings is the next best thing, IMO.

# Shawn Wheatley

Just curious...does EMacs do real autocompletion for Python?

Right now I'm using SciTE, which does smartly indent. I tried all those IDE's including Eric3 but they were much too slow. SciTE is very fast, and allows me to jump to an exception instantly. However no inline Python functions.

I think I'll try out that NewEdit. It looks Scintilla based from the screenshots, but doesn't overdo it. I'm glad you mentioned it!

# Kevin Deenanauth

Emacs doesn't have "real" python auto-completion, for some value of "real". But pycomplete is a start. (requires pymacs.) The default keybinding is C-M-i. You may have to fiddle $PYTHONPATH before starting emacs to get it to find things you want to complete. Annoyingly, it seems to be a bit all-or-nothing: if something imported in the current buffer isn't on $PYTHONPATH, you can't complete anything, and I don't know know any way to supplement $PYTHONPATH without exiting emacs and fixing it in the shell. And pycomplete it doesn't work at all in filesystem Zope2 CMF "Scripts", but those are sufficiently weird that it's not surprising :-P

# anonymous

I use Vim and now I'm using SciTE too.

Easy to configure and well documented, code folding for free, auto closing of xml tags, uses spaces or tabs according to the actual file or to your preference, show whitespaces and indentation, autocompletion (but only from the actual file), you can generate a python api file for calltips, support for UTF-8, runs on Linux and Windows. And is very small and fast (you can even put it on a usb drive).


The only negative point is that the author is more active on the Win side, anyway the GTK version works fine.

# michele

Oh, and gnome 2.14 will come with a totally new gedit which will even spot a cool python plugin system.


I'm really looking forward to see how this will turn out.

# michele

jedit - http://jedit.org/ As much as I try to switch to something else I find nothing else supports what I want from an editor. Probably the only java UI that isn't a train reck. I mainly use these plugins: session and buffer list. But the search in the tool bar is key! And multi window or multi view support is great. The number of syntax highlights is hudge even apache httpd.conf is in there. Good luck

# Lateef

I also use jEdit; it has a Jython plugin so you can script it with Jython. There's also a JPyDbg plugin that gives you remote Python source debugging from inside of jEdit. Its Python mode indents when you hit enter after a colon, and it's fairly easy to configure sensible tab processing. The hypersearch and project searches are useful, as is rectangular selection and editing.

Dunno if I'd compare it to Emacs exactly; for me it's better as I'd rather not have to spend so much time programming the editor to do useful things. :) But then, I haven't used Emacs in a long, long time. I've only ever written two jEdit macros; one to automatically strip trailing whitespace from the current line whenever I hit enter, and one to insert blank lines until the current line's line number modulo 41 is 1. (Don't ask.) Anyway, everything else I've needed has already been there, or easy enough to do by hand.

# Phillip J. Eby

For the record, regarding indenting, Emacs understands expressions and block terminators in addition to colon. So this is Emacs indenting:

def munge(x, y, z,
    return {
        'x': x,
        'y': y,
        'rest': (z, kwarg),

Emacs will indent the lines to exactly the position I show up there, and after the last line it won't indent at all (since the def is closed by the return). Sometimes -- not often -- it gets it wrong. Other times -- not often -- I don't like how it wants to indent my source. In those cases it can be a little annoying, but mostly because I depend on it so much that it's hard to resist using it. Emacs python-mode also has block indent and block dedent; in comparison to the automatic indenting this isn't a very sophisticated feature, but definitely something you want to have for Python.

(Is that line number modulo 41 the reason you have [what seems to me] strange chunks of verticle whitespace in your source?)

# Ian Bicking

I could be wrong, but I believe the only other editor to come close to Emac's python mode indenting is Vim. Here's what vim looks like for your sample without any fixups:

def munge(x, y, z,
    return {
'x': x,
'y': y,
'rest': (z, keyarg),

and with fixups along the way (commented)

def munge(x, y, z,
          kwarg=None):      #space kwarg over 2
    return {
        'x': x,
        'y': y,
        'rest': (z, kwarg),
        }                   # left 2, tab 1

I suspect this could be fixed, but its low on my priority list. Favorite vim feature: tags support - between this and other doc / code lookup features I spend a lot less time clicking about other modules and packages, particularly those I rarely use.

Have used jedit extensively; eric3 as well - found the ubiquity of vim and the extensibility of gvim just too hard to live without. That said, I'm sure a blew a month getting vim configured how I like it and getting used to a modal editor. If its not a long term commitment its not worth going down the vim road I fear.

# Mike Watkins

I'm not sure what python.vim indent plugin you're using, but the updated one from vim.org should produce the following:

def munge(x, y, z,
    return {
        'rest': (z, keyarg),

and drops the cursor to the 1st column after the last }. This almost exactly the same as Emacs.

# Keir Mierle

Dunno if jEdit is being actively developed. I know Slava (the primary developer) has moved on. I haven't seen a release in a long time. Does anyone know the status? Has someone taken over development?

# anonymous

I don't think anyone's taken over development. It was sad, but I've moved back to using emacs after using jedit for ~4 years. Here are some pro/cons that I re-discovered, for out-of-the-box experience (I realize you can "do anything" if you code enough elisp, but that's not what I'm talking about).

jedit pros: 1. GUI is nicer/exists - fonts, dialogs, etc. 2. (Simple) configuration is nicer. 3. Has more editing features readily available (I hesitated to include this, given that I'm comparing against emacs, but I did find that I discovered useful features more easily by browsing the jedit config/docs than with emacs through apropos/texinfo)

emacs pros: 1. Editing modes are more polished - python, and especially auctex. 2. Remote/console use. 3. Less memory intensive.

A con for both is still occasional unresponsiveness. The reason that I left emacs to begin with was that at the time I still read my mail through emacs, and the fact that emacs was single-threaded meant that whenever I did something "intensive", e.g. open a large mail folder, my entire emacs would stall. I felt like I needed to move away from the emacs- is-my-OS workflow. Now that I've come back to emacs and use it soley as my editor, it's not nearly as bad (and computers have gotten faster in the meantime too :-), but I still find the occasional inability to edit another buffer while emacs does its thing annoying. On the other hand, jedit, being a java app, seems to want a ridiculous amount of memory, and hence I encountered random hiccups from (I'm guessing) gc.

Anyways, I think the main advantages and disadvantages of emacs stems from its age - it has a lot of nifty polished packages, but its base architecture AFAICT isn't really conducive to threading (or whatever other technology you want to use to enable snappy multi-task/buffer work environments).

# anonymous

JEdit is incredibly actively developed. I would definitely recommend it or else Eclipse (pydev). Especially the pre-release version of JEdit has much improved syntax rules, like auto-unindenting for ruby, etc. There are many plugins for things like project support, code completion, console access, etc. One plugin I can't live without is the buffertabs one. Set the tabs to show open files on top, and it's similar to a lot of IDEs. Also, set the gutter preference to show line numbers.

# anonymous

Sorry, you're right, Slava did abandon the project. This happened recently, I wasn't aware of it. Sounded too unbelievable! But he has his own programming language now apparently.

# anonymous

A new beta release of jEdit happene in Jan 1, 2006. That is something to chear about.

How about pymacs:http://pymacs.progiciels-bpi.ca/ ?

# didier

There's SPE: http://www.stani.be/python/spe/blog/

I like WingIDE, but it's proprietary. (wingide.com)

# Ken Kinder

Hi Ian

My comment assumes you don't know Vim - if you do, and you still believe Emacs to be better for you, great(!) and ignore my post. Otherwise...

Vim is just awesome. Like someone famous once said, using Vi(m) is practically a zen experience in that the brevity of your keystrokes appears to cancel out brain chatter. You will already know this as an Emacs user, but for myself, switching from the notepad-like editors of ConTEXT, syn, Zeus and so forth, it was astonishing to me in Vim how low the number of keystrokes for typical routine editing tasks can become.

I don't claim to be a power user in any way, but the features I use often that continually blow my mind are:

I am not an Emacs user, so it is difficult for me to contrast the two for you. However, for the particular purpose of editing text and writing code, I imagine Vim will be hard to beat in terms of keystroke efficiency, if that is at all important to you.

Vi(m) is of course, not without its faults. For me, context sensitive completion for python (or any) code /modules is a big deal, because I come from a Delphi background and that feature of the Delphi IDE is incredibly cool. One day I will put in some effort to build a class inspector into vim. Since vim is python-scriptable, it shouldn't be that tough.

Good luck! Caleb

# caleb

Check out wingide www.wingware.com. It's commercial, but is an amazing python editor.

# Peter Fein

Several people have mentioned Vim and I thought I would touch on this just a little bit more.

Vim can satisfy ALL of your requirements:
  • Open Source: Hosted on sourceforge, see vim.org
  • Python scriptable: needs to be compiled in. This is true on default Windows build, not sure about Mac builds
  • Vim fully supports the single editor instance paradigm. I find it particularly good on windows when you add the edit with vim explorer extension(part of the default install) which lists the open instances for you to add the file to, or start a new instance.
  • All the standard features are there (highlighting, many language support, incremental search etc.)
  • Vim has smart indenting as well as smart reindenting (highlight code and press '=' to indent the selection according to automatic rules)
  • There are several emacs keybindings plugins
  • Vim is both gui and console which means that you can ssh into a box and run vim on the remote box. You can also have vim edit files that it gets over ssh, and ftp.
  • There is excellent windows support. I know people who use Vim on Mac, though I don't have Mac so I can't comment on its level of OS integration.
  • It is actively developed both from the standpoint of the core program(version 7 is in development) and plugins (see vim.org)

To give you an idea of how powerful Vim is check out http://cream.sf.net/ which is a project to make Vim easier to use for the masses. This is done though configuration files and scripts.

# Chris Lambacher

For something which is quite _different_ in the text editor space, have a look at http://www.cs.yorku.ca/~oz/wily/

There's a comparison of wily and emacs at http://www.faqs.org/docs/artu/ch13s02.html

# Gary Capell

Vi(m) is worth checking out. Also take a look at Vi(m) versions built with a specific OS in mind like: cream, gvim Carbon, ...

Outside of Vim land, I am getting into xcode and even BBedit. Both close source and on run on the Mac, so the definately do not fit you requirments. Nevertheless, I think it is only a matter of time some of the impressive features found in xcode will be cloned in some open-source projects.

# Brian Ray

i'm writing a pygtk editor. http://fauxlkner.sourceforge.net/ i thoroughly suggest writing your own, or modifying my source to suit your wants. [it already has your needs.]

# faulkner

SPE is emerging very fast as one of the most promising IDE's. It supports UML, has a gui builder wxGlade and WinPdb a remote debugger, which even can handle multi-threaded programs, etc... Any bugs are quickly fixed and its author is very responsive to its users. If you haven't you should really try out the latest version: http://pythonide.stani.be

# Koen

Jed! of course http://www.jedsoft.org/jed/

I checks on ALL the requirements you mentioned Ian. The major difference between Jed and Emacs (cuz you still wanna use emacs keybindings don't you) is that emacs starts in about 3 seconds, jed in 0.1 but jed can't split the screen vertically like emacs can.

# Peter Bengtsson

I generally use joe when I need a quick console editor with Emacs bindings. I'll give jed a look too, but I only imagine using it as a quick auxillery editor.

# Ian Bicking

I recently moved from ultraedit -> jedit -> wingide. Wingide is completely changed since 1.* and 2.* is really powerful and has everything I need including emacs (and soon to come VI) bindings.

It is also free if you have an open source application (which you do). You should definetly give it a spin

# VJ

Isn't one of the console-based editor's advantages that the capability is the same whether you are working on your local X-desktop or via ssh to a remote server? ipython appeals to me as an IDE for its console UI and emacs integration. It always is in the back of my mind that if using a powerful GUI IDE or editor, you're probably going to have to do without it at an inopportune moment on some remote machine.

I would love to use a python-based console editor. Emacs intimidates me, but I'm drawn to its power.

IMO, It would be a very good use of PSF grants to support a two-year iniative to develop pure python editors. Year one, a capable editor back-end in pure python is implemented to support most use-cases of power emacs and vi users, and various IDEs. It wouldn't have much of a UI, but its components would be powerful, portable and extensible.

In year two, grants are awarded to teams who propose to write UI layers for the back-end, resembling or inspired by popular editors such as (X)Emacs, Vi(m) and various GUI editors. The point of departure with the imitated famous editors and the new implementations would be a common python scripting and extensibility API from the year-one project. (e.g. Python scripting instead of Emacs LISP and other heresies).

There are most likely limitless possibilities for a well-designed editor back-end in python.

I'd use it.

# Jeff Kowalczyk

How about Leo? It's "more different" than most editors, but it seems to fit your requirements...

# Mark Eichin

Leo uses its own file format with funny annotations. I can't use that, because everyone who worked with my code would need to use Leo as well, and that's no good (at least for me).

# Ian Bicking

It would be a very good use of PSF grants to support a two-year iniative to develop pure python editors. Year one, a capable editor back-end in pure python is implemented to support most use-cases of power emacs and vi users, and various IDEs.

# Jonny

I have been searching for a visual editor (basically dragging my widgets across the screen) for wxWidgets.

I found that boa-constructor supports wx, but the problem was that i could not move a widget once it was placed. This is rather discomforting... are there any other rich Visual editors in the market? I would prefer ones for the linux/FreeBSD platforms

# Prashanth Mohan