My history with code editors

Here’s a quick tour of the many editors that I’ve tried. I’ve never really been the type to be loyal to a single editor. They are merely tools after all, so it would be silly to be attached to them.


Notepad, the text editor that comes with Windows, was my first editor.

For someone just starting, Notepad is great. Notepad doesn’t come with any bells or whistles, so you can focus on what’s essential: the code. It also start up instantly, even on the slowest of machines.

Notepad’s limitations become apparent once you work on a larger project. As soon as you deal with multiple files, you’ll end up having to tediously manage the files and windows yourself.

Notepad also doesn’t support Unix line endings, which is very annoying. Oddly enough, WordPad, a rich text editor that also comes with Windows, supports it. Given how long Notepad has been around, I’m still baffled as to why they haven’t fixed it.

Despite the lack of features, I still use Notepad when I want to quickly check a single file out, or perhaps write a simple script. Actually, it’s Mousepad now since that’s the text editor that comes with my current Linux distro.


Naturally (not really), after Notepad, I moved on to Notepad++. Unlike Notepad, Notepad++ is meant for code, not just text.

Notepad++ has tabs, making easier to work with multiple files. It also comes with the features that you’d expect in code editors like: line numbers on the side, syntax highlighting, the ability to fold code blocks, find and replace (with regex support).

However, despite the number of features that came with it, I eventually found it to be lacking. It did have a plug-in system, but I never explored it.


I’m grouping all the IDEs together because I feel the same way with all of them. This includes Eclipse, Netbeans, IntelliJ, Code Blocks, Visual Studio, and many others.

IDEs are supposed to enhance a developers experience by providing convenient features and integrations like auto-complete with documentation, auto-import, code analysis, go to definition, find references, debuggers, build tools, refactoring tools, and GUI builders. While these features do indeed come in handy, they come at a price: they slow the editor down. Sometimes it even causes your machine to lag due to its excessive memory usage.

Because of this, I’ve avoided using IDEs as much as I can. I usually only use them for Java projects, such as Android apps. Still, these features are genuinely useful, so if your machine can handle it fine then it shouldn’t be an issue.


If you’re not familiar with Vim, it’s an editor known for its key bindings and shortcuts. For most editors, regular key presses always insert text. For Vim, depending on the mode, they may execute commands instead.

It’s a bit difficult to explain, but those commands allow you to navigate around and make changes more efficiently by minimizing the key presses and hand movements needed. It may not be intuitive at first, but once you get used to them, they are quite handy.

Oh, Vim runs on the terminal by the way. Sometimes I think people learn Vim just to impress their friends. I wouldn’t blame them; the powerline is sexy. Too bad proportional fonts (which I prefer) don’t work well on the terminal.

Vim doesn’t come with much out of the box, so you’ll probably want to install a couple of plug-ins. Configuring stuff is a bit of a pain though. At some point I realized that it isn’t worth the hassle.

Nowadays, most of the popular editors have a plug-in for Vim key bindings. If you’re just after the key bindings, I suggest you use those plug-ins instead. They usually work well enough as long as you don’t do anything too advanced.

I still end up using Vim whenever I need to edit files from the terminal. This happens quite often when configuring Linux machines, especially servers.


Actually, I started with Spacemacs. Spacemacs is Emacs plus a bunch of packages installed out of the box. Unfortunately, Spacemacs made Emacs too slow for me.

Emacs claim to fame is its customizability. People even joke about Emacs being an operating system because you can organize your mail, chat with friends, and play games inside of it.

Then there’s org mode, which turns Emacs into a powerful note-taking organizer. Some people even use Emacs exclusively for this. That’s actually how I learned about Emacs.

In the end, my experience with Emacs was just like Vim: a not so intuitive UI with too much configuration required. It’s a bit ironic since users of those two regularly have flame wars with each other.

Sublime Text

Sublime was a pretty good editor. It wasn’t slow like an IDE, it had a friendly GUI, and also a bunch of nifty features.

The things I found nice in sublime include: the ability to quickly open files by search via Ctrl+P, multiple cursors, and the preservation of unsaved text buffers. Sublime also has a plug-in system, but I think its UI needed a more work (back then at least).

Sublime isn’t free though. They provide a free version for evaluation, which will constantly, and unexpectedly, nag you to buy it. The price, while arguably fair, is expensive compared to all the other editors available.

Development of Sublime is a bit slow too. Version 3 was in beta for more than four years. It used to be a one-man show, but they recently got another guy to help out.


Atom is the editor by the folks at GitHub. It’s designed to be very customizable, and has a great UI too. It’s mostly built on top of web technologies, which many people blame for its performance issues.

Seeing that there are IDEs built on top of it, I think it achieved its goal on being customizable. Emacs enthusiasts might violently disagree with me for saying this, but Atom is like a “modern-day” Emacs.

I didn’t use Atom so much myself because it was too slow on my old (2007) machine. It would probably run fine on my new machine though.

Visual Studio Code

Not to be confused with the IDE also called Visual Studio, Visual Studio Code is another editor by Microsoft.

What I love about VS Code is how great it works out of the box. In fact, even before they introduced extensions VS Code was already my editor of choice. Somehow they also managed to take the best features of an IDE, and packaged it into an elegant UI.

So far, it has the best UI among the editors I’ve tried, especially its find & replace and Git integration. It also has the things I like about Sublime although its fuzzy search isn’t as good. For me, they really hit the right balance on this one. It doesn’t feel bloated at all.

Like Atom, VS Code also runs on web technologies, but the performance has been much better. This also helped it become cross-platform, which is unusual for a Microsoft product.

Development is very active, with many improvements regularly being delivered. The community has also been rapidly growing.

Today, I still use VS Code. There isn’t much that I don’t like about it, so I don’t see myself switching anytime soon.

Other interesting editors

A few less popular editors have some interesting ideas, but I haven’t tried them myself (yet?).


Kilo is an editor implemented in less than 1000 lines of code. It’s a toy, but it is usable. Oh, and it’s by antirez, the guy who built Redis. Someone wrote a really cool step by step explanation of the code.


QEmacs is an editor that has a lot to offer for an editor that is so small. It’s quite astonishing, and just what you’d expect coming from Fabrice Bellard.


Zile is not an editor itself, but an editor development kit. The idea here is to build the editor of your dreams. Sounds nice, but it’s probably too much work in practice.


Textadept is a lightweight but highly customizable editor powered by Lua. I’ve used it before, but I can’t seem to remember why I didn’t stick with it.


Acme is the editor by the Plan 9 guys. It’s inspired by Wirth’s Oberon. Russ cox made an awesome video tour showcasing its unique features.


Kakoune is another modal editor like Vim, but it works on selections and claims to have a more orthogonal design. The orthogonal design thing intrigues me, and make me want to try it out some day.


Neovim is an editor that attempts to modernize Vim. I liked how they separate the front-end and back-end. This allows others to build different UIs for it while still leveraging the Neovim engine.

Tags: #programming