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
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
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
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
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
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
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
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
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
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
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
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
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
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
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.
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
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
You should follow us on Identi.ca or Twitter