Finding The Best Text Editor... For You!

Here, we’ll take a look at a few areas in which text editors distinguish themselves. For each area, we’ll mention a few ways to approach that particular aspect or problem, and highlight a particular editor or two.

“Text editors” here really refers to text editors for programmers — while there are great solutions for writers of all kind available, our focus this time is on writing and editing code. Also, while some editors mentioned are cross-platform, the perspective here is definitely Mac-centric.

Here's what we're going to cover:

1. IDE vs Text Editor
2. Native vs Web
3. Extensibility
4. Text Editing Experience

IDE vs Text Editor

Traditionally, people have made a distinction between full-featured IDEs, compared to more minimalistic, lighter text editors.” If you want more features, go for an IDE. If you want a streamlined, faster experience, go for an editor.” I don’t think this perspective is that useful today. The popular editors of today abound with features, and thanks to extensibility, they can be made to do just about anything. Developments like LSP, the Language Server Protocol, mean that programming language developers can implement smart auto-completion, navigation and refactoring support for a language once, and have it be available in any text editor that supports LSP, rather than the developers of each editor having to implement support separately for each language.

I think a better axis for comparing IDEs to text editors is how tailored the application is to a specific language. Here, we see that an editor like Sublime Text certainly can support lots of clever operations for e.g. the Python programming language. But PyCharm by JetBrains, a Python IDE, comes preconfigured to support running Python tests, debugging programs, integrating with Jupyter notebook and popular frameworks like Django, and using virtual environments for your project. PyCharm is tailored to the Python ecosystem.

Sublime Text can probably do all these things with some tweaking and a few extensions, but it’s not optimized for the Python ecosystem. On the other hand, if you also program a lot in Swift, Sublime Text will let you set it up for that as well where, in the case of PyCharm, you may be better off looking for a separate IDE for this use-case.

In some cases, the technology you’re using dictates the choice of tool: if you’re developing apps for Apple devices, Android or Windows, you’re likely to be using Xcode, Android Studio or Visual Studio respectively. These tools not only feature deep ecosystem integration, but incorporate necessary compilers and simulators which may not be available outside those tools.

As for other IDEs, Jetbrains is a big player, with full-featured IDEs for a host of different programming languages, including (but not limited to) Java, Go, PHP and Ruby. Jetbrains actually started development on the Kotlin language which superseded Java as the development language for Android applications, and the official Android IDE, Android Studio, is based on Jetbrains’ IntelliJ IDEA Java IDE.

Native vs Web

I mentioned that different things are important to different people, and this is very evident when we talk about native vs web. In short, a native text editor is built using the native frameworks for a particular operating system, and leans heavily on conventions for that platform, integrating seamlessly. Web-based editors, on the other hand, are mainly built on web technologies — HTML, CSS and JavaScript. However, being web-based doesn’t necessary mean an editor is only available through a browser — thanks to frameworks like Electron, many “desktop applications” are built like web apps under the hood. There are also editors that are neither native nor web-based, using instead some abstraction like a cross-platform GUI framework.

Native

In the “native” category, we have Textmate, which is a Mac app through and through. Released in 2006, Textmate quickly gained popularity, for example in the burgeoning Ruby and Rails development communities (perhaps in part thanks to being championed by Rails creator DHH). Textmate came with great support for dynamic snippets with placeholders, a feature picked up by many editors since.

A common thread through the history of text editors is that good ideas tend to be quickly picked up by others — see Sublime Text, a few paragraphs down, for more examples. After version one of Textmate, developer Allan Odgaard worked on version two for a long time before eventually making the application open-source in 2012, and officially releasing version two in 2019. Development of Textmate still continues.

Panic’s newly released Nova editor — the successor to their previous editor Coda — fits right in the “native” category as well. As new as it is, it’s too early to say where it will find its niche in the editor ecosystem, but in short, it brings some of the modern features pioneered by Sublime Text and VS Code in an interface that is as Mac-native as Mac-native gets — and it adds many deep features like remote file browsers and terminals. It also supports extensions written in JavaScript.

Sublime Text is an example of an editor that is neither quite native nor web-based — it uses its own cross-platform GUI framework. Available on Windows, Mac and Linux, Sublime Text is blazingly fast and introduced or popularized many concepts like a command palette, “Goto anything” and the minimap. The command palette is a feature that lets you call any command in the program by hitting a keyboard shortcut and typing in a few letters of the command name. “Goto anything” works similarly for files and symbols. Many apps have picked up these features since, including a certain Git client: Quick Actions and Quick Open in Tower let you do something very similar! Version four of Sublime Text was released in 2021.

Web

Moving on to editors based on web technology, Visual Studio Code is the star of the show. Perhaps the most popular editor for programmers today, VS Code is largely implemented in TypeScript, HTML and CSS. Extensions are also built using these technologies, and the popularity of VS Code is evidenced by the plethora of extensions available. Initially, GitHub developed the Atom editor, out of which spun the Electron framework for making desktop apps using web technologies. Subsequently, Microsoft (who would go on to acquire GitHub) developed their own Visual Studio Code editor based on this framework.

A drawback with VS Code is that, being written on top of a browser runtime, its interface is not quite as responsive as some of the native options. Out of the box, VS Code has very good support for modern web development, and through extensions and configuration, it can be made to support just about any programming language and workflow. If you’re interested in some tips and tricks for using the VS Code editor more efficiently, take a look at our two-part series on how to become more proficient with VS Code.

Taking the concept of web-based editors to the extreme, there are some quite full-featured editors that are available directly in your browser. Actually, VS Code is one of them — GitHub Codespaces (still in “early access”) brings the complete VS Code experience to GitHub. Such a development is made possible by the editor being built on web technology from the beginning.

Finally, we might mention JSFiddle and CodePen — two popular projects that give you a front-end development environment right in your browser for quick HTML, CSS and JavaScript mockups. These services let you add in popular frameworks to your projects, allowing you to easily test ideas out or demonstrate concepts. Perhaps most importantly, they give you a URL for your project which you can use to quickly share them with others, just by sending them the URL.

Extensibility

Just about any modern text editor for programmers supports some form of plugins. TextMate supports customization through bundles, and Panic Nova, Sublime Text, VS Code, the Jetbrains IDEs, Xcode, Android Studio and Visual Studio all have some kind of extension support. In VS Code, many of the core features are actually built as extensions — themselves built using web technology. So, whatever your editor of choice, the editor itself may be only a starting point. Of course, different editors differ as to the extent of customizability available.

Extensibility provides a segue to another topic I’d like to touch on — command-line editors. If you’ve heard about command-line editors such as Emacs and Vim, with their text-based user interfaces and archaic terminology, and wondered why anyone would choose to use them today, here’s an attempt at an explanation.

Let’s start with Emacs, and the topic of extensibility. Emacs is a venerable editor with roots in the 1970s. At its core, Emacs is an interpreter built in C. The language interpreted is Emacs Lisp, and much of the actual editor features of Emacs are built on top of this core using Lisp. Importantly, Emacs makes it very easy for a user to quickly write some Lisp to make Emacs do something — the boundary between customizing and actually developing your editor becomes blurry. Perhaps for this reason, there are Emacs addons for everything from email and calendars to file management, and some users do practically all of their daily computing tasks in Emacs. Instead of delegating each task to a different application with its own set of conventions and restrictions, Emacs can bring many tasks together under one, highly customizable interface.

Text Editing Experience

In the end, the main task of a text editor is to let you enter and edit text. There are some aspects to this that I’d like to go over. A responsive interface and clever keyboard shortcuts speed up editing. Dynamic snippets and support for multiple cursors may let you complete repetitive tasks with a few button presses. Editors may provide language-aware services allowing you, for example, to select the contents of an HTML tag or a block of code using a shortcut. Also, “find and replace” operating on many files simultaneously and using regular expressions and capture groups may substitute for a lot of manual editing.

Some editors take this a bit further, however. The main antagonist of Emacs in numerous ancient flame wars, Vim, is an old open-source favorite still used by many.

Vim is a so-called modal editor. When you use it, you’ll likely be in one of two modes for the most part: normal mode and insert mode. In insert mode, characters you type are entered just as in any other editor. However, in normal mode, which you’ll be using most of the time, the same characters perform operations on the text. In fact, they constitute something akin to a language for manipulating text, with verbs operating on text objects or motions. So you might type, for example, dt' to “delete up to the next instance of '”, or ]aB to “indent a block” of code, wherever in that block the cursor happens to be. There’s much more to this concept of “a language about text editing” — a couple of great resources if you want to learn more is this article and the Vimcasts videos.

Neovim is a popular fork of Vim, started in 2014. Focusing a bit less on backwards-compatibility than Vim, it instead aims to provide usable defaults and extensibility through Lua as an alternative to VimScript.

Are you intrigued by the concept of powerful primitives for text manipulation combining to form complex operations? Allow me to end this article with a mention of a personal favorite — Kakoune. Kakoune takes much inspiration from Vim, but brings a few new touches. For example, where Vim has you specifying an operation first, followed by the text that operation is supposed to work on, in Kakoune, you always make the selection first, then apply an operation.

Vim does have something similar in its visual mode, but where Kakoune shines is when it comes to multiple selections and cursors. You can easily select a block of code, trim your selection to only those characters matching (or not matching) some regular expression, and then edit each match simultaneously, with multiple cursors, using regular editing commands and seeing your results in real-time. Again, users of Sublime Text may not find this impressive, but it’s the ability to combine primitive text operations in orthogonal ways using full multi-selection support that makes Kakoune so awesome.

Final Words

This concludes our look at how to find the right text editor. Hopefully, you’ve found the article interesting! Maybe you’ve discovered a new editor to try, or some things to test out in your current editor of choice. For some programmers, trying out different text editors and configuring them in search of ever-elusive perfection is a hobby which eventually comes to overshadow the actual programming work itself in importance. If you’re inspired to take a look at a command-line editor like Emacs or Vim, the internet abounds with example configs for these editors which can be used as starting points and tweaked to your own requirements but beware — this particular rabbit hole goes deep!