# CotEditor: a macOS-native plain text editor built on NSTextView

> CotEditor is an Apache-licensed Swift text editor for macOS that follows Cocoa document conventions instead of inventing its own. It is a good fit for people who want a familiar Mac app for plain text, and a poor fit for anyone who needs Windows or in-editor project tooling.

**coteditor/CotEditor** — Lightweight Plain Text Editor for macOS

- Repository: https://github.com/coteditor/CotEditor
- Website: https://coteditor.com
- Stars: 8,528 · Forks: 538
- Language: Swift
- License: NOASSERTION
- Published: 2026-09-21 · Updated: 2026-09-21 · Language: en
- Canonical page: https://hysenlabs.com/projects/coteditor-coteditor

## The problem CotEditor solves, and who it is for

macOS ships with TextEdit, which is a rich text editor first and a plain text editor second. CotEditor takes the opposite position: the README describes it as a "lightweight plain text editor designed for macOS" whose goal is to be a general plain text editor with "an intuitive macOS-native user interface." That framing tells you who the intended user is. Someone who edits configuration files, notes, scripts, or legacy text formats and wants the app to behave like every other Mac application they already use.

The design philosophy section is unusually explicit about what that means in practice. CotEditor adopts "system-native UI components, conventions, and behaviors" and the README states that features deviating from standard macOS behaviour "may be rejected, even if they're common in other editors." That is a deliberate constraint, not a gap. If you have used an editor that reimplements its own file browser, its own tab strip, and its own keyboard model, you know the friction that follows. CotEditor trades that customisation surface for predictability.

The second stated principle is accessibility across skill levels: simple enough for casual use, precise enough for "experienced editors and developers." The third is "less is more," with the README arguing that minor options accumulate into decision-making burden. Read together, these principles describe a tool that will lose feature comparisons against heavier editors and will not apologise for it.

## How CotEditor is built: Swift, Cocoa documents, NSTextView

The architecture is stated plainly. CotEditor is "a purely macOS native application written in Swift" that "adheres to Cocoa's document-based application architecture and respects the power of NSTextView and related text system APIs."

That single sentence explains most of the editor's behaviour. Document-based architecture means each open file is an NSDocument-style document with the usual macOS semantics: the proxy icon in the title bar, autosave and version browsing, the standard revert and duplicate commands, and per-document windows. Because the text surface is NSTextView, the editor inherits the system text system rather than replacing it. Input methods, dictation, the emoji and character viewers, Services, and accessibility APIs come from the platform. For users of languages that need complex input method editing, that inheritance matters more than any bespoke text engine.

The README also states that the project handles "a wide range of plain text formats accurately," prioritising "correct text handling, encoding support, and predictable editing behavior" from everyday notes to "niche or legacy formats." Encoding handling is where plain text editors earn or lose trust, and it is listed as a design principle rather than a feature bullet.

Development environment requirements are listed as macOS 27, Xcode 27, with sandbox and hardened runtime enabled. The repository layout matches that: an Xcode project at CotEditor.xcodeproj, a Configurations directory holding xcconfig files, plus Packages, Scripts, Tests, UI Tests, and Test Plans directories.

## Installing CotEditor and editing a first file

The README does not give a command-line installation procedure. It points to two distribution channels: the project web site at coteditor.com and the Mac App Store listing. The web site also hosts an Archives page, which the README recommends for people on an older macOS release: "please use the latest compatible version available from the Archives." It notes that this is also "the most stable version for your system, as it includes the final updates and fixes for that macOS release." So the first decision is which macOS you are on, because the current version requires macOS Tahoe 26 or later.

Once installed, the first real task is opening a file and checking that the encoding was detected correctly. There is no CLI to demonstrate in this material, so the honest starting point is the app itself: launch CotEditor, open a file through the standard Open dialog, and inspect the document's encoding in the inspector or status area.

Building from source is documented, and it is a two-path process. For a local build, the README says to open the Xcode project, switch to ad-hoc signing, and build the CotEditor scheme:

```bash
# 1. Open CotEditor.xcodeproj in Xcode
# 2. Edit Configurations/CodeSigning.xcconfig
#    and uncomment this line:
#include "CodeSigning-AdHoc.xcconfig"
# 3. Build the "CotEditor" scheme
```

For a distribution build, the README gives a shorter path: open CotEditor.xcodeproj in Xcode and build the CotEditor scheme, with no ad-hoc signing change. The difference between the two is the code signing configuration, and the ad-hoc include line is the only edit involved in the local case. Note that the file lives under Configurations/, not at the repository root, and that the include line is commented out by default.

If you build from source rather than installing from the App Store, expect to supply your own signing identity for anything beyond local use. The README does not document notarisation steps.

## The macOS version policy is the real constraint

CotEditor supports "the latest two major macOS releases." The README is direct that this is a long-standing policy and "is not evaluated on a per-release basis." The stated reason is that supporting more versions "would significantly increase the testing and maintenance burden, making it harder to deliver both new features and reliable updates."

This is the limitation most likely to affect a real decision. If you are on a macOS release older than the latest two, the current version will not run for you, and the README's answer is the Archives page. That is a reasonable answer, but it means you are on a frozen build with no further fixes. For an individual editing notes, that is fine. For a team standardising on an editor across machines that cannot all be upgraded on the same schedule, it is a hard blocker, and it is worth checking your fleet's macOS versions before you plan around CotEditor.

The requirement line compounds this: macOS Tahoe 26 or later. A user on an older release gets no current build at all.

The second limitation is scope. The README describes a general plain text editor and says nothing about project-wide indexing, build integration, debuggers, or language servers. If your work depends on jumping to definitions across a repository or running a test suite from inside the editor, CotEditor is the wrong tool, and the design philosophy suggests that is intentional rather than a roadmap gap.

## CotEditor compared with BBEdit and Sublime Text

The comparison that comes up most often is with BBEdit, and the difference is architectural. BBEdit is a long-standing Mac text and code editor with its own feature set built up over decades. CotEditor's README makes the opposite bet: instead of accumulating features, it defers to the platform, adopting system-native components and rejecting behaviour that deviates from macOS conventions. If you want an editor that behaves like a Mac app and stays out of the way, that bet favours CotEditor. If you want a deep set of text-processing tools and a scripting surface, BBEdit's approach is the one that accumulated those.

Against Sublime Text, the split is cross-platform versus native. Sublime Text runs on macOS, Windows, and Linux with its own UI toolkit and its own extension ecosystem. CotEditor is macOS only. That is a genuine trade-off in both directions: a single editor across three platforms is valuable for teams, and a single-platform editor that inherits NSTextView, system input methods, and accessibility is valuable for individuals on Macs. The README's localization list, covering English, Simplified Chinese, Traditional Chinese, Chinese (Hong Kong), Czech, Dutch, English (UK), French, German, Italian, Japanese, Korean, Polish, Portuguese, Russian, Spanish, and Turkish, is the kind of thing that comes from using macOS's localization machinery rather than building your own.

Neither comparison is settled by feature counts. The deciding question is whether you want the editor to be a Mac app or a portable platform.

## Licence, maintenance and upgrade cost

The source code is licensed under the Apache License, Version 2.0. Image resources are licensed separately under the Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International License, and the README points to LICENSE for details. The repository's licence field reads NOASSERTION, which is a signal that the split licensing is not captured by a single SPDX identifier. If you plan to redistribute CotEditor or reuse its assets, the image licence is the part to read carefully; the non-commercial and no-derivatives terms are narrower than the Apache terms covering the code. That is a description of the terms as stated, not legal advice.

On maintenance, the last push to the repository was on 2026-09-21, and the most recent release listed is 7.1.0 from 2026-09-12, preceded by 7.0.9 on 2026-09-05 and 7.0.8 on 2026-08-06. Releases are arriving on a short cadence.

Upgrade cost is dominated by the macOS version policy. Because only the latest two major releases are supported, a macOS upgrade can move you from a supported build to the current one, and an older machine can fall out of support entirely. The mitigation is the Archives page, which the README recommends, but it is a static fallback rather than a maintained branch. Budget for that when you standardise on CotEditor across machines you do not control.

## Conclusion

Adopt CotEditor if you work primarily with plain text on a current macOS release and want a document-based Cocoa app rather than a project IDE. Do not adopt it if you need Windows or Linux builds, or if your workflow depends on an integrated build and debug loop; the README describes a general plain text editor, not an IDE. Before committing, check the requirement line for macOS Tahoe 26 or later, confirm your machine is on one of the two supported macOS releases, and read the licence split between the Apache 2.0 source and the CC BY-NC-ND 4.0 image resources.

## FAQ

### Is CotEditor open source?

Yes. The source code is licensed under the Apache License, Version 2.0, while image resources use the Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International License.

### How do I install CotEditor?

The README points to the Mac App Store listing and the project web site at coteditor.com. It does not document a command-line installation method.

### What is CotEditor?

It is a lightweight plain text editor designed for macOS, written in Swift and built on Cocoa's document-based application architecture and NSTextView.

### Is CotEditor free?

The source code is available under the Apache License, Version 2.0, and the README lists a Mac App Store page as one of the distribution channels. The README does not state a price.

## Sources

- [coteditor/CotEditor on GitHub](https://github.com/coteditor/CotEditor)
- [Issues](https://github.com/coteditor/CotEditor/issues)
- [Project website](https://coteditor.com)
- [README](https://github.com/coteditor/CotEditor/blob/main/README.md)
- [Releases](https://github.com/coteditor/CotEditor/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/coteditor-coteditor