From the archives: the best text editors of 2000
War. In our world, people get into conflicts about all sorts of matters, from religion and belief through to money and oil. And, in the Linux world, tensions can build up and overspill into flame wars on many subjects too. The most popular of these is text editors - yes, the KDE vs GNOME and GPL vs BSD arguments rage on, but the infamous combat between Emacs and Vi predates most arguments you'll see, and is just as heated today.
Nine years ago, Linux Format magazine printed a group test of the best text editors. We sent a red-shirted colleague down - deep below LXF Towers, way under the execute gym complex, far beneath Nick Veitch's cave, and down on into the archives - where we dug up that group test just for you. So, if you've already read the best distros of 2000 and the best window managers of 2000, read on for more historical Linux goodness...
One of the biggest changes over the last nine years has been the perception of bloat. Back in 2000, (X)Emacs was sometimes regarded as the king of bloatware - many users joked that it was an operating system that just so happened to include a text editor. In today's world of gigabytes of RAM and GHz of CPU power, Emacs looks like a tiny little program.
Also, in 2000 Linux was very much the realm of geeks and server admins, so the focus on text editors was features rather than hand-holding wizards and other user-friendly gizmos. Today the range of text editors is much wider, with every major desktop environment sporting its own program.
Unless you've only been with Linux for the past few days, chances are you'll have encountered a text editor at some point or another. From doing a quick hack on a configuration file through to writing thousands of lines of C code, at some point you'll have relied on an editor to get the job done. Of course, masses of other tasks like writing emails and jotting down ideas also depend on a sold editor which won't let you down.
As with almost everything you can find on Linux and the other free UNIX systems, there's a superabundance of editors for every need under the sun. Huge, feature-packed applications, small and fast tools, and specialised programs for a particular purpose; there should be something available free of charge to suit your requirements.
Of course, there are certain properties of any editor that we all want, such as reliability and reasonable performance. There's no point in having a program that's choking with incredible features if it eats up half of your memory and falls to pieces whenever the going's remotely less than smooth.
As discussed above, Emacs and Vi are both enormously popular and have legions of fans who would support them to the death. Both editors have long histories and considerable development time behind them, and have spawned new versions of themselves, each with slightly different aims. Both are included with just about every Linux distribution on the planet, and have their relevant newsgroups and mailing lists.
One of the reasons users become so passionate about particular editors is because of the frequency of their use. Unlike, say, an MP3 player which you just flip on and leave to go, or an IRC chat client which you may only use for half an hour each day, a text editor will be constantly in use and must be designed to fit this. Fancy features should be kept tucked away unless needed, and the user should have instant access to common commands instead of trawling through menus or tapping in endless key-combinations.
Kernel hackers and other programmers often spend several hours gazing at the screen, and the appearance has to respect this. Flashing distractions or pointless effects would be roaringly annoying in this respect - the program itself should become transparent, and let the user focus on the main matter in hand: the text.
Other features that would are hugely valuable to programmers include code formatting and syntax highlighting, which enhances the text's structural appearance and stops it all melting together into a meaningless mess after 16 hours of fine-tuning an algorithm.
In a similar vein, the portability of a text editor is significant too. If you work on a number of platforms other than Linux, like Windows and the BSD variants, you'll want your favourite editor to be available in some form or another to free yourself of another potential learning process and make switching around considerably easier.
In this roundup, we put a collection of the most popular Linux text editors under the spotlight, discussing the issues mentioned above and examining how well they suit the job they're designed for. We're looking at a variety of editors here, from tiny text-mode utilities through to colossal X-based applications with all the bells and whistles you could ever imagine.
Check out the comp.editors newsgroup for discussion and help with all things editor-related.
GNU Emacs 20.6 - http://www.gnu.org/software/emacs
There's no question about it - Emacs is definitely the most widely-known and famous text editor in our entire roundup. It's well-known for a number of reasons, and not all of them positive (think of the expansion for the acronym that Vi fans jocularly use: "Eight Megabytes And Constantly Swapping"). Of course, it's prominent for its vast range of features too.
Emacs was born in MIT (the Massachussetts Institute of Technology) way back in the early 1970s, where developers were using the ITS operating system to run TECO, the most popular text editor available. TECO was favoured by many because of its built-in programming language - developers could add new sequences of commands, known as macros, thus making the editor very powerful and extensible.
Richard M. Stallman, commonly known thesedays as RMS, was working at MIT at the time and set about bringing the best aspects of the various macro sets together, and working on them to produce the most usable TECO system he could. He named these "Editor Macros", which compressed into the snappier title of "Emacs".
Of course, Stallman himself is celebrated for starting the Free Software Foundation and the GNU project, much of which is still alive and kicking in Linux distributions today. Along with compilers and libraries, it was essential that the GNU project had its own text editor, and work started on GNU Emacs, with the main core written in C, and an implementation of the Lisp language used to enhance the program.
GNU Emacs is freely downloadable from the GNU site, and is released under the GPL license. Virtually all Linux CDs include it too, so you won't have trouble getting your hands on a copy. Package sizes are pretty hefty, though, with typical RPM packages weighing-in at around 6 MB. For typical distributions, there's a base 'emacs' package, along with 'emacs-nox' for plain-text console usage, and 'emacs-X11' for those who need to run it under the X Window System too.
The X front-end to Emacs, showing two open buffers with documents loaded in each.
Fortunately, though, the packages aren't dependent on anything unusual, with the X-based version avoiding the popular Gtk and Qt toolkits and using plain Xlib instead. The text version typically uses ncurses for screen drawing, and will work with GPM mouse support at the console if you have it enabled. Installation is totally straightforward, and once the packages are extracted you can get straight to work.
The default screen layout of GNU Emacs consists of a menu bar along the top of the display, with a status bar at the bottom. There's a small gap below that, which is the place for entering information like search queries and filenames. Unless you specified a filename when starting the program, you're presented with a page of help text and release information, which is a nice touch and worlds apart from the terse startup of Vi.
Emacs doesn't use modes (i.e. text-entry mode, command mode) like Vi, but accepts key combinations using the Meta button to perform specific operations. The Meta key is usually mapped to ALT on modern systems, and CTRL plays an equally important role here too. Basic tasks like saving are achieved with CTRL+X then CTRL+S, and CTRL+X then CTRL+C respectively. Emacs users would write the latter of these combinations as C-x C-c, as an example.
You'll find all the usual features like search and replace, multiple levels of undo and other text-editing functions in Emacs. The display can show a number of buffers (text holders, which can be files or just scraps) on the same screen, and the status bar keeps you informed of your location in the file and whether it has been modified or not.
Got a problem? The Emacs psychotherapist will talk you back to happyville.
But Emacs really comes to life through it's Lisp-like extension language, which enables it to run completely different applications. Examples of these include Gnus (a highly configurable and comprehensive email and news client), Emacs/W3 (a powerful Web browser with support for CSS and frames), and many more.
In all, Emacs is a mighty, enormously-capable editor with just about every feature you could need. The elisp language adds further to this - allowing coders to make a huge variety of additions - and it's very solid in use too. Of course, the downside to all this functionality is the performance, and Emacs can go heavy on the memory at times.
Overall: 9/10 - Immensely capable with some fantastic features, but can be heavy on system resources.
PICO 3.7 - http://www.washington.edu/pine
While some editors (like the Emacs and Vim releases both tested in this roundup) try to cover all bases and be capable of doing most things the user would want, others are heading for a different goal of speed over size, and simple usability over complex features and commands. Of course, this makes it less powerful - but in some cases more useful - than the big boys.
PICO is one such editor, and the name is derived from "Pine Composer". PICO is part of the Pine messaging application, which is one of the most popular and useful text-mode email clients around. PICO is typically used in Pine for creating and responding to messages, although it can be used straight from the console to run on its own. The editor needs the ncurses library, and will use GPM or the X pointer if available.
The screen layout of PICO is made up of a status bar at the top, together with a double-line section of help for the command keys at the bottom. These list the basic operations of saving, cutting text and inserting files. The status bar says very little apart from the modified status of the current file, and it would have been nice to see a line-number indicator there.
PICO being used in the Pine mail client to compose a message.
Commands in the editor are entered using the CTRL key plus one of the letters, as listed at the bottom. When cutting text, PICO simply removes the line that the cursor is sitting on, and stores it to be undeleted if necessary. This can cope with a sizeable amount if text, despite its simplicity of use, and overall the editor is a sinch to work with.
Obviously, PICO doesn't have anywhere near the amount of features you'd expect with larger packages like Emacs. Yet it's still a worthwhile tool for doing a quick hack on a config file, and because of its Pine origins its solid as a rock too. Have a look if you want something tiny and speedy without any extra trimmings.
Overall: 7/10 - No notable features, but still lightweight and reliable.
KWrite 1.0.0 - http://www.kde.org
Any complete desktop environment needs a suitable text editor which fits in with the rest of the suite and is always at hand. The Qt-based KDE project started off with the simple KEdit in their early releases, and with the upcoming version 2.0 they have a more advanced tool in the shape of KWrite, which includes new features for normal users and programmers alike.
The KWrite on test here is from the a beta release of KDE 2, as the developers are still working on the code and cleaning out bugs before making the final release which is due any time now. Consequently, you'll need the usual kdebase and kdelibs packages to get KWrite up and running, along with version 2.1.1 of the Qt toolkit library.
KWrite's interface is neat and intuitive, with clean and obvious icons and a status bar along the bottom. The icons are linked to the usual processes of opening and saving files, undo and redo, and cut-and-paste, while the status bar holds information on the line and column number, whether the editor is in insert or overwrite mode, and the file's modified status.
KWrite in action. The toolbar along the top is detachable.
A point worthy of particular note is the level of configurability, which is especially thorough in aspects of text-selection, while the colours for syntax highlighting can be redefined. This feature extends to a wide range of languages, including C/C++, HTML and Perl.
At the time of writing, KWrite is shaping up to be a good all-rounder for the KDE desktop suite. It has some pleasant features, but doesn't go overboard and still starts-up and runs pretty rapidly. The syntax-highlighting in particular will be valuable to programmers and Web site designers. We had a few problems with stability, but these should be ironed-out for the final release.
Overall: 7/10 - A competent and friendly general-purpose editor for KDE.
Vim 5.6 - http://www.vim.org
Along with Emacs, Vi is one of the two major text editors that divide Linux users and cause constant wars. Vi is a very different editor, though, and the differences in design philosophy and implementation of common features make up the fuel that powers the flamefest. Also like Emacs, Vi has spawned a number of clones, with the most popular being Vim which we're looking at here.
Vi has a long history behind it. The early text editors, available to users before proper monitors had been developed, were line-oriented and worked with a single line of text at a time. The 'ed' tool, included on most distribution CDs, works in a similar fashion, with the user dealing with single lines from a file rather than the whole text.
This is how Vi actually started off, as the line editor 'ex'. In fact, ex mode is still available in Vi today, even though the 'vi' visual mode is almost invariably preferred. The original version was developed at the University of California at Berkely by William Joy, and was originally supplied as an unsupported utility, before being officially included in AT&T System V UNIX.
Vim in plain text mode, demonstrating the syntax-highlighting on a C source file.
As the editor has grown in popularity with both programmers and system administrators, a multitude of clones has emerged with slightly different aims, including Elvis, Vile and and the Viper mode in Emacs. Many versions have been ported to a staggering amount of platforms, from the usual UNIX and Windows flavours through to VMS and BeOS. Vim's main goal is simply to improve the original Vi with new features, while keeping it fast and stable.
One version of Vi or another is included with almost every UNIX package on the planet, and with Linux distributions this tends to be Vim. The widespread use of Vi plays heavily in its favour, as we note later on. You'll need the vim-common package, which is approximately 1 MB, along with vim-enhanced at 900k if you want to take advantage of some smart features, and possibly vim-X11 at around 900k to use it under X.
Installation is completely straightforward as there are very few major library dependencies, which helps it to run in almost any circumstances (and again, this is a major plus point for several reasons). The vim-X11 package includes gVim, a Gtk-based version of the editor, so you'll need that toolkit installed if you plan to run it under X.
Vim's default appearance, depending on how it's invoked, is petrifyingly minimal and terse at first. If you've started it without specifying a file to load, you're presented with amount of help on getting started and how to quit the program. On the other hand, if you've loaded a text document, you'll see the file's contents with a single status line along the bottom, containing the filename, number of lines and characters, cursor position, and the percentage of the file still to be viewed.
gVim is a Gtk-based front end to the editor.
This total lack of frills may initially seem like a negative point, but it's designed to be completely undistracting and not show anything you don't really need to see. The layout lets you see as much of the text as possible, and becomes second-nature after a few days of use.
Vim's two main modes are "command-mode" and "insert-mode", and affect the way the program responds to keypresses. In command-mode, you can move around the text, delete lines and enter sequences of commands. These start with a ":" character, and when pressed you're given a prompt to type in several commands (such as ":wq" to write the file to disk and then quit).
Perhaps the most important feature of all, though, is the "macro" support that Vim sports. These allow you to replace longer commands, text strings and other things typed-in with smaller sequences of keystrokes - so, instead of typing "Linux Format" into your work, you could enter "lxf" and it would be expanded instead. Also, longer and more complicated commands can be replaced by shorter and quicker-to-type ones.
Some of the features that Vim offers over the original Vi include syntax highlighting, where colours are applied to specific programming language keywords, multi-level undo for stepping back through the changes you've made, and command completion (much like in the Bash shell). Many other additions and extras are included too, and Vim supplies a comprehensive file detailing the changes.
Vim, and the operation of Vi in general, is certainly not straightforward to get started with, and you'll probably either love or hate the way it works. However, once you become familiar with it, you'll enjoy the speed, stability and uncluttered interface. As versions of Vi are installed on almost every UNIX box, it's worth learning as you'll virtually always have it available, even when the going gets rough.
Overall: 9/10 - Tricky to begin with, but fast, clean and extremely powerful.
Jed 0.99.10 - http://space.mit.edu/~davis/jed.html
With the history of Linux and the GNU project being essentially a tale of hackers around the world contributing code in their spare time, it's no surprise to see that a number of text editors aimed at programmers have appeared. Coders often have very different needs to typical users, and while programs like Emacs attempt to satisfy this, sometimes it's best to have a single program with a clear focus.
Jed is just that, and above all else it aims to be a programmer's editor. Like Emacs and Vim, it can be run at the plain text console, or under the X Window System. The main package you'll need is jed-common, which is about 600k and provides the support files, along with jed itself for the main program binary and jed-xjed for X support. The program requires the Slang library, but apart from that, it's simple to install.
In terms of the interface, Jed initially resembles Emacs, with a menu bar at the top, a status bar sitting near the bottom, and a prompt underneath. It's slightly more helpful than Emacs, though, with an indication of the menu key which displays colourful, drop-down menus that you can navigate with the cursor keys. The menus also show the shortcuts for each function, which are also similar to Emacs in the default setup.
Jed working on a Perl script, and showing the drop-down menu.
Jed sports impressive syntax highlighting for C, Fortran and TeX. A few other languages would be even better, but as it stands it does a good job with the few it supports. The program is extensible to a large degree through the Slang language, which provides the alternative emulations of WordStar and Brief, along with the standard Emacs mode.
Undoubtedly, Jed is one of the fastest text editors on test here, and its small size helps it on the memory footprint front too. The syntax highlighting has been well-implemented, and emulation of Emacs' behaviour is a bonus point for those wishing to move over.
Overall: 8/10 - Fairly small and rapid, with a few great features.
gEdit 0.6.1 - http://gedit.pn.org
As with the KDE desktop project, the developers behind GNOME realised that a small and fast text editor would be essential for their environment. Several groups of hackers have been working on such an editor, with gEdit has becoming one of the most popular, and it's released under the GPL license.
Depending on the type of package you download, you may need the GNOME libraries for gEdit to work properly. The program will stand as a Gtk-based editor in its own right, and you'll definitely need the relevant libraries for that toolkit. Most distributions install the editor as part of GNOME, so it's available on many systems.
gEdit has an appearance similar to KWrite, with a row of crisp icons on a detachable toolbar along the top of the screen, and a status bar at the bottom. One of the most pleasant features of the design is the tabbed display of multiple files, where each open document has its own tab, making it easier and quicker to switch.
The three open files are represented by three tabs below the toolbar.
The editor can be extended by use of plugins, which add extra tools and capabilities like word counts etc. Most of the typical functions of cutting and pasting, undo and redo etc. are supported, but there's little that's an immediate surprise. The configuration box is rather sparse and only includes the obligatory font style and a few other general options, and there's no syntax highlighting.
Still, it's usable as a general GNOME editor for basic tasks, and the plugin support could improve the feature set. The omission of a line counter in the status bar is annoying though, and because of the nature of the GtkText widget, undoing changes to the document and pasting isn't always spot-on. It performs quite well, though, and with some work it could have a nice home in GNOME.
Overall: 6/10 - Usable, but with little to make it a major recommendation yet.
XEmacs 21.1.9 - http://www.xemacs.org
With GNU Emacs being released under the GPL license and the source freely available for anyone to modify, it's not surprising to see that variants have sprung up. The most popular of these is XEmacs, which originally started life in 1991 as a development of Lucid Inc. to produce a C++ development environment with extra additions over the original. In 1994, Lucid partnered with Sun and changed the name to XEmacs.
XEmacs is a huge download, with the main base package reaching around 12 MB. You'll definitely need to have this installed, as it provides the foundations of the application. Then, depending on your need to run it under X or at the console, you should choose between the 'xemacs-X11' and 'xemacs-noX' packages too. There's also an 'xemacs-extras' package, which contains files used by both XEmacs and GNU Emacs, so install this if you haven't got the GNU version on your system.
The most noticeable differences between XEmacs and the GNU releases is that under X, the former has a far more graphical appearance, with a row of icons along the top of the screen, and generous use of colours. At the text console, the visual enhancements are not so apparent, but the extra functionality and features are really the best part of XEmacs.
XEmacs busy at work, showing the syntax-highlighting on C file.
With syntax-highlighting for a number of languages, along with an increased number of elisp packages in the main distribution, XEmacs might be worth checking out if you want more from the original version. The developers have tried to retain compatibility with the GNU releases, and this has worked to a reasonable extent. You can run the Gnus and Emacs/W3 packages with XEmacs too.
Like the original Emacs, XEmacs suffers from the problem of bloat and being hungry on memory. The power and versatility of the program clearly ranks it as one of the most capable editors available, but on older hardware it can be sluggish to work with.
Overall: 9/10 - Powerful and extensible, but huge and memory-munching too.
NEdit 5.1 - http://nedit.org
With much of the free software community joining together to help Linux newcomers from other operating systems move across, it's no surprise to see the same happening in the field of text editors. NEdit is a program designed to bring a familiar text-editing environment to Windows and MacOS users, while providing keyboard shortcuts for users of text-based programs too.
NEdit is a very small download at just under 300k, and is straightforward to install, apart from one thing - you'll need to have the Lesstif libraries on your system if the package was built to use Motif, the graphical toolkit used in applications like Netscape. This should be on your distro CD, and is also available on the Web.
In the field of appearance, NEdit is plain and clean, without any icons or toolbars to act as distractions. The main menu bar provides links to the usual operations of cutting, pasting, searching and replacing, along with the ability to execute shell commands and pipe the results into the file you're working on. A status line can be displayed below the menu, which gives indications of the line number and file size.
NEdit's interface is hardly eye-candy, but it does the job well enough.
NEdit features a comprehensive set of configuration menus, with dialog boxes for altering the tab settings and font, and submenus for enabling the syntax-highlighting and language mode. This includes an impressive range, with the usual C and Pascal complemented by Makefiles and native NEdit macro files support.
As a no-nonsense text editor, NEdit does the job well and in our tests it proved to be fast and reliable. While it's not close to providing the same number of features of software like Emacs, it has enough to satisfy most tasks and is well worth checking out.
Overall: 8/10 - Plain to look at, but undistracting and great to use.
Joe 2.8 - ftp://ftp.std.com/src/editors
Many editors we've tested in this roundup have demonstrated their ability to act like others, in an attempt to ease the move across from an alternative program. Emulation of another tool, at its most basic form, involves creating a similar visual style and responding to the same combinations of keypresses. One of Joe's goals is to behave like many other editors, while keeping unique features of it's own.
The name Joe itself is short for "Joe's Own Editor", and is named after the author, Joseph H. Allen. It's supplied in a tiny package at 115k, and you'll need the ncurses library to install it. In fact, there are several executable files in the package, which let you invoke the editor with a different name to start the alternative emulations.
When called with 'jpico', for example, the program starts with a similar layout to PICO (also covered in this roundup). Other imitations include 'jstar' for a WordStar lookalike and 'jmacs' to use the editor with Emacs-style keypresses. These emulations are one of the best features of the program, and help to make life easy when you haven't got one of the real versions around.
Joe's configuration options are passed at the command-line, and include switches for cursor behaviour and setting word wrap. The editor itself performs extremely well and was reliable throughout the time we used it, which is good to see. Also of note is the documentation - while only a single man page is supplied, it's detailed, thorough and well-written.
If you're used to the behaviour of Emacs or the others mentioned, but don't have space to install them or they're simply not available, Joe makes a good replacement and does a top job of emulating them. Its size and speed also add to its plus points.
Overall: 7/10 - Ultra fast with some great emulation styles - take a look.
e93 1.3r2 - http://www.e93.org
As you might have guessed, the name "e93" is derived from the year in which the program started development. This length of time isn't unusual with text editors for UNIX-like systems - Vi and Emacs have been around for decades now. One of e93's main focus is to be portable to other platforms while being highly configurable at the same time.
We grabbed the source package, at 320k, and compiled it. The process is simple and doesn't even require a ./configure script to be run. However, you need to have recent versions of the Tcl/Tk languages and toolkits on your machine, as they form the front-end of the editor itself. Aside from those, the program is not reliant on a anything else you won't have.
e93 follows the NeXT principles of GUI design (see the AfterStep and Window Maker window managers), so you're presented with a main text-entry window and a vertical menu in another window by itself. Initially this setup can seem unusable, but it works well and saves on screen space. The document windows themselves have just a status bar, which holds the cursor position and file length information.
e93 includes a number of colour schemes, and user-configurable syntax-highlighting.
A number of colour schemes have been included, ranging from the black-on-white "Visual Studio" through to the grey shades of "NEdit". e93 has several menu items for adding and stripping line-termination characters, which is invaluable for those working with UNIX, DOS and Mac text files. Syntax-highlighting is also available for a few languages, including Tcl and HTML, and fortunately these are user-configurable.
e93 is an interesting program with some unique features, such as the interface design and ability to select text in columns rather than lines. It's not particularly attractive, but the development effort has been on its features and it stands out well in that respect.
Overall: 7/10 - Some interesting features, and a good and robust performer.
The text editors that we examined in this month's roundup have clearly proved one thing: that big isn't always best. At first it might seem preferable to have an editor which is capable of doing everything you need, with all the tools and features you require easily at hand. This is what some editors, notable Emacs and its variant, have set out to achieve, and have done so with remarkable success.
However, firing up a large and complex application just to modify a few characters of a configuration file can seem like overkill, and this is where some of the smaller tools come in. Programs like PICO and Joe are much quicker to start up for small editing jobs, and consequently they're worth having around on the system.
Also, their near-negligible size makes them handy for running on older systems. Running Emacs on that old 386 box with 8 megs of RAM in the cupboard will just lead to plenty of memory being munched up and the swap space having the busiest time of its life. The trade-off between features and running speed is clearly apparent, and on less-powerful hardware you need to make a careful decision based on your exact requirements.
Still, the capabilities of larger editors are hard to beat, with the elisp language in Emacs and XEmacs leading to some fantastic results, such as the Gnus messaging suite and the W3 browser. Similarly, while Vim isn't capable of being extended to the same degree, its macro capability gives it great potential and lets users develop fast working techniques.
The Emacs vs Vi debates will continue for many years to come. We did a quick poll in the Linux Format forum on our site (http://www.linuxformat.com), with the majority of responses being in favour of Vi over Emacs. A few other posters said that PICO was their editor of choice, while gEdit got a quick mention as well. Of course, even our beloved forum wasn't immune to some arguments breaking out here and there...
For newcomers to Linux, it's fair to say that Vim should be avoided for the time being until you've got the hang of the system in general. Vim's interface is alarmingly minimal when first encountered, and can be off-putting. At the same time, the sheer complexity of Emacs can be equally daunting too, and for a first-time user the simple operation of PICO or KWrite would make for an easier step into the Linux world.
Developers are well-catered for too, with Vim and Jed's superb syntax highlighting complemented by the sheer power of Emacs and its cousin. Coders will find all the tools they need for marking points in files, formatting code and performing compilations and file-management tasks from inside the editor itself.
In all, the situation on Linux and the other free flavours of UNIX is very positive on the text editor front, and it will continue to improve. Much of the focus is switching towards graphical editors for use in the popular desktop suites and integrated development environments, but just about every type of user can find a decent editor for their specific needs.
As always, http://freshmeat.net is the place to be for text editors.
We tested the text editors on a 32 MB 233 MHz PC running Linux-Mandrake 6.1, with a 14" monitor and 4 MB S3 Virge graphics card. Note: the package sizes and memory usage statistics below should only be used as a rough guide. Memory usage varies from system to system, and is affected by the program's configuration etc.
Requires: ncurses (text mode)
Package size: 6 MB
Memory usage: 6 MB
Configurability: Very high
Package size: In Pine
Memory usage: 760k
Configurability: Very low
Requires: KDE2, Qt2
Package size: In kdebase
Memory usage: 5 MB
Ease-of-use: Very easy
Package size: 2 MB
Memory usage: 1 MB
Package size: 600k
Memory usage: 1.2 MB
Requires: Gtk, GNOME
Package size: 194k
Memory usage: 3.5 MB
Ease-of-use: Very easy
Requires: ncurses (text mode)
Package size: 12 MB
Memory usage: 7 MB
Configurability: Very high
Package size: 300k
Memory usage: 3.3 MB
Package size: 115k
Memory usage: 900k
Package size: 320k
Memory usage: 3 MB
First published in Linux Format magazine