Hacker News new | past | comments | ask | show | jobs | submit login
TextMate 2.0 (github.com)
400 points by jjuliano 38 days ago | hide | past | web | favorite | 181 comments

Great to hear and congratulations to the team. Amazing persistence. I used to be a huge Textmate fan - it was so revolutionary in its time. Unfortunately, I think it is too late. The Google Trends comparison of Textmate, Sublime Text and VS Code tells the story: https://trends.google.com/trends/explore?date=all&geo=US&q=%...

When I was starting with vim, I was searching for 'vim [something]' a lot, from plugins to configurations, trying to improve the experience. I have since switched back to Atom and now to VSCode.

I don't search 'vscode [something]' nearly as much. Most of the configuration options are explained in the interface (both the visual one and `settings.json`). I can find plugins right from the editor and that usually also includes essential information about working with the plugin.

I still use barebones vim for commit messages, and I still find myself looking for how to trigger the spelling suggestions. I never seem to recall the `z=` when I need it.

Just because something is less user-friendly and requires more knowledge or looking for help, it doesn't mean it's more popular.

The Stack Overflow developer survey is probably a more representative sample: https://insights.stackoverflow.com/survey/2019#technology-_-....

That may indicate users googling how to exit vim.

Some are still stuck up to this day.

Funny, because it's true.

There. Fixed even more: https://trends.google.com/trends/explore?date=all&geo=US&q=%... . And if we take into consideration various versions of how to spell (for example vscode), Visual Studio code dominates even more.

Let's include something more standard for comparison.


I can now announce that this is the best HN discussion of 2019.

Don’t forget emacs of course: https://trends.google.com/trends/explore?date=all&geo=US&q=%...

Looks like Emas used to rule the roost but then died away. What really piques my interest is why those of us in Wyoming (and the Dakota’s and Alaska) and apparently love Vim:


Because vim is great for cowboy coding? (I've been using vim for decades)

Emacs takes a fair bit of commitment in time and practice to use it well. In these days of 40 hour work weeks, and life long beginner stage programmers. You won't be seeing its usage grow.

I'd even go to an extent and say vim trends show supply of intermediate level programmers. Emacs trends show supply of expert programmers. The fact that those trends are in a downward direction tells a story in itself.

Absolute numbers could be up, even if relative share is down. Intel reported growth in fortran compiler sales, but python does grow more, so relative numbers are what you expect.

That may indicate vim users googling for how-to guides.

I think the relevance of these graphs is quite limited by Google's UI (which doesn't allow for wildcarding nor combining results)

See for example: https://trends.google.com/trends/explore?date=all&geo=US&q=%...

It’s possible that native graphical editors will increase in popularity at some point. There’s probably a niche of people who don’t like the potentially poor performance of Electron-based editors but don’t want to learn (or find that they dislike) terminal-based editors like Vim and Emacs. Who knows? Google Trends isn’t an accurate way to tell the popularity of programming languages either.

Sublime Text, is native, isn't?

Sure, much of the API and all the plugin stuff is in Python, but the core is all native C++ AFAIK.

Its native but cross platform so many Mac purists don’t consider it as “native” as TextMate, which is built specifically for the Mac and doesn't compromise on standard Mac UI idioms.

Having said that, if they had known all the modern alternatives were going to be even less “native” amd run in a browser engine, they'd probably have been less nitpicky.

Eh, as a macOS user until recently, I found Sublime Text to be a very integrated application. Appearance and behavior was exactly as I'd expect from modern macOS applications.

It may not be heavy on archaic Mac features such as AppleScript integration, but I hope we can all agree to ignore those technologies.

TextMate just brings memories of the 10.4 Tiger days.

TextMate never had AppleScript integration, AFAIK.

Also, I'm not convinced we should ignore those "archaic" technologies, at least in the abstract. Applications can provide "dictionaries" of commands that, when implemented well, provide GUI applications with the kind of "snap together for amazing effect" you get with shell scripts and a host of well-written CLI tools. You arguably can't script the AppleScript-intensive BBEdit to the same level that you could, say, Emacs or Vim, but imagine the possibilities of a suite of apps from different makers that all had complete scripting dictionaries that could all be woven together with a deep system-wide scripting language.

I actually think it's a shame that AppleScript has been kicked to the curb. I don't think we have a "modern" replacement yet -- certainly not in the Apple ecosystem, and I'm not sure anywhere else. (Shortcuts on iOS is trying, but it's not on the Mac yet, and it gets pretty clunky if you start doing overly complicated automation bits with it.)

AppleScript is a great idea in how everything is scriptable.

Unfortunately, the language itself is a horrible abomination from the wild 1990s days of Mac OS... sorry, now macOS... and writing absolutely anything in it is painful.

I feel like Apple introduced Automator to overcome the pain of AppleScript, but it never really caught on (I don't even know if Automator is still on macOS.... yep it is, still with the cute Aquaesque icon)

Nowadays everything is Electron anyway and those are not that well AppleScript-able, but what to do, that's life

"AppleScript" can do JS now, but it's so clunky and badly documented that it's barely worth it.

JXA, like Scripting Bridge before it, was shipped crippled and buggy and abandoned once it was out the door. Apple finally disbanded the Mac Automation team and fired the PM responsible a couple years ago.

In fact, there are several production-tested Apple event bridges that totally wipe the floor with Apple’s failed attempts, but caveat emptor as I don’t do support:

http://appscript.sourceforge.net https://www.npmjs.com/package/nodeautomation https://hhas.bitbucket.io/welcome.html

We’ll see what happens when Shortcuts lands in 10.16, but I’d say the chances of Apple event automation having a long and healthy life ahead are 50/50, at best.

I think AppleScript and Automator is/will be deprecated and the replacement would be Shortcuts present on iOS.

I think the main developer of AppleScript left Apple last year.

I think I read something on these lines on HN, I may be remembering things slightly wrong

The language itself is pretty bonkers, to be sure. I think the Amiga probably did this better with ARexx, simply because Rexx was much better for "friendly scripting language." I was going to say I'd made my peace with AppleScript, but it'd be more honest to say "I've gotten better at beating AppleScript into submission."

iOS Workflow/Shortcuts is what Automator should have been in a lot of ways. If Automator was superseded by a macOS version of Shortcuts, I'd actually love it, as long as it didn't lose any of Automator's functionality. (All they'd really need to do is add Shortcuts that run AppleScripts and shell scripts, I think, and be able to use automator actions exposed by applications.)

Expect Shortcuts to land in 10.16. Most of the plumbing’s already in 10.15; it’s just not public yet.


I love Applescript. Not necessarily the language but what you can do with it is great. It's one thing that's keeping me on Mac--there's no Windows equivalent, much less a Linux equivalent. You can kind of hack stuff with Autohotkey but that's not the same thing at all.

>Eh, as a macOS user until recently, I found Sublime Text to be a very integrated application. Appearance and behavior was exactly as I'd expect from modern macOS applications.

Compare the file browsers and find dialogs and the difference is night and day.

Yes! Sublime Text certainly has the functionality, but the search/replace UX is a big part of what keeps me going back to BBEdit for technical writing.

Right. I’m referring to 5 to 7 years ago when Sublime 2 was still young.

I personally liked ST2 but I know that some people held their nose.

TextMate is native and modern.

Depends on what you mean by "native". The core is compiled to a native binary. But it doesn't use macOS native text editing or UI idioms beyond the level of windows and menus. If you don't want to use TextMate, you might as well use Visual Studio Code instead, which is closer in spirit to the native Mac idioms and is easier to configure.

I'm not well versed on the specific implementation details of ST, but whatever the ST team does on macOS yields a result that is much closer to a native application than VSCode does through embedded Chromium. The difference in text rendering is particularly noticeable on a non-hidpi display.

Sublime Text is C++ expect for the plugins part. And they have put years to optimize it. It beats everything when it comes to performance, memory, and power consumption.

The only fight it can't win over VSCode is the extensions and ecosystem.

It’s also declining according to the chart, but you’re right that it’s both native and way more popular than TextMate.

I found that ggl trends graphs for tech topics usually decline over time and I attribute it to more non-technical crowd becoming netizens and thus technical topics will usually seem declining.

> It’s possible that native graphical editors will increase in popularity at some point

Panic seems prepared to take that bet, with their development of Nova [1], a replacement for Coda.

[1] https://www.panic.com/nova/

It better be way, way better than Sublime Text is the plan is to charge Panic prices. Their apps are best of breed but this is a crowded space and they’re competing with free.

I mean, Sublime costs Panic prices. It just doesn't care that much if you abuse its trial.

(Wait, maybe I'm misreading your comment. Are you trying to say "Sublime is free, so Nova will have to be way better to compete with Sublime" or "Sublime wasn't good enough to justify its price, so Nova will have to be way better than that to justify its price"?)

Not the parent poster, but I'd agree that Nova would have to be pretty close to revolutionary to even get me to consider it.

People invest a lot of time into their existing text editors. For many people (myself included) a potential replacement would have to be more than a little better, because otherwise it's not worth the somewhat large cost (in terms of time spent on setup+mastery) of switching.

Panic also has a tendency to create something, and then neglect it for ages, which includes their previous editor...

They just have too many products than what they can focus on...

They seem to be doing okay with Coda already?

I can't say I've ever met anyone who actually uses Coda. Does it appeal more to the Dreamweaver crowd? (No offence to anyone who uses Coda, or Dreamweaver, or anything else!)

FWIW, I met folks from Panic when Coda was first released, back when the Macworld Expo was a thing, and said -- honestly -- that the program struck me as "Dreamweaver without the suck." They joked it was a shame they couldn't use that as a tagline.

Coda is more like VS Code and Sublime Text in some ways, but it definitely has Dreamweaver's "one stop shop for big web sites" thing going. (BBEdit also has that to a large degree, despite being even more of a pure HTML/text editor.) The biggest liability Coda has is that it feels designed for a time when we were primarily building sites out of hand-coded HTML; like BBEdit, it really isn't optimized for working on MVC-based apps, whether server-side or front-end.

I used to use Coda and Coda 2 - I loved them, and they were true "Mac" apps. But I switched to Sublime and Vim for one reason alone - Cmd-T/Ctrl-P fuzzy file opener.

That one feature makes such a difference to me as I switch between big project trees that I can't do without it.

I'd happily pay Panic for Nova if they add that back in.

Coda does have "quick open," with ^Q, doesn't it?

(Ironically, as I get more deeply into Vim, I've found the :find and :buffer commands to be faster and just as useful as the CtrlP plugin, even if they're not quite as forgivingly fuzzy.)

^Q isn't as fuzzy as I'd like it - I do a lot of rails work and being able to type apvwpeopsho to match app/views/people/show.html.erb is really useful

Emacs is not by any stretch terminal-based. It can work in a terminal, but it also fully supports graphical environments. In fact, I dare say that most Emacs users use the graphical rather than the terminal version.

Example: https://www.youtube.com/watch?v=FWQB_9QcGI0

I would consider myself an Emacs user and I use the graphical version too. With the exception of the menu bar and toolbar, Emacs seems to be graphical but not a graphical user interface, if that makes sense. It is still primarily a text-based application controlled through the keyboard. There’s certainly nothing wrong with that approach, but my litmus test is if you lose a significant amount of functionality by using the terminal version instead of the graphical version, it’s graphical. I don’t really lose anything (and I don’t think most people do) when running emacs -nw.

Actually you lose quite a lot, which is of course everything that requires a graphical environment. Examples include smooth pixel-based scrolling (see my other reply below), extensive image support everywhere (e.g. EWW/elfeed/GNUS/Org) which includes animations, PDF viewing (native on macOS), true color / SRGB, SVG rendering, better font support including emojis on macOS and multiple frames.

Maybe you don't care about any of these but don't tell me you don't really lose anything.

No smooth scrolling is a deal breaker for a lot of people I'm guessing

It does have smooth scrolling. On macOS (Emacs mac port), it's the same inertia-based scrolling that every other system app is using and on Linux pixel-based smooth scrolling was added for Emacs 26.

Smooth scrolling equivalent of editors are bulk editing commands, keyboard macros and Elisp etc.

Yea, I try VSCode every so often, but I keep coming back to Vim in my terminal for the majority of my editing, but I actually have been using TextMate 2 (before release) as my GUI editor of choice. It’s simple, fast, and gets the job done.

If I wasn’t writing so much Python, I’d say I have a type.

A niche? Tons of people use non-Electron/web based graphical editors.

Visual Studio, Sublime Text, TextMate, BBEdit, SlickEdit, Notepad++, XCode, Vim, Emacs, heck, one could add IntelliJ into the mix...

> There’s probably a niche of people who don’t like the potentially poor performance of Electron-based editors

Haven't noticed any performance problems with VS Code, since I started using it everyday maybe 3 years ago. I switched from Intellij based editors to VS Code and before that I used vim for a decade.

600 MB memory usage with just one small text file open IS a performance problem imo (but I agree the app doesn't feel slow).

Especially on MACs were RAM is priced at a premium.

On Windows I developed a small program that sums the ram usage of my browsers and Electron apps I use. Between Firefox, Chromium and VSCode it's frequently around 4 GB of ram ! That's insane just to basically browse text.

You might like to follow OniVim2: https://onivim.io

It is native, cross platform, and not based on Electron. It also uses Vim as the core editing engine.

> It is native

It isn’t native in this context; As a sibling comment mentioned, OniVim2 uses revery[0], which uses it’s own widgets (not native ones) like flutter[1].

Quoting from my old comment[2]:

> We really should be trying to use the native GUI toolkit (or cross-platform native UI libraries like libui), not using Flutter-esque libraries that draws everything from scratch.

> Coherent UI is a very important point to users IMO. Users can assume that some special feature from App X will also work on App Y.

[0] https://github.com/revery-ui/revery

[1] https://github.com/revery-ui/revery/blob/master/README.md#de...

[2] https://news.ycombinator.com/item?id=20612195

I'll adopt whatever definition you want "native" to mean for the discussion - and under your definition of native, I would say it's pretty clear that users of text editors and developer tools don't care much at all about "native"(your definition of using the platform provided widgets). Just look at the market share of developer tools and IDEs/editors that don't use stock platform widgets. They are the ones that have become dominant. The problems that people have with the dominant players that have gained traction is the performance. You might be able to make the case that using stock widgets matters for non-developer tools (and I would only partially agree there), but for developer tools when people say they want "native" they are more likely to mean they want the performance that more often comes with natively compiled languages without a VM. It makes sense that developers would trade stock platform-widgets in exchange for an editor with greater cross platform reach because users of these tools benefit from network effects of these tools having wider reach. They want someone to have written the plugin/extension they're looking for.

Personally, I'm not looking to increase the ways that I'm locked into my current operating system, so all else equal, I'd favor an editor that runs everywhere.

FWIW personally with "native" i mean "native widgets too, where possible". It isn't always possible and i'm ok with that, but if your application uses a text edit area, a treebox for project files, a menu bar, a bunch of tabs and perhaps a toolbar (the "standard" IDE layout -AFAIK- introduced by MSVC4 back in the 90s and replicated by pretty much every IDE and most "programming" text editors since then) then every mainstream (and most niche) desktop OS outside of Linux/X11 has native widgets that provide 99% of the functionality (with that missing 1% being the text edit area itself and some minor UI stuff).

(and also FWIW, of all text editors personally i use Notepad++ on Windows and Geany on Linux - though as i really dislike Gtk3 and Geany switched to that, i'm looking for some alternative that uses a more snappy and lightweight toolkit - for now the Debian version i use is still on Gtk2 but that is just a matter of time to be replaced)

Under that definition of "native", it's pretty clear developers don't care very much about having "native" text editors/IDEs, wouldn't you agree? You can look at editor usage to see how they are voting.

Yeah most developers probably do not care, but it isn't like nobody cares (for example i do and i read comments like mine on HN often, so there are others who do too). At least when it comes to text editors there are options and you can use whatever you want regardless of what a complacent majority votes for :-P.

Though i also believe that the functionality some people want from their applications is only available on (what i see as) applications with inferior UIs and they'd rather get used to these UIs than not have the functionality - that is, their vote is for the functionality, not for the UI.

The other thing to consider is that developers spend up to ten hours a day in these editors. The biggest benefits of OS-coherent UI is that an application is quickly learnable for the first week. But when you use an editor for multiple years, all day long, many would trade that for increased customizability.

If not Electron, is it native or does it use some other web engine?

It uses the authors' own Revery [0] framework, based on ReasonML and GLFW. So there's Javascript in the stack, but no Chromium.

[0] https://github.com/revery-ui/revery

ReasonML does not imply JavaScript - it can compile natively using the OCaml native compilers - and that's exactly what Revery does. GLFW is also native/C.

switching those from "search terms" to "topics" tells a different story


(and if you keep it to search terms but swap "visual studio code" for "vscode" you see a simialar rise)

The topics aren't perfect either, unfortunately. For example, Sublime Text, as we know it, was first released in 2008 while the topic trends data you linked shows it being the leader in 2004.

Would be interesting to know which percentage of vim searches are for vim keybindings in other editors. (i know several people who use vim keybindings, but don't know anywone who uses vim itself)

Or, people searching for how to exit vim.

A little off topic: but when I was in uni our instructors insisted that we use vim for all of our development during the freshman year CS courses. Did everyone actually use it? Of course not, but a significant amount of class time was spent teaching keybindings, macros, etc.

I really built a habit of vanilla vim usage, and to this day I have yet to find a "modern" text editor that really supports everything that vim has to offer i.e. "vim mode" being more than binding the arrow keys to hjkl and providing modes.

I've found a lot support most of the standard modes / commands but not vim scripts (and partial ex mode quite often) . Which is often fine as extended functionality often comes through the host editor/ides native capabilities. The advantage being they can leverage things that just don't exist in Vim.

Wow, I had no idea how much the relative stature of Vim and Emacs had changed over my career.

Hmm good point, when looking for a place to retire look for Vim searches!

wow what is up with alaska 100% vim!! what a state

As an aside, I added vim and vi to the trends, which dwarf the others, but show a long and slow decline for `vi`, but a fairly steady state for `vim`. As a vim user that at times wishes he learned emacs instead of vim, emacs is an interesting trend to see: https://trends.google.com/trends/explore?date=all&geo=US&q="...

How much of that is just users searching "how to exit vim" though? :)

Half-joking, but I think it is actually over-estimating the vim user base because there are so many things to search when learning to use vim, whereas the others are much closer to a traditional word processors.

Keep in mind that "vi" has meaning outside of text editors.

Very true and likely, also considering how short the terms are, but emacs is in clear decline. Perhaps it's just become so easy to use, no one needs to search for anything anymore?

vi usage is here to stay, even if not heavy usage, some one has to always change something in a file on a server and has to use vi.

Apart from that, Emacs usage mostly correlates how much of text heavy tasks a programmer is doing. Most people tend to write tons of shell/perl/python scripts and take a lot of time recreate the magic of emacs outside it, Sadly most of it is also throw away effort with a lots of manual effort in between. Sometimes its entirely manual effort because eventually you need to learn Perl regexes, or sed or awk really well, and that's another black hole in itself. To me that's kind of a gap in developer training itself. If you are wasting man-hours to weeks doing what should be done in man-minutes you probably have a huge gap in the way you are used to thinking about how your work in general.

Growth of Python is a big problem for programming community at large. It's a tool largely designed for beginners and people refuse to move beyond that. What's worse they also carry that kind of thinking to any tool they want to use.

Developers are generally bad at automating our own work. We wish to liberate accountants and ware house workers from drudgery. But rarely do we look at our own very work the very same way.

Pode Vim, an album by Pedro Kimura is popular in Brazil.

Using git with vim also seems a popular search combo.

Personally I am amazed that the younger generation are keen to learn vim. I don't see why as I have gone the other way to only use phpStorm for editing in earnest. For me using vim for code instead of phpStorm is a bit like handwriting instead of typing, a definite loss of formatting and neatness.

The reason I find modern interest in vim so amusing is that there is no compelling excuse to use it. In the olden days when you had to queue to use a terminal in a computer room to enter code you had handwritten on paper there were no 'nano' or other editors, you had to learn and use vi.

I don't believe vi is quicker than a full size IDE but I still use vi, find and grep because I don't fully trust these new IDE tools and I am fairly dyed in the wool as a command line user.

The tools I don't fully understand are the textmate, sublime, notepad++ and other middling editors that don't offer the brilliance of vim or the possibilities of a phpStorm grade editor.

It's available on servers. It's fast to manipulate text with. It doesn't spin up my CPU (cough electron editors). It never falls over on me. Basically it just gets out of my way.

Even if I don't use Vim much anymore, there are things that I would still do it Vim because it just does them faster.

I'm curious, why phpStorm specifically and not IntelliJ or any other jetbrains IDE?

Obviously its php specific features aren't relevant here since we're discussing editors (or development environments) in general.

Personally I find that most IDEs are far too language specific, and I can't possibly invest the time to learn an IDE per language when there's so many languages I regularly need to edit (and probably yet more in the future).

VSCode isn't half bad, as it has plugins for just about everything, but it's still a juggernaut in terms of software size. None of the jetbrains product I've used had decent plugins for all the languages I need.

And of course none of these work over a purely terminal ssh connection, which is a bit of a deal breaker for me.

I believe Sublime does offer the brilliance of vim. And I use vim too! They take about the same time to configure to similar levels of usability. Sometimes a more native UI is preferable. Notepad++ has a bit more built-in. There's some Windows particular stuff where I might want that Win 2000 aesthetic. I'm thankful for all the options.

What features are you using in phpStorm that you think are missing from vim?

Definitely not trying to convince you to use vim over your favourit IDE, I'm just currious what your top 10 missing features are.

but phpstorm is just for php, right? what if you want to code in some rust, does it support it? with just a few tweaks and packages sublime turns into a half-decent editor for any language and stack.

I tried adding Notepad++ to this comparison but google filtered it to mean "notepad". Lame.

Works if you search for each software as a "topic" instead of the (exact) queries.


I hope sublime doesn't die off (or fade into obscurity)

They blew it, plain and simple. Development went dark, VS Code swept in and took its place. Sad.

I’m afraid that ship has sailed.

I believe the uptake of typed langs (typescript) is what drives peeps to look beyond sublime.

At least VS Code and TextMate are free and open-source software. Sublime is basically dead and there's no chance of a fork.

> Jumped ship to Sublime when it was released because it was evolving much quicker. Was glad to have backwards compat on a lot of things like themes. Still have my modified “Made or Code” theme kicking today. Tried TM2 a ton during the betas but never managed to reach the same level of productivity as Sublime. My muscle memory is too strong now and I can’t find any reason to leave.

That's an interesting comparison. I completely agree that VSCode is the rage right now. Sublime was big 2014-2016. I'm surprised atom isn't as popular (I suspect its because of the awful loading time)

That’s why I never switched from Sublime to Atom, the general slowness was just too frustrating. Not just the load time, but things like opening large-ish files or global find/replace. VSCode kind of feels like how Atom should have been, fully featured with lots of great plugins but also snappy. I still keep Sublime in my toolbox in case I have to open a huge file or something.

"atom" probably includes searches for the particle, not just the editor, so not really fair comparison.

Also "vs code" trends higher than "visual studio code", so take all of these results with a pinch of salt.

Except for the fact that you can “type hint” your query term (in this case, Atom: Text Editor), which the referenced URL does.

If you look it says "Atom - Text Editor"

That graph shows it was almost as popular in 2004 as it is today, so obviously that term isn't just referring to the editor. (since it wasn't released until 2015)

But if you select "Visual Studio Code - Text Editor", then that one becomes the most popular - see link I posted above

If you select the appropriate topics as opposed to raw search terms, you get a very different picture https://trends.google.com/trends/explore?date=all&geo=US&q=%...

Nah, I just tried it out and it's great. One of the few good lightweight editors on macos, and might make me ditch vim since i never needed most of its functions. Popularity doesn't really mean much.

Also interesting the decline of Emacs and the stability of vim: https://trends.google.com/trends/explore?date=all&geo=US&q=%...

Too late for what?

Dominance of the text editor market. TextMate was pretty meh, Coda I tried and thought was ridiculously overpriced for its total lack of features. Sublime was great for its time, I even paid for a license, but Atom is just too good for its value (free).

But apparently VS Code is becoming extremely popular. I wonder if its literally just because of GitLens (still missing from other text editors).

Disclaimer: RubyMine / IntelliJ for life.

I do most of my development work in Jetbrains IDEs and am a huge fan but if you don't keep the environment open 100% of the time it takes a long time to bootstrap. texmate is great for fast one offs

So keep it open all the time? Are you really working on more than one serious project at a time?

I use Atom for my quickie projects here and there, but you really can't beat an IDE. (IMO)

I usually have three instances of IntelliJ open at the same time with large Java projects in them. One I'm working in, another a colleague is asking me questions about, another to lookup some related code, et cetera.

CPU use is negligible and I have plenty of RAM.

Far more than GitLens. Integrated terminal, for example. You can add database tools, Docker tools, etc. The relatively recent addition of SFTP is a first class implementation.

I have a lot of respect for Allan Odgaard. Something happened, and I don't want to speculate, that caused him to take a break from Textmate (version 2.0 was supposed to come out 9 or so years ago).

Instead of abandoning the project he open sourced it and almost a decade later it is being released.

Textmate is now my graphical Notepad on Mac, with VS Code being my IDE and vim my text editor.

Thanks Allan.

> Textmate is now just graphical Notepad on Mac

I hope no one reads that and assumes that’s all TextMate is. TextMate is the godfather of all modern “smart” GUI code editors — VSCode included.

Doesn’t BBEdit hold that position?

I'm not sure, but I think the whole themes, expandability, multiple cursors thing was TextMate first.

BBEdit magic was all through AppleScript, which was always inscrutable for me.

It does, and one can argue it's been maintained and updated much more consistently than TextMate. I still think BBEdit is the best "Swiss army knife" for text manipulation; I've used it for editing huge Markdown-based documentation sites in three tech writing jobs now.

Visual Studio released in 1997 pre-dates TextMate. There were also quite a few products based on Scintilla which came out in 1999.

(And you could edit not just C++/VB/Microsoft-language files with Visual Studio back then. It was extendable to support many languages, which they did.)

TextMate's key innovation was its method of parsing using regexes to build a syntax tree, which was extremely general while at the same time being approachable. This lead to a huge variety of grammars, more than any other editor and it became the standard for syntax highlighting in Sublime, Atom, VSCode, etc.

I hear you, but I think that if the only thing that VS Code did well was to highlight code, far fewer people would be using it because VS Code is not just a text editor. Far from it.

Once you add panels and toolbars with all sorts of GUI tools, consoles, language servers, remote editing, debugging and built-in commands for common external tools like Git - you've got yourself an IDE in my opinion.

However, aside from all of that, Microsoft's mastery of autocomplete - which they call Intellisense - is really what attracted people to Visual Studio and later VS Code. I know that's the reason I've always used it. Also, VS always had syntax highlighting before TextMate even if it was implemented differently than how TextMate did it.

So, I don't think it's fair at all to say that TextMate is the godfather of VS Code assuming that by saying that, we're saying that it's the reason that we have VS Code or that it's the reason that people are using VS Code... I don't fully understand implication of the phrasing but my guess would be that TextMate is the godfather of the implementation of syntax highlighting that VS Code and many others are using.

(I think if we changed godfather to grandfather, it'd make more sense to me because then you have lineage. A godfather is more there as a backup, to be your father in case your biological dad dies. But perhaps, like in the Godfather movies - you go to him for help and advice. So in that respect it sorta makes sense.)

> Once you add panels and toolbars with all sorts of GUI tools, consoles, language servers, remote editing, debugging and built-in commands for common external tools like Git - you've got yourself an IDE in my opinion.

You can have all (or none) of those features in either an editor or an IDE.

The core idea of an IDE was to provide a single UI for all aspects of development — which originally included source code editing, compiling, debugging, and testing. To handle all of these tasks within an IDE required the IDE to have a top-down configuration that would enable it to compile and run the project.

Editors like VSCode don’t compile or run anything on their own (though doing so is possible via the integrated terminal). Editors thus normally don’t require a project file. They may use files like tsconfig.json to inform internal language services, but those config files are not specific to VSCode.

I don’t know, that’s kind of an arbitrary differentiation. I guess the full Visual Studio is not technically an IDE either then because the GUI process itself does not compile anything. It calls out to the standard Microsoft C++ compiler or the dotnet compiler or whatever else it happens to be working with... like Python.

From the point of you of the user they are all an IDE I think.

Isn't Visual Studio an IDE? Something like IntelliJ IDEA?

On the other hand Visual Studio Code is just an editor, like Textmate.

Agreed! anyone reading this who hasn't used TextMate don't pass it by it is an incredibly useful tool to have in your tool belt. It opens faster than just about all IDEs and is feature rich far beyond "graphical Notepad"

Apologies that was in fact a typo.

I feel at least slightly responsible, as I imagine many people from the TextMate community circa 2006–2010 do. I think the decline of TextMate was mostly a community problem rather than a technical problem, and it’s a bit hard to untangle exactly what happened.

Allan had been making very fast progress on TextMate for the first several years, and the community was full of excited “early adopter” types, who were very chatty and supportive, and were actively engaged in improving the TextMate language “bundles”, trying out new features, etc. I found the ##textmate IRC channel at the time to be the best place to get technical help with pretty much any programming language.

Then at some point Allan decided that he had made some suboptimal design choices in pretty much every component of TextMate 1, and wanted to improve those with new designs. But he thought it would take more work to incrementally swap new parts in that were compatible with all of the other stuff he wanted to eventually replace, so he started in on what was a substantial rewrite of everything.

That (a) took away his incremental improvement of TextMate 1, (b) took his time away from being as responsive to user questions/ideas, (c) caused bundle authors to slow down on improvements to TM1 bundles while they waited to see what new features TM 2 had in store.

At the same time, the creation of an "insider" IRC channel took away some of the activity from the main IRC chat, the migration from one big SVN repository to a bunch of separate per-language Git repositories damped a lot of the bundle development activity as people were no longer exposed to every change to every bundle, so the bundles didn’t cross-pollinate as much.

Many of the core people in the community gradually drifted away, and weren’t being replaced by new people, from some combination of existing bundles being good enough, and less overall buzz.

As Allan was getting less feedback about the code he was working on, and less interaction overall from users, he became less motivated. As the TextMate 2 project dragged past its original timeline, both Allan and others in the community started to get discouraged. I would speculate he started to feel like more of the work was a chore rather than a joyful adventure.

There are many great TextMate 2 features which have still not been properly explored by bundle authors all these years later. It could use more screencasts, more technical documentation, more people testing zany things and making feature requests...

For my money TextMate is still the best editor available, from a purely technical perspective. The experience of customizing one’s own editor environment has less friction than pretty much anything else out there. Almost completely nontechnical people can do amazing things with it. But the community isn’t the same as it was.

* * *

Aside: Sublime Text was an unauthorized (and for at least the first few years half-baked) rip-off which borrowed TextMate bundles wholesale without contributing anything back whatsoever. In early versions [and maybe still?] people couldn’t actually edit all of the bundle items in Sublime, so its users were disempowered from customizing their own experience, arguably the main point of TextMate’s design. In the early days many of them came to complain at us about TextMate bundle items which didn’t work in Sublime. In my opinion the Sublime author profoundly missed the point of what TextMate was about and why it was special, and viewed it as nothing more than a convenient pile of existing work he could exploit to kickstart his own app.

Wonderful write-up.

> Aside: Sublime Text was an unauthorized (and for at least the first few years half-baked) rip-off

This puzzles me though. What "authorization" should Sublime's author have sought?

I don't know why application XYZ would/should need permission/blessing to be compatible with application ABC's plugins.

To me it's just a completely sensible decision; why would the author(s) of application XYZ want to force users to reinvent the while to write a plugin to do Ruby or Javascript or HTML or whatever highlighting, when this work has already been done so many times over?

> In the early days many of them came to complain at us about TextMate bundle items which didn’t work in Sublime.

Well this was certainly exasperating I'm sure. Sorry you had to deal with that.

> In my opinion the Sublime author profoundly missed the point of what TextMate was about and why it was special

Sublime's author has never really engaged the community much like Textmate's author, which is a shame. Though I would have to point out that a small team (both were single-man teams for most of their lives) can only accomplish so much, and I would say that ST's development has greatly outpaced TextMate's. Also I think ST has somebody working full-time on package management stuff now, not sure.

I think it’s unethical to copy an existing program’s features one by one, as precisely as possible, while adding nothing novel. If you want to make software, get your own ideas. Copying something is a lot easier than inventing it for yourself, which requires doing real research.

If you try ripping off large companies, you run the risk of getting sued. But if you do it to a 1-person company, you can generally get away with it. Still scummy.

> completely sensible decision

From a purely selfish “how can I profit without doing my own work” perspective, sure. Same is true of many types of unethical shortcuts in the world.

> ST's development has greatly outpaced TextMate

I haven’t looked in years, but when Sublime was about 4–5 years old (when I last spent some time examining it) this was nowhere close to true.

I would say instead that the man-on-the-street external impression of ST’s development has been faster.

> I think it’s unethical to copy an existing program’s features one by one, as precisely as possible, while adding nothing novel. If you want to make software, get your own ideas. Copying something is a lot easier than inventing it for yourself, which requires doing real research.

I'm not a fan of this argument. We all build upon the work of those who came before us, and usually even the most blatant rip-offs add something.

I'd even argue the opposite: We should copy good ideas. There's no point in re-inventing the wheel over and over again. If we copy good ideas, we can build on them, and we can spend time inventing new things, rather than re-inventing everything just to make sure it's all original.

(And I say this as someone whose work has been shamelessly ripped off multiple times in the past.)

    I think it’s unethical to copy an existing program’s features one by one, as precisely as possible
Completely disagree that this is what ST did. Implementing TextMate's bundle/syntaxes APIs != creating a clone.

I'd argue that conceptually, TextMate borrowed at least as much from Emacs and BBEdit as ST did from TextMate.

After all, what was TextMate's raison d'être? It was not some totally new idea. It was a successful iteration of existing ideas. It was lightweight like a text editor, but highly extendable via scripting.

So, it was like Emacs, except not quite as infinitely extendable, but more friendly and had a native OSX GUI interface. And it was like BBEdit, except more extendable. (Correct me if I'm wrong on this -- I used BBEdit a bit back in the day but never dove too deeply into it)

ST iterated further upon TM's ideas and others. Yes, it implemented TM's bundles and syntaxes for compatibility reasons, which I would call a very good thing because why invent those wheels again. Any new entry into an existing software category certainly should leverage the existing ecosystem to the fullest extent possible, unless there is a very good reason not to.

It's been years since I used TM but I think ST's command palette was a big innovation over TM, and more keyboard-friendly. ST's integrated Package Control is also something I don't believe TM has an equivalent for. And ST is of course cross-platform: it's not like using TM is even an option if you're on Windows/Linux.

So I really reject the talk of ST being a "ripoff". Good software should borrow ideas and leverage existing work whenever possible. And it's demonstrably false to claim that ST offered nothing new, or that TM itself didn't borrow very heavily from other editors.

> while adding nothing novel

AFAIK, Sublime is/was cross-platform? I wouldn't call that nothing novel.

As a fellow early TextMate contributor, I find your take 100% accurate to the extent I was around for it. I personally drifted away because I got a new job that took up all my available time.

I might have found time here and there to contribute to TextMate after the open sourcing, but my company won't let me even look at GPL3 source. I don't even dare look at the bundles.

Textmate for me is the best example of "second system effect". Allan decided to rewrite everything, which killed the community.

(I also don't think SublimeText "just ripped off" TextMate and didn't add anything new. They added Windows and Linux support, for one.)

The thing that caught my attention and I found useful enough to really give SublimeText a chance was the mini-map. I see that in a lot of places now, but as far as I can recall, the first place I saw it was ST.

I still love TextMate -- but I have to be honest, I switched to VSCode recently. The community around VSCode is hard to pass up, and thanks to documentation (and it being JSON), I've found it fairly easy to configure, and in a few ways, it's much easier to configure the whole UI. (pros and cons there...)

I won't say VSCode as stable as TextMate, and it certainly doesn't feel like a native Mac app in the same way, but it's simply easier for me to find plugins that I need.

I'm still using Text Mate almost always as a default editor. The plugin system is a selling point for me.

It's a tough call. And he did the right thing in the end.

But it took him way too long, unfortunately.

Had him realized he couldn't move the project forward and open sourced it earlier, it could have been a different story.

At the ripe old age of 35, I am apparent a greybeard, because I still use TextMate.

I'm just doing light HTML/CSS/JS prototyping, so my needs are easily satisfied, but TextMate is just so light. Launches instantly, doesn't crash, and uses minuscule resources. (Versus the 9 Adobe processes running in the background, even though I don't have an actual application open.) It's just nice to have a completely blank window, no sidebar, no nothing, just a place to plonk text.

Funny you say that, because in my testing this evening the performance of ST3 is significantly better than TM across the board. Scrolling and navigating around files on my 2018 Macbook Pro w/ Radeon 560X is noticably slow. Even scrolling the release notes was choppy.

> TextMate is just so light. Launches instantly, doesn't crash, and uses minuscule resources.

I used Sublime for the same reasons, which is to say I understand why people like TextMate over something like VS Code. Being able to do something like open up a 400 CSV without in an editor without the editor choking is just really nice!


Would be great seeing the community bringing Language Server Protocol[1] and other goodies to TextMate

[1]: https://microsoft.github.io/language-server-protocol/

This is great news. So glad to see next stable version of the Editor which invented or at-least made Snippets and Quick-Open popular.

I've been taking TM 2.0 for spin for the past few weeks. I must say - it is THE editor that gives true Mac editor experience.

No complaints on performance. And it is very stable.

1. Among the existing features, UI refresh for Quick Open window is required as it feels very heavy now in 2.0. TM 1.x Quick open window UI was slick and neat and I wish they kept it as such. Same comment goes for Go to Symbol window (CMD + SHIFT + T).

2. They would win back a lot of users if they provide a slick option to have split editor to make use of very common high-DPI Mac screens.

3. Documentation for Textmate 2.0 is still WIP as I see on their website. Lot of pages are empty with titles alone.

And glad to see Alan's comment in ChangeLog - `Not everything on the wishlist made it into 2.0, but TextMate remains a work in progress, so don’t despair :)`

Loved the original TM and built a ton of things with it. It was my daily driver for a good 4-5 years through many projects, startups and full time jobs.

Jumped ship to Sublime when it was released because it was evolving much quicker. Was glad to have backwards compat on a lot of things like themes. Still have my modified “Made or Code” theme kicking today. Tried TM2 a ton during the betas but never managed to reach the same level of productivity as Sublime. My muscle memory is too strong now and I can’t find any reason to leave.

Regardless, this is a great accomplishment/milestone and I’m very stoked for Allan and the team. Maybe I’ll need to take it for another test drive.

The multi-platform support was what got me to jump ship to Sublime. TextMate on MacOS was definitely more polished, though.

A throwback to the days when men were men, women were women, Obama was still president and we still knew how to make desktop apps without `npm install`.

A different time.

A different time indeed. Really wasn't that long ago either.

I've switched from OS X to Linux approximately 12 years ago so I'm not really concerned by this release, but I'm still happy about it. TextMate has introduced me to powerful text editors. I was completely crazy about this software at the time. Back then, it was not open source and it was the only software I paid for (well, except for the OS and the included iLife suite). I remember paying two licenses just to support Allan Odgaard a bit more.

When I switched to Linux my first choice was Gedit (it was usable at the time) with a ton of plugins to make it like TextMate as much as possible, but I very soon turned to Emacs and I've not gone anywhere else since.

I’ve used TextMate 2 since it’s earliest beta release and always found it fast and reliable. If you want the speed of a native Mac OS X editor, in my opinion, nothing beats TextMate. Congrats to the developers for this major milestone.

I still use TextMate on a daily basis. It's what I use as the macOS equivalent of Notepad (I know there's TextEdit, but TextMate is better IMO). I also use it as a programming scratchpad. Mainly for Swift and Python.

Thank you to all that contributed to TextMate 2.0 release. I still use TextMate everyday since around 2008.

I am using TextMate as a text editor, coding for Python/Django, and as scratch pad for code.

Wow, 13 years after I really got into it... and I’ll be happy to install it. But I’ll stick with Neovim, can’t really justify switching to an editor that might not be around. Good achievement but they need an entirely new user base!

Congratulations Textmate team, and thanks for hard work.

I still find textmate the best for my needs:

1. Nice search interface (sorry sublime) 2. Fast and memory efficient 3. Best autocomplete 5. Multi line editing.

But few things could be better: editor tabs not contrast, slow when editing files with very long lines, feature to see memory usage per project

I have also been happily using TextMate 2.0 throughout the beta and can confirm that it's been stable and fast.

Surprisingly, my 15-year-old license is still considered valid

Allan did say it would be a free update like 12 years ago. :)

Thank you for TextMate. My Mac-like daily-use no-nonsense text editor, handles whatever I throw at it. Congrats on the release!

You'll have a hard time prying Webstorm out of my hands...

I was a die hard editor purist (Sublime) for a while but after using an IDE for Java I realized how powerful they can be - even for frontend.

Can you give a reason or two why? Specifically for frontend. I want to go into trying IntelliJ with some good reasons

Well, I wouldn't recommend IntelliJ with plugins. I would only recommend Webstorm.

Everything works well. The intellisense and linting integration is amazing. CSS selectors are autocompleted from indexed HTML. If you don't have any red squigglies in your TS or HTML files then most likely your Angular app will just work. Plus, point-and-click to navigate through classes/methods like Intellij. No more "let me search for this method by name to find the declaration."

Good unit test integration w/ jasmine to top it off.

Just too many benifets to ignore. If I had a company I'd require development in an IDE.

IIRC I was in the ~600 first licensees. After several years of BBEdit, TextMate felt magical: the "Jump To Symbol" panel, the "Filter Through Command…" feature, the recordable macros, the language bundles, the great colorschemes, etc.

Then the complete rewrite was announced and, as 2.0 was delayed and the author disappeared… I switched to Vim.

I downloaded 2.0 out of curiosity, though, and it feels just like 1.5.x with VCS badges built-in. Too little, too late.

It seems to me that if TextMate 2 hadn't been a complete rewrite, Sublime never would have been able to take over.

So I don't know what the backstory is with the slow release cycle, but at a certain point it became untenable to use TextMate 1 on our large codebase with performance problems and features missing from other tools.

Still my favorite editor, but I really appreciate the language server protocol support in vscode.

Even though VSCode is my main driver, I like textmate for browsing large numbers of files, and emacs for Lisp. When I get back home after my travels I am looking forward to the update.

I remember liking TextMate back when I used macOS as a daily driver. Glad to see the project is still going. Wish there was a Linux port. :-/

>Wish there was a Linux port. :-/

This would defeat the point of it really, the whole point of TextMate in 2019 is to have an editor that leverages the native Mac UI.

If you ported it to Linux you'd either just be making a completely new application that didn't work the same or you'd be making as weird application that felt like a Mac app running in the Linux world.

Congrats to the contributors. Textmate was one of the first text editors I loved on Mac after so many years of working with BBEdit.

Wow... textmate was my editor so many years ago... it was basically what introd me to coding many many... many years ago, when for my very first project someone said "i want a website", so I bought a CSS and HTML book 10 years ago and used textmate to code it.

Now however, I worship Vim, the one true god

Hmm really surprised that it is slower in handling large files then VSCode

TextMate is such a wonderful editor. I tried them all, but always go back to TM. Also the fact that you can use ruby to write plugins is just awesome.

First impressions: so nice. Love native apps.

Textmate could do text wrapping better than all the other editors combined. Miss that feature.

Cool!I have been using visual studio code before, this time I can try it.

Aww, yay! I've moved almost entirely to VS Code (disclosure, I work at Microsoft but I moved to Code before that and I do not work on that team, though I am lucky enough to work with some of them indirectly), but I still have TextMate for some stuff that it either does better/faster or that I prefer to use out of muscle memory. Beyond that, I will always be a huge fan/evangelist of the app.

2005, the Mac alone had lots of good options (BBEdit to name just one), but I think it is fair to say that TextMate charted the course that every successful text editor has followed over the last 15 years. And I'm not just talking about the ingenious bundle system (the syntax of which VS Code still uses to this day!) or the themes -- stuff like the "mate" command genuinely changed how I interacted with files (it's possible this existed for other editors before TextMate but I'm unaware of it). When TM 2 first went into beta/alpha in 2011, rmate was a revelation. Now, I could use my editor of choice on all my remote machines. VS Code now does this elegantly with the VS Code Remote extension (it works super well in WSL/WSL2), but for those of us who abhor vi/nano/emacs, this is the sort of thing that has really made my life easier. There are more examples I could cite -- but TextMate really paved the way for the editor market we have today.

TextMate was one of the first apps I bought when I became a full-time Mac user in 2007 and nearly 13 years later, it's remained one of the most important applications I've ever owned. I've been using the 2.0 release basically since it was in alpha stage (when it was necessary to have TM1 installed alongside it) and I would honestly probably still use it if the community hadn't all but abandoned it (first for Sublime -- an editor I respect but could never love -- and later for Atom, which was soon usurped by Code).

Even now, for writing stuff in Markdown the way I like to write, my customized TextMate packages remain the best way to do that. I've ported most of what I used to do over to Code but there are some thing that just aren't perfect. (And more accurately, it's hard to get used to something new.)

I bought TextMate when I was still a broke college student, so I took advantage of the student discount offered at the time for TextMate 1.5 or whatever it was. I've always felt bad about that because over the course of the 11 years or so that I used it for my primary writing tool, I easily composed ~5 million words or more into it (one year, 2009 - 2010, I did more than 1 million words -- and this is of prose/Markdown, to say nothing of however many lines of code I might have typed. To put that in perspective, the longest Harry Potter books are ~110,000 words. Suffice to say, I cut back on my writing obligations in 2011 and beyond to save myself from burnout) and an ungodly number lines of bad code across assorted projects (so much bad JavaScript!). I paid a friend initially to customize a plugin he'd made when we worked together for my more specific purposes, and I later maintained/ported those plugins to TM2 (and now, VS Code), but when I look at my TCO for TM versus what it gave me, I can't help but feel guilty.

Congrats, Allan!

Congrat on the Textmate release.

OT. Anyone know of a secured text editor for iOS that can encrypt and decrypt text files on writing and reading? The encrypted files should be portable so that I can encrypt and decrypt them on other platforms.

Just in time for nothing

What is text mate?

So what are the actual changes?

Guidelines | FAQ | Support | API | Security | Lists | Bookmarklet | Legal | Apply to YC | Contact