I’m not easily persuaded to try out a new editor, but since I heard so many
great things about Sublime Text, I decided to
give it a try. After all, it looked a lot better and smoother than my old and
rusty Vim, and I’m a sucker for look & feel. So, I took the free courses on tuts+, and tried it out for a while
on my daily tasks. Here are my findings.
Let’s start with the pros:
- Sublime is cross-platform. I wouldn’t even consider using any editor that
only works on one platform, so this one was a must.
- Not only does Sublime work on each platform, it looks and feels awesome
on all of them. Very smooth, responsive, and appealing to the eye.
- One of the distinctive features is support for multiple cursors: You can make the
same change to different parts of the
text by simply selecting different parts, and starting to type, and you see the
changes happening live. This is very
handy for refactoring, such as renaming a variable.
- The command palette makes it very easy to do any operation you can’t be bothered
to remember the shortcut for. Simply open the command palette, type a few letters,
and Sublime will use fuzzy searching to suggest the command/option. Almost as good
as remembering a shortuct.
- Every operation and option is available from the intuitively laid out menu.
Not that you use the menu a lot (or even at all, thanks to the command palette), but
it’s great for looking around and learning all the things you can do with the editor.
- You can quickly open files and jump to specific symbols using the Go to anything
popup. I was already using this exclusively to open files on Vim through
ctrlp, but Sublime
adds support for symbols and lines to this interface as well, which can come in
- You can trigger builds of your project while editing files, see the results, and
quickly cycle through build errors. This integration is very well done, much smoother
than in Vim for example.
- You can use Vim commands to move around and edit text, which is obviously
nice if you’re used to those already, and means you can do lightning fast edits.
- Of course, there are lots of useful operations on text, with sensible keybindings
- Sublime is extensible, using a Python-based plugin system. There seems to be
a very large and dedicated community, writing plugins for it, which means you’ll
most certainly find all the integrations and features you want on the web.
Unfortunately, there are also some cons:
- Although Sublime is cross-platform, it seems to not have been designed for the
user who actually uses it on different platforms. For example, the key-bindings
differ from platform to platform, more than merely Cmd becoming Ctrl.
This is probably rooted in Sublime’s decision to use
shortcuts that are native to the platform. Remembering different shortcuts for
different platforms is a nuisance, and causes regular incorrectly typed
shortcuts when switching a lot.
- Settings are stored in fixed, platform-specific locations. Again, this is because
Sublime chose to integrate with the OS as much as possible. However, this makes
it hard to store your settings in a central Git repository, and share it across
different machines and OSes.
- Sublime uses JSON as settings format. Although that sounds sensible, it actually
has a big disadvantage: each line of your settings needs to end with a comma, except
for the last line. This hit me almost every time I wanted to customize something.
Another consequence of using JSON is that the settings file isn’t very powerful:
since it’s basically just key/value pairs, you can’t do anything conditional
(e.g. depending on which machine you are on), or source other files.
- There is no console version available. I regularly need to edit files on remote
systems where I only have a terminal available. In that case, I need to switch back to
- And then the obvious one: Sublime is closed source, and not cheap. I don’t
have anything against closed software per se, and I’d gladly pay the
(relatively steep) price of the editor if I’m going to use it all day, every day.
However, I have some practical problems: the systems I work on every day can’t run
Sublime, since it is linked against older libraries than the ones I have available.
Since I can’t recompile Sublime myself to link against the older libraries, it ends
there. And then there’s the fact
that I don’t like the idea of my editor’s life depending on one person’s focus and
ability to avoid being hit by a bus. If the project dies, maybe someone will create
a clone to support the current userbase, but I still consider it a risk.
I only tried Sublime Text 2, but since these issues are pretty fundamental, I
don’t think they will have been addressed in the upcoming version. Since I had
an uneasy feeling about these things, and was regularly hitting the issues over and
over again, I finally decided to go back to Vim. However, I think Sublime Text
is a great editor, and is probably the closest an editor will ever get to being
a Vim alternative I find worth considering.