Attachment 'review-of-6-python-ides.html'


Friday, September 09, 2005
A review of 6 Python IDEs
(March 2006: you may also be interested the updated review I did for PyCon --

For September's meeting, the Utah Python User Group hosted an IDE shootout. 5 presenters reviewed 6 IDEs:

(The windows version was tested for all but Eric3, which was tested on Linux. Eric3 is based on Qt, which basically means you can't run it on Windows unless you've shelled out $$$ for a commerical Qt license, since there is no GPL version of Qt for Windows. Yes, there's Qt Free, but that's not exactly production-ready software.)

Perhaps the most notable IDEs not included are SPE and DrPython. Alas, nobody had time to review these, but if you're looking for a free IDE perhaps you should include these in your search, because PyDev was the only one of the 3 free ones that we'd consider using. And if you aren't already familiar with Eclipse, PyDev probably isn't for you. (It's worth pointing out, though, that the personal editions of Komodo and Wing are only $30 and $35, respectively, and Wingware lets open-source projects use its IDE for free.)

This review first gives a comparison of features that I consider important, then gives some more subjective material for each IDE to indicate the flavor of our experience with it.

(The pronoun "we" in this post refers to the UPyUG, but "I" is always Jonathan Ellis.)


All reviewed editors provided basics like syntax highlighting. These features are not included in the comparison charts; no modern IDE should be without them.

PyDev Eric3 Boa Constructor BlackAdder Komodo Wing IDE
Keyboard Macros No Yes No No Yes Yes
Configurable Keybindings Yes No No No Yes Yes*
*Very weak UI; expect to do a lot of manual browsing
Tab Guides No Yes Yes No Yes Yes
Smart Indent* No No No No Yes Yes
*Knows to de-indent a level after break/return/etc. statements
Code completion Decent Useless No Vim-style* Good Excellent
*Can guess symbols already present in the current document
Call tips No Mostly broken No No Yes Yes*
*"Source Assistant" provides calltips and docs in a separate panel
"Go to definition" for python symbols No No No No No* Yes
*"Find symbol" is basically a find-in-files text search
Templates Yes Yes No No Yes Yes
Source Control Integration Eclipse* CVS** No No CVS/Perforce/SVN CVS
*CVS is standard; plugin availability varies for others
**SVN is ostensibly supported, but didn't work for us
GUI Builder No No Wx Qt Tk No
Emacs emulation* Poor No No No Poor Good
*None yet support VI(m) emulation -- sorry!


PyDev Eric3 Boa Constructor BlackAdder Komodo Wing IDE
Conditional breakpoints No Yes No No Yes Yes
Evaluate arbitrary expressions Yes No No No Yes Yes
Debug external programs* No Yes No No Yes Yes
*E.g., a script processing a web server request


PyDev Eric3 Boa Constructor BlackAdder Komodo Wing IDE
Documentation Virtually none Virtually none Virtually none Poor Excellent Good
Unique features PyLint integration; "extract method" refactoring ?* Regular expression builder ?* Multilanguage; save macros; regular expression builder Source Assistant; scriptable with python
*I didn't notice anything worth mentioning



If you like Eclipse, PyDev is a decent choice (provided, of course, that you have a suitably beefy machine). If you are unfamiliar with Eclipse, good luck with the learning curve; you'll need it.

PyDev is the only IDE reviewed where features such as code completion will not work unless you add the .py files to the PyDev project.

"Extract method" is cool, but limited. Perhaps the biggest drawback is, it doesn't know its limits and will happily perform invalid refactorings.

Code completion is the best of the free IDEs we reviewed.


Eric3 has a lot of good features. These are overshadowed by two problems: a horribly cluttered UI, with a correspondingly painful initial experience, and the worst implementation of code completion I have ever seen.

You can choose from two kinds of code completion: completion for the stdlib, and completion for your current project. You cannot have both at once. "What the hell?" I hear you say. Yes, but it gets worse: say you decide to pick the stdlib. You write, "import os; os." and wait expectantly for the completion. You get... a list of all symbols anywhere in the stdlib! Or pretty close to it. Wow.

Calltips are a similar mess. If you write "os.path.exists(", you may get the calltip for os.path.exists, or you may get the calltip for any other exists method.

Eric3 is documented as well as the other open-source projects we looked at, which is to say, there are some screenshots and a mailing list.

Boa Constructor

Supposedly, Boa Constructor supports code completion and call tips, which you can invoke with control-space.

This didn't work for us. At all. We didn't spend too much time trying to figure out what was wrong, though, because the worst part of the experience was how amazingly unstable Boa Constructor is. (Well, "amazingly" except to anyone who has used earlier versions of BC, I guess. Apparently this isn't new with the 0.4.4 release.) It would corrupt dialogs, screw up components such that they had to be deleted and re-added, and crash to the desktop. I hadn't considered rating IDEs on MTBF before, but Boa Constructor made me think hard about it.

Oh, and if you try BC and your first component on the frame sizes to take up the entire frame once you run it -- that's normal, apparently. Just add more components and they will start behaving. Until it crashes.


The only IDE here that doesn't support code folding, BlackAdder fails in more important ways as well. (Hey, I almost never bother with folding even in other IDEs.) Most glaringly, it was the only reviewed IDE that we could not get to run a test program; it complained instead about DLL import problems. Possibly this is due to us using PyQT 3.1.14 instead of 3.7, but the former is the only one available to download from TheKompany's site. (Trying to install on Linux resulted in even less success; we never did manage to get it to run.)

BlackAdder also has the uniquely annoying trialware behavior of closing itself after 10 minutes no matter what you are doing. (The description on, which says that saving is disabled, is incorrect -- you do get to save your work.)

Vim-style code completion is pretty weak stuff when you're competing with companies and free projects that do the real thing.

Editor doesn't obey normal conventions like double-clicking on an option to pick it and close the dialog or re-opening a file when it changes on disk.

The only documentation is a 35-page PDF, about 18 pages of which is actually reference material. The rest is taken up by installation instructions (see above for how helpful this was to us), a tutorial (fairly useful) and a guide to QT Designer. It's hard to complain about the reference material since there really aren't a whole lot of features to document, but it's still underwhelming. (No mention is made of code completion, for instance; I never would have known about it if I hadn't seen a reference in some Usenet thread.)

BlackAdder is the oldest IDE reviewed here (1.1 was released in 2003), which speaks in more than one way to its relative priority for TheKompany. I'd be embarassed to leave a product with this level of problems in my store.


Komodo is a good IDE, but it has rough edges. Its code completion engine is prone to refusing to help out in certain files. I couldn't discern any pattern in the set of files it couldn't figure out. It also occasionally reports parse errors on valid code; this, for instance, is valid Python 2.4 (which Komodo 3.1 supports), but even in a blank file results in a parse error:

   other_space_used = sum(max(v.space_used, v.pending_space_used)
                          for (k, v) in u._machines.items()
                          if k != self.machineid)

Another one: Alt-b cannot be rebound to anything. I filed a bug report against Komodo 3.0 for this over a year ago, and it's still there in 3.1. (I also contributed to a report listing ways to make Komodo's emacs mode not suck quite so much out-of-the-box. This hasn't improved since 3.0.1, either. I guess it's fair to say I'm not very impressed with ActiveState's support system.)

Probably the biggest win for Komodo is its support for multiple languages. If you're not lucky enough to only code in Python (I am), this might be the killer feature that makes you an ActiveState customer.


Wing shares with PyDev the distinction of being the most heavyweight IDE in this review, in the sense of needing a fairly beefy CPU to remain snappy. (Two data points: on my 1.6 GHz Pentium M with 512 MB of ram, it's fine; on my 900 MHz P4 -- it's a long story -- with 512 MB, it's noticably sluggish.) This may be due to the bulk of Wing itself being written in Python.

I called out BlackAdder for having an obnoxious trial behavior, so I should probably point out that Wing has the least obnoxious trial. You don't have to enter your email address (BlackAdder/Komodo) or download and run an executable license key (Komodo); you just install the software and Wing asks if you would like it to contact to auto-install a trial key. Slick.

Wing is the only IDE here to give you code completion for more than function and class variables; it also completes keywords, modules (in import statements), and locals. This is more useful than it sounds; once you get used to it, you won't want to go back. (For my .NET readers: Wing does Whidbey-style completion.)

Wing's Source Assistant is nice, but it's distracting to have to look at a different panel to get call tip information. Better to have both.

Wing is the most polished of the IDEs here. I suspect this is due to the Wingware developers "dogfooding," using Wing to develop Wing. There are fewer oversights and more of the small touches that indicate quality. A minor exception is that the documentation has become outdated in some places.

Let me also note that if you tried and rejected Wing 1.1 back in the day, you should give Wing 2.0 another look. I fall into that camp myself; on Windows, at least, Wing 1.1 was horribly ugly. I couldn't stand looking at it. Wing 2.0 is much, much easier on the eyes. In fact, almost all the IDEs we reviewed look pretty good. Eric3's cluttered look is the only exception.

When I've had occasion to send several questions ("How can I make enter autocomplete, as well as tab?") and suggestions to the Wing IDE mailing list, Wingware has responded promptly. ("Use control to select multiple keys in the autocomplete dialog." Okay, I guess that was a stupid question.)


Early last year, I bought Komodo Personal edition for $30. That's a pretty good deal, especially when you consider its support for other languages (Perl, PHP, and TCL) as well as Python. I still think Komodo Personal is a good deal, but today I would go with Wingware Personal ($35) instead, primarily on the strength of its better code completion support, "Go to definition" feature, and Source Assistant. Superior Emacs emulation (superior to just about any other non-Emacs editor I've ever used, actually; I suspect Wingware has at least one Emacs refugee) seals the deal. A few days ago, I ordered Wing IDE Professional (paid for by my boss).

If you need an integrated GUI builder, or you have an older machine, Komodo remains a good choice, although not many people these days would pick Tk as their first choice for a GUI toolkit.

Of the free choices, PyDev is the clear choice if you have Eclipse experience. If not, well, the situation isn't pretty. Perhaps you'll have better luck with one of the IDEs we didn't review here.


ActiveState, TheKompany, and Wingware were all kind enough to donate a license for their respective IDEs to the Utah Python User Group as door prizes for the meeting where these reviews were conducted. (None of the reviewers received any of these.) We thank these companies for their support. (Sept 22: Shawn Gordon of TheKompany appears to have decided not to honor his commitment here.)

Thanks also to all our reviewers. Alphabetically, these are Brent Hughes, Byron Clark, Jason Reusch, Jonathan Ellis, and Justin Wilson.

Update Sept 10: noted that Eric3's svn support didn't work for us

Code completion ?
Please, are that tools able to complete properly the following code ?
class test:
def __init__ (self, name, value):
setattr(self, name, value)
def test (self):
setattr(self, "test2", self.test)

a = test("a", "b")
a. => ['a', 'test']
a. => ['a', 'test', 'test2']

I don't think they're able to complete that...
Here are a few points relating to Eric3, the IDE I use daily.

> Configurable Keybindings: no

Not directly, but Eric3 is well integrated in KDE, that offers such feature for all programs. I did remap a number of Eric3 commands.

> Code completion: useless

I beg to differ. I use completion from the file being edited all the time. Not being able to complete from API too at the same time does not make it useless in the least.

> Source Control Integration: CVS

Eric3 supports Subversion too.

> GUI Builder: No

Eric3 supports the creation of Qt user interfaces.

> Unique features: ?*

Eric3 integrates lots of stuff, like refactoring, coverage, and documentation tools.

Also, I don't see how Eric3 user interface is more "horribly cluttered" than other IDEs.

Absence of docs is a real problem, though, given its wealth of features.
A new one I stumbled accross recently, PIDA
Its sort of a thin gui binding together commonly used existing tools. Including a GTK glade compatible gui editor.
The windows version was tested for all but Eric3, which was tested on Linux. Eric3 is based on Qt, which basically means you can't run it on Windows unless you've shelled out $$$ for a commerical Qt license, since there is no GPL version of Qt for Windows. Yes, there's Qt Free, but that's not exactly production-ready software.

Unintentional (or misinformed) FUD?

One doesn't need a commercial licence to _run_ Qt apps on Windows. The qt.dll (whatever its name) can be distributed with an application without requiring a fee or limb sacrifice from the user.

What is needed is a licence in order to build PyQt, for the _creator_ of PyQt (once again, not for the users). And I think there _is_ a WinPyQt already available (and free of charge).

Anyways, all this will change with Qt4, which comes GPL-ed for windows too. And yes Qt4 is already much better than Qt3 was. Once again, all that is needed is a PyQt4Win.
Please note you COULD use ERIC3 with windows platform --->

Please install Python2.4(.1) and PyQtGPL prior to this software!

Build by
The latest version of this executable can be downloaded from

Eric3 snapshot 2005-04-10
The Zeus for Windows editor is a language generic IDE that supports Python:

Based on your list here is how it adds up:

Keyboard Macros - Yes
Configurable Keybindings - Yes
Tab Guides - Yes
Smart Indent - Yes
Knows to de-indent - No (manual de-indent only)
Code completion - Yes/No **
Can guess symbols - No
Call tips - Yes/No **
Source Assistant - No
Go to definition - Yes/No **
Find symbol - Yes/No **
Templates - Yes
Source Control Integration - Yes (CVS, SCC) No SVN
CVS is standard - Yes
SVN is support - No
GUI Builder - No
Emacs emulation - Yes
VI(m) emulation - No
Debugger - Only limited debugger support
Documentation - Yes
Unique features - scriptable with python
Unique features - code folding for python

** Based on ctags information
I evaluated SPE (Stani's Python Editor), Komodo and Wing several months back. Since the evaluation I've settled on SPE for editing and iPython for interactive running/debugging.

Both Komodo and Wing were 'good enough' but didn't seem to offer enough to me to justify the higher-priced developer licenses.

It is a shame that SPE was missed from the above table, I think it is more stable than some of the other tools - I was happy to switch into the environment and I've recently donated money to the development fund.

I recommend SPE - it has rough edges but development is on-going and bugs seem to be squashed quickly.
I've been looking at various IDEs and have been using SPE lately. I would have been interested to see it in the shoot-out and to read your comments about it.

Here's how it stacks up:
Keyboard Macros - Yes
Configurable Keybindings - Yes*
Tab Guides - Yes
Smart Indent - Yes
Knows to de-indent - No (manual de-indent only)
Code completion - Yes
Can guess symbols - ?
Call tips - Yes
Source Assistant - ?
Go to definition - ?
Find symbol - ?
Templates - ?
Source Control Integration - No
GUI Builder - wxGlade and XRCed
Emacs emulation - Yes
VI(m) emulation - No
Debugger - Yes
Documentation - Yes, + tutorial
Unique features - UML diagram of your classes
Unique features - code folding
Unique features - Kiki regex console and PyChecker

? I don't know the answer to these
* you can define your own menus & toolbar buttons - but this feature is deprecated
I don't use a lot of Emacs features (ignorance as much as anything), but most of the things are recognizable in that environment as well.

Keyboard Macros - Yes
Configurable Keybindings - Yes
Tab Guides - Yes
Smart Indent - Yes
Knows to de-indent - Yes
Code completion - No
Can guess symbols - No (though I feel like there's some minor mode that some people love in Emacs that does this; I've never used it, though)
Call tips - No
Go to definition - I think there's something with oo-browser that does this, but I've never tried it
Find symbol - I believe BRM (bicycle repair man) can provide this...? There's several BRM-provided refactoring features (it would be interesting, actually, to know which of these IDEs use BRM, and which have their own refactoring support)
Templates - No
Source Control Integration - Yes
GUI Builder - No
Emacs emulation - Yes ;)
VI(m) emulation - Yes
Debugger - Yes (pdb integration, haven't tried it)
Documentation - Excellent
Unique features - a whole bunch I probably don't know about

It would be nice, though, if there was a document out there describing a complete stack of modes, configuration, and development practices that work well with Emacs.
As much as I love Emacs, it's a pretty sucky python IDE, even with the add-ons you mention. I mean this in the sense of "modern features like code completion," not "better good as vi," which is a pretty low bar against which to measure yourself. :)

I've heard that python-mode for Gnu Emacs 22 is much improved, but it's not compatible with v21 emacsen and I have better things to do than try to build that beast from source. :)
... perhaps I should mention that I've been using emacs for 13 years, so I'm no emacs hater. It just doesn't cut it anymore.
Oh, I certainly know Emacs has its problems. Hell, I only know of most of these features, I haven't put the time into figuring them out, and it sucks when it takes time to figure things out.

It's just sad that nothing else seems to be taking up the torch when it comes to the Emacs UI, which remains one of the best editing UIs out there.

I'm surprised Emacs 22 has features that couldn't be backported to 21 easily enough...? I thought it was all in elisp?

If someone made a self-proclaimed Emacs clone in Python, I would totally use that, even if it sucked. So long as they mean Emacs-the-general-idea, not just Emacs-the-keybindings.
I agree, although I think to become "the next emacs" you'd have to support multiple extension languages, similar to how postgresql allows you to use any procedural language.
Emacs never supported multiple languages, and it did okay. That, despite the fact elisp hasn't been a very modern language for twenty years.

I suppose VIM would be a multilanguage example. I've never really used it, the vi thing scared me off. And, honestly, I like the long-running expectation of an Emacs session (the very thing othr people hate). But it's very possible I simply am not giving VIM the chance it deserves. There's a Python VIM-based IDE out there, isn't there? I forget the name.

But anyway, there's more programmers now than 20 years ago, and yet we're still all writing the same freakin' text files, so we (a) ought to be really good at this, and (b) don't need the entire programming community to build this, and (c) can write most of the stuff in a single language and avoid a lot of heartaches^Wheadaches.

I don't write GUI apps, except for one or two experiments in the past, so I don't know what it involves. But Emacs doesn't seem hard to me, except for all the extensions, which are the kind of thing I do know how to write, and I think that part is doable. Postgres supports multiple languages because it's written in C, and that's definitely not what I want.
One of the main reasons emacs is dying IMO is precisely because you can only extend it in elisp. Who the hell wants to write elisp in 2005? I sure don't. :)

VIM supports multiple extension languages but (a) not nearly enough of the internals are exposed for this to be useful and (b) it doesn't ship with any but "vimscript" (whatever the real name is) enabled by default, so effectively only vimscript is supported.

PostgreSQL is written in C, but nothing prevents a primarily python|ruby|whatever language from supporting other extension languages.
To be fair, the problems with Boa Constructor are because of the wxGTK widgets it uses (by means of wxPython). The widgets are not reporting their correct size or location to Boa Constructor, so Boa Constructor is left with incorrect placement information. So the weird widget placement is actually the fault of the underlying wxGTK library, not Boa Constructor.
Just a heads-up: Wing 2.1 will have a VIM mode to complement the already existing Emacs and Brief modes.

Disclosure: I am testing pre-releases of Wing 2.1 for the VIM bindings. There certianly still are rough edges and missing bindings, but they stand out because I feel I am in VIM all the time now. :)

As for the anonymous post about code completion: no IDE is going to autocomplete dynamically generated attributes due to the possible side-effects of having to run the code to find these attributes.

Wing works around this by interpreting isinstance calls in the code as hints. If you need auto-completion to certain types, simply insert a 'assert isinstance()' line.
Another amazing thing I'm surprised you did not mention about Wing is the integrated debug probe. This lets you execute code from a python shell on your program variables in th emiddle of a debug session. This is very very useful.
Hi. I'd like to correct you regarding "Go to definition" for python symbols feature in PyDev
- it exists - if you set cursor at some function and press F3 - PyDev will get you to it's definition
This works for me at version
I've tried many different Python IDE's, and have come to the same conclusion: Wing Ide 2 is by far the best!
Great to have a review - re eric3 I think they were a little unfair.

1) eric3: You can turn off most of those icons
2) Eric3: Autoindent can be turned on for :
3) Would be nice to see drpython reviewed
4) One more thing - in a BlackAdder license is the included distribution rights to the QT library. Which is much cheaper than the same license purchased directly from Trolltech.

Oh I use PythonWin on occasion as well as ipython (not an ide).

Brilliant review. Thumbs up.
Got a Python IDE review myself I did recently that I thought you may be interested in. Take a look if you get a chance - I'm always up for some healthy discussion.
The WingIDE debugger cannot handle multiple threads (Wingware have confirmed this). However, PyDev *does* do threads in an elegent way.

Another plus-point for pydev/eclipse is it's first-rate SVN integration. Probably the best out there.

Since eclipse can also handle C/C++ files (when the CDT plugins are installed), this is useful for mixed C++/python projects. Pydev also has full Jython support (although I've never used it).
SPE - Stani's Python Editor should be mentioned!
Please extend to SPE which has a lot of cool features: coed completion, LINT etc etc !!!
Another vote for including SPE.

I think midtoad's table summarize rather well the issue. I'd add to that table that the "go to definition" does work for SPE.

As well, for Emacs users that split their screen with several buffers, a "comfortable" setup might be the "single with tabs (mac, linux, windows)" document interface that allows fast switching between documents (if your window manager allows you to; with fvwm "Alt + Tab").

In addition, SPE is fast (much faster in not-the-latest-hardware than wingware's Wing IDE), clean, and to the point.

Midtoad, however, writes that Emacs emulation is possible: is this through a "by-hand" editing of the keybindings or is there something I am missing?

Yes- Eric3 does run on windows, but with a really old version of QT, and there is no support from the developers,
I'll add in another vote for SPE. Stani's really getting into developing the IDE and it shows. He's extremely prompt to respond to requests for assistance, both on and off list. Speed is good, it offers code completion, and has a really clean interface. Well worth checking out at

What about Xored TruStudio Foundation and Professional? It's another Eclipse-based solution that should be considered, especially given the choice to include PyDev. TruStudio seems very well integrated into Eclipse's project-oriented view of the universe and isn't just an editor plug-in (like PyDev seemed to be when I last tried it).

Eclipse does have a bit of a learning curve. However, once you figure out the essence of what is going on, you'll find that Eclipse is much more than "just an IDE". Contrasted with most of the environments that were reviewed, there is real documentation for Eclipse in general.

As an aside, I think Eclipse's CVS/SVN integration is just about second to none. I find myself sometimes using Eclipse just to manage various projects.
i like komodo pretty much except that i face a weird problem when i use gplt function from scipy the plots vanish as soon as the program ends. So i had to put a break point / raw_input statement after the plot
Also can somebody tell me an IDE which can help me freeze a python program to exeecutable file. Now i am doing it using py2exe which i guess you know is pain. i mean finding the missing module and stuff like that
You forgot to mention that in Wing, the call tips are only available in the pro version at $170 or so. With Komodo call tips are available in the $30 version.
To use completion from API in ERIC (actually to find out what methods and attributes an API class contains), use the ERIC's embedded shell (or any Python shell). For example:

## just in case you do not have yet:
import rlcompleter, readline
readline.parse_and_bind("tab: complete")
## end

>>> import sys
>>> sys."now push TAB key"

gives you list of methods/attributes of "sys" module.

Why didn't you include in your review the "Stani's Python Editor" at

i think it is one of the best free IDE for python available nowdays
Please read the second review, linked at the top, which included SPE.
What about PyScripter?
Post a Comment

<< Home

Powered by Blogger

Attached Files

To refer to attachments on a page, use attachment:filename, as shown below in the list of files. Do NOT use the URL of the [get] link, since this is subject to change and can break easily.

You are not allowed to attach a file to this page.