macromates.com

TextMate supports version control by surfacing changes in two places—the file browser and the editor—and by letting you review and commit at a finer grain than "all or nothing." According to the product page, it shows which files have changes in the file browser view, which lines have changes in the editor view, brings up a diff of the current file's changes, and supports committing a subset of changes. The page states this works "for all the major version control systems," so the features are presented as system-agnostic rather than tied to one tool.

What you see while working

Changed files in the file browser

The file browser marks files that have changes. This gives you a project-level view of what's been touched without leaving the editor or running a separate status command.

Changed lines in the editor

Within an open file, the editor view indicates which lines have changed. You can see the scope of an edit in context rather than reconstructing it from memory.

Reviewing changes

Diff of the current file

TextMate can bring up a diff of the current file's changes. This is the review step: compare what's on disk against the committed state before deciding what to keep.

Committing a subset

The page explicitly lists the ability to commit a subset of changes. Instead of committing everything at once, you can select part of the work and commit that portion—useful when a file contains both a fix you want to record now and unrelated edits you want to keep working on.

What the page does and doesn't specify

The page describes capabilities, not mechanics. If your decision depends on a specific system (for example, a particular distributed or centralized tool) or on the exact commit workflow, verify that against the app itself rather than assuming from this summary.

How to evaluate it for your workflow

1. Install TextMate 2.0 (the page lists macOS 10.12 or later as the requirement) and open a project that is already under version control.
2. Make a small edit and confirm the file browser marks the file and the editor marks the changed lines.
3. Open the diff for that file and check that it matches what you expect.
4. Test the subset-commit path on a file with two unrelated edits: stage one, commit, and confirm the other remains uncommitted.

If steps 2–4 behave as described with your version control system, the integration fits your setup. If the diff or subset commit doesn't appear for your system, that's the practical limit to check before relying on it.

Where this fits among TextMate's features

Version control is one of several editing-oriented capabilities on the page, alongside multiple carets, file search, scoped settings, commands, snippets, bundles, and macros. The version control features are presented as awareness and review tools inside the editor—seeing changes and committing selectively—rather than as a replacement for a full version control client. For history browsing, branching, or merging, the page makes no claims.

TextMate approaches file search as a scoped operation: you select what to search, specify what to search for, and the editor presents results so you can jump between matches, extract matched text, or preview replacements. Navigation is tied to that same results view and to the file browser, which also shows which files have changes under version control. This fits developers working in project folders who want search and file movement without leaving the editor. The details below come from the TextMate product page on macromates.com.

Scoped search: choose the range first

The page describes the workflow as three steps: “Select what you want to search, what you want to search for, and TextMate will present the results.” The first step matters most. Instead of searching an entire disk or an arbitrary folder, you define the scope — typically a project or a selected set of files — and then run the query inside it.

That ordering has practical consequences:

• Fewer irrelevant hits. Restricting scope before searching keeps results tied to the code you are actually working on.
• Repeatable searches. Because scope is an explicit choice, the same query can be re-run against the same set of files.
• Works with mixed projects. TextMate’s scoped settings feature is built for files that mix languages or projects that use different build systems, so a search scope can follow the structure you already use.

What the results view lets you do

The page lists three actions on the results: jump between matches, extract matched text, and preview desired replacements. In practice:

1. Jump between matches — move from one hit to the next without manually scrolling through files.
2. Extract matched text — pull out just the matching portions, useful when you want a list of occurrences rather than full file contents.
3. Preview replacements — see what a change would look like before applying it, which reduces the risk of a broad find-and-replace going wrong.

Navigating files and changes

File navigation in TextMate is centered on the file browser, and the page ties it directly to version control: “See what files have changes in the file browser view, what lines have changes in the editor view.” That means the file browser doubles as a status view — changed files are visible where you navigate, so you can move to modified files without running a separate status command.

The same version-control awareness extends into the editor and to diffs:

• Changed lines are marked in the editor view.
• You can bring up a diff of the current file’s changes.
• You can commit a subset of changes.
• The page states this works “for all the major version control systems.”

For navigation, the practical loop is: scan the file browser for changed files, open one, use the editor’s line markers to see what changed, then diff or commit from there.

How search and navigation fit together

Search results and the file browser serve different navigation needs, and TextMate keeps both available:

A typical task shows the combination: you are fixing a deprecated function call across a project. You scope the search to the project, review each match by jumping between results, preview the replacement text, then use the file browser to confirm which files now show as changed before committing only the relevant subset.

Limits to keep in mind

The product page describes these capabilities but does not document menu locations, keyboard shortcuts, or configuration syntax for search scopes. Those specifics are best confirmed in the app itself or its documentation. The page also does not state pricing or licensing terms for TextMate, so treat cost and access conditions as things to verify on the site rather than assume.

TextMate 2.0 is listed as requiring macOS 10.12 or later, and the editor is described as open source with support for a large list of programming languages — relevant if your navigation workflow depends on language-aware scoping and bundles.

macromates.com is the official home of TextMate, a powerful and customizable text editor for macOS. It is developed as open source and supports a large list of programming languages. The current download offered on the site is TextMate 2.0, which requires macOS 10.12 or later. If you are looking for a native Mac editor with deep customization through bundles, snippets, and commands, TextMate is the product this site distributes.

What TextMate offers

The site highlights a set of editing features aimed at people who work with code and structured text:

• Multiple Carets — add multiple insertion points to make several changes at once, swap pieces of code, and similar edits.
• File Search — choose what to search and what to search for; results are presented so you can jump between matches, extract matched text, or preview replacements.
• Version Control — see changed files in the file browser, changed lines in the editor, bring up a diff of the current file, and commit a subset, with support for all major version control systems.
• Scoped Settings — associate detailed scope selectors with key shortcuts and settings, which helps with files that mix languages, projects using different build systems, or third-party code with different formatting preferences.
• Commands — write custom actions in any language that works with stdin, stdout, and environment variables; complex interactions can use WebKit or a dialog framework for Mac-native or HTML-based interfaces.
• Snippets — turn commonly used text or code into snippets with placeholders and transformations that adapt to context.
• Bundles — the customization mechanism, with support for many languages, markup systems, and workflows.
• Macros — record a scratch macro for immediate replay or save one for repeated use.

The page also lists clipboard history, custom themes, live HTML/Markdown preview, foldable code blocks, and indented soft wrap under "And More."

Who it suits

TextMate fits Mac users who want a native editor they can shape around their own workflows: the bundle system, scoped settings, and command support are the main reasons to choose it over a fixed-feature editor. The macOS 10.12 minimum means older Macs are supported, but you should confirm your macOS version before downloading.

Getting started

1. Go to macromates.com and use the download link for TextMate 2.0.
2. Confirm your Mac runs macOS 10.12 or later.
3. After installing, explore Bundles for language support and set up snippets or macros for repeated work.

The site presents TextMate as open source; the page does not state pricing or login requirements, so check the download page itself for any current terms.

TextMate is a macOS text editor whose coding features center on making repetitive edits faster: multiple carets for simultaneous changes, snippets with placeholders and transformations, macros for repeated work, and supporting tools such as clipboard history and foldable code blocks. It requires macOS 10.12 or later, and the current download listed on macromates.com is TextMate 2.0. These features are most useful if you regularly edit similar code in several places, reuse boilerplate, or repeat the same keystroke sequence.

Multiple carets for simultaneous edits

TextMate lets you add multiple insertion points so you can make several changes at once, swap pieces of code, and perform similar edits across a file in a single pass. The practical workflow is to place carets at each location you want to change, then type or delete once and have the action applied at every caret.

This is useful for tasks such as renaming a local variable in several adjacent lines, adding a prefix to a list of values, or editing repeated markup. The main thing to watch is scope: before typing, confirm every caret is where you intend, because a single keystroke now affects all of them.

Snippets with placeholders and transformations

Commonly used pieces of text or code can be turned into snippets. According to the site, snippets support placeholders, transformations, and more, so they can adapt to the context in which they are used. In practice, a snippet can drop in a code block and let you tab through the parts that change, rather than retyping the fixed structure each time.

Snippets are a good fit for boilerplate you write often, such as function skeletons, import blocks, or repeated documentation patterns. The expected result is less retyping and more consistent structure; the caveat is that a snippet only saves time once it matches how you actually write that code.

Macros for repetitive work

TextMate macros eliminate repetitive work. You can save a macro for repeated use or record a scratch macro for immediate replay. A typical use is a short sequence of edits or cursor movements you perform over and over on similar blocks.

Record a scratch macro when the task is one-off, and save it when you expect to repeat the same sequence later. As with multiple carets, verify the macro on a small case first, since replaying a flawed sequence repeats the same mistake.

Supporting features that help while coding

The site also lists clipboard history, custom themes, live HTML/Markdown preview, foldable code blocks, and indented soft wrap. Clipboard history helps when you need to paste several previously copied items in sequence; foldable code blocks help you collapse sections you are not editing; live preview is useful when writing HTML or Markdown.

How the features fit together

TextMate also supports scoped settings, so one file mixing languages or projects using different build systems can associate detailed scope selectors with key shortcuts and settings. For custom actions, its commands can be written in any language that works with stdin, stdout, and environment variables, with WebKit and a dialog framework available for more complex interfaces. If your main need is fast, repeated text manipulation on macOS, these features are the ones to evaluate first.

TextMate handles per-language and per-project customization through scoped settings: instead of one global configuration, you attach settings, key shortcuts, and commands to scope selectors that describe where they should apply. This lets a single file mixing languages, a project with its own build system, or third-party code with different formatting preferences each get the behavior it needs, without you switching profiles manually. The mechanism is documented on macromates.com as one of TextMate's core features, alongside bundles, commands, snippets, and macros.

How scoped settings work

A scope selector is a pattern that matches the "scope" of the text at the cursor — for example, the language of the current block, or a more specific context inside it. TextMate associates detailed scope selectors with settings and key shortcuts, so a setting only takes effect where the selector matches.

The practical consequence: you define a rule once, and TextMate applies it automatically as you move between regions of a file or between files. You are not toggling modes; the editor resolves which settings apply from the scope under the caret.

The mixed-language file case

macromates.com uses this exact example: "One file mixing languages?" A file that embeds, say, a different language inside a host language produces different scopes in different regions. Because settings are bound to selectors rather than to the whole file, each region can follow its own rules — indentation, formatting, or shortcuts — while remaining one document.

The project and third-party code case

The same mechanism covers two other situations the site names directly:

• Projects using different build systems — settings and shortcuts can be scoped so a project's build-related behavior applies where it belongs.
• Third-party code with different formatting preferences — formatting rules can be attached to the scope of that code instead of changing your defaults everywhere.

Bundles: the customization layer

TextMate uses bundles for customization and, per the site, supports "a countless number of different languages, markup systems, workflows, and more." Bundles are where language support and workflow-specific behavior live, which is why scoped settings scale: the scope vocabulary comes from the language/markup definitions, and the settings and shortcuts hang off those scopes.

Related customization tools worth knowing

Scoped settings are one part of a broader customization set described on the page:

What you need to run it

The download listed on the page is TextMate 2.0, and it requires macOS 10.12 or later. The editor is described as open source and as supporting a large list of programming languages. The page does not state pricing or licensing terms beyond "open source," so check the download page for current details before relying on any assumption about cost.

How to approach customization in practice

1. Identify the scope, not the file. Decide where a behavior should apply — a language region, a project's build context, or a specific kind of third-party code — and treat that as the target.
2. Attach the setting or shortcut to a selector for that scope, so it activates only there.
3. Verify by moving the caret between regions of a mixed-language file or between files; the applied settings should change with the scope.
4. Package language and workflow support as bundles when you want the customization to be reusable rather than one-off.

The common sticking point is expecting file-level or project-level switches; TextMate's model is selector-based, so the selector — not the open document — is what determines which settings win.