If you use KDE or a distribution like Manjaro, openSUSE, or Fedora with Plasma, sooner or later you'll have encountered KWrite and Kate in the applications menuAt first glance they seem almost the same, and in fact, many people wonder why both are installed, if they are the same app, or if one can be deleted without deleting the other.
The reality is that KWrite and Kate They are two very close “brothers”.They share almost the entire internal engine, but are designed for different uses: one as a lightweight and simple editor, and the other as an advanced editing environment for programming and large projects. Let's take a closer look at what differentiates them, what they have in common, where they come from, and when it's worth using each one.
Origin and relationship between KWrite and Kate
For about twenty years, KWrite and Kate have always gone hand in hand in the KDE ecosystemHistorically, KWrite was the first: a single-window text editor (SDI) that came in early versions of KDE as the typical "powered" notepad.
Over time, one of the main KDE developers decided to create Kate as a multiple document variant (MDI)Designed to work with multiple tabs, more panels, and programming-oriented features, Kate was explicitly created as the most powerful, multi-document version of KWrite.
For many years, Both projects followed somewhat separate development paths.KWrite changed little: it remained a simple editor, with occasional improvements and bug fixes, but without becoming a huge "suite". Meanwhile, Kate received reimplementations of features such as the tab system, session management, advanced plugins, integrated terminal, and project support.
However, the core editing system they both used is the same: the KTextEditor library of the KDE frameworkThanks to this, both KWrite and Kate offer a very powerful editing experience, far superior to a typical plain notepad, even though KWrite may look "basic" visually.
A single codebase: when Kate “eats” KWrite
In recent years an important decision was made regarding the project: Avoid duplicate code and have KWrite directly reuse Kate's codebaseby disabling the more advanced features. This idea arose when they wanted to add tabs to KWrite.
A developer (Waqar, very active in the project) began to implement eyelash support in KWriteThe problem was that the tabs in Kate's repository had already been rewritten several times, both in the core and through plugins, and it didn't make sense to add yet another implementation that would require long-term maintenance.
To avoid that duplication, the team decided that KWrite would not have an independent codebasebut would use the same core as Kate with a "cropped" mode. KWrite is now built as a kind of Kate simplified with no sessions, no plugins, and the cleanest interfaceTechnically, what changes between the two is mainly the main function and some checks in the shared code to activate or hide parts of the interface.
Thanks to this change, Approximately one thousand lines of KWrite-specific code were removed. And only a few lines of code had to be added to the common code. The result is that both editors share virtually all of their logic, including the modern tab system, command-line parameter parsing, and basic editing behavior.
However, even though they have unified the internal base, KWrite still has its own personalityIt doesn't share instances between windows, it doesn't have session management, it doesn't load advanced plugins, it doesn't offer an integrated terminal or server language (LSP), among other things. If you want those features, you'll have to go with Kate.
KTextEditor: the common editing engine
Both KWrite and Kate They rely on the same editing library, KTextEditor, part of the KDE framework. This library provides almost all the powerful editing "magic" you see in both programs, and is also used by other applications such as KDevelop and other KDE IDEs.
This means that The pure experience of writing, selecting, highlighting, and manipulating text is virtually identical. between KWrite and Kate. If you get used to one, you'll have no trouble using the other or even KDevelop, because the behavior of the text area is consistent across the entire family.
Thanks to KTextEditor, both editors have syntax highlighting for countless languages, analysis of specific modes (for example, Markdown supportHTML, Python, C, etc.), editing tools such as automatic indentation, line numbering, document mini-view, and other features that go far beyond a plain editor.
Installation and distribution on different systems
In general, if you use KDE Plasma, Most likely, you already have KWrite installed by default.Kate, on the other hand, you may have to install it manually, depending on the layout.
On RPM-based systems like Fedora, it's as simple as running something like sudo dnf install kwrite kateIn other distributions, the packages have the same or very similar names. Furthermore, Both are published independentlyKWrite is available at apps.kde.org/kwrite and Kate at apps.kde.org/kate.
In the KDE ecosystem, You can install them from Discover within the desktop itself.KWrite is also distributed as a Flatpak for environments where you prefer this type of self-contained package. In Manjaro, for example, you'll see them in Pamac as separate programs, even though they largely share source code and dependencies.
An important detail is that They do not depend on each other as packagesIn other words, you can have just KWrite, just Kate, or both at the same time without them interfering with each other, without configurations getting mixed up, and without direct dependency conflicts. They work like "well-behaved twins."
KWrite: a lightweight editor, but not at all cheap.
If you open KWrite expecting something like memo pad extremely limited, you're going to be surprised, because It's a lightweight editor but with quite a few advanced features.You can launch it from the applications menu and start writing as is, saving individual texts, notes, small scripts, etc.
Among the functions traditionally attributed to it are: HTML export, selection mode lock, code tracking, and bookmarksAll of this makes it very useful for both note-taking and informal code editing. It also offers word autocompletion and other writing aids.
Available Configurable syntax highlighting for multiple languagesIt also offers line ending mode selection (Unix, Windows, Macintosh) and the option to choose the text encoding. While it doesn't always automatically detect the file's encoding, often using the system default when opening files, you can manually change it if needed.
Another cool feature is that It allows working with remote files through protocols such as FTP or fish.integrating with the KDE network infrastructure. This makes it easy to edit files located on servers without needing to set up complicated external solutions.
KWrite also includes the option to use different components thanks to KParts technology (In older versions, this was a significant innovation.) This allowed embedding, for example, a Konsole console within the editor, or other components. Later, the Kate engine was adopted as the default text editor, solidifying this integration.
In the historical context of KDE, KWrite was part of the kdebase package And, more recently, it's distributed alongside Kate, with its code in a dedicated subdirectory of the repository. All of this reinforces the idea that it's not a completely separate project, but rather a different facet of the same underlying technology.
Shared features: bookmarks, highlighting, and more
Since both KWrite and Kate are based on KTextEditor, they share some tools that make a significant difference compared to very basic editors. For example, You can use temporary bookmarks to move quickly through the document.
With a simple keyboard shortcut, like Ctrl+B to create a bookmarkYou can then jump to them from the bookmarks menu. They aren't saved within the file (they don't modify the actual content), but while you're working, they're an elegant way to mark important sections. Much more practical than leaving random words like "foobar" in the text and having to search for them later, which you might eventually forget to delete.
Another key function is the syntax highlighting and document modesFrom the tools menu, you can activate automatic spell checking, which highlights errors with underlines, and choose specific modes for particular formats: Markdown, HTML, Python, C/C++, etc. Each mode applies a different highlighting scheme to help you read and better understand the content.
If you want to get more specific, you can directly choose the highlighting type regardless of the modeThis is in case you want to force a specific visual scheme. This kind of flexibility means that the same editor can be used both for writing plain text and for quickly debugging a code snippet.
In addition, many users especially appreciate The document overview is on the right side.A kind of vertical thumbnail of the entire text. Although it looks small, it's surprisingly useful for locating sections, titles, or snippets of code and jumping to the approximate area with a single click.
What does Kate offer that KWrite doesn't?
The big question is: if "pure and simple" text editing is almost the same, Why switch from KWrite to Kate? The answer lies in everything surrounding the text when you work as a programmer or with complex projects: panels, plugins, sessions, and the terminal.
Kate adds one sidebar where you can view the file system or a project directoryFurthermore, it handles the concept of "project", so it can relate files to each other (for example, a .cpp with its .h, or several configuration files of the same module) and offer you smarter navigation between them.
Also includes a integrated terminal that is deployed with a key (usually F4)This allows you to run commands, compile, launch scripts, or use console tools without leaving the editor itself. You can even send the document's contents directly to the terminal, which saves a significant amount of time for development and scripting.
Another plus is the session managementKate can save different configurations of windows, tabs, open projects, and preferences, so you have different profiles for each type of work (for example, one environment for C++, another for web editing, another for documentation notes, etc.).
Also, Kate It supports a wide variety of plugins These add advanced features: integration with language servers (LSPs) for intelligent autocompletion, static analysis, enhanced terminals, debugging, language-specific tools, and much more. This ecosystem of extensions is what, in practice, makes Kate a kind of mini-IDE for many developers.
For all these reasons, many users describe Kate as a very complete tool for programmersKWrite, while seen as the "clean" editor for quick or simple tasks, still has powerful options under the hood.
Practical differences in interface and behavior
When you compare the two windows side by side, you realize that KWrite's interface and Kate's interface are almost identical. in the elements they share: toolbar, text area, side mini-view, basic menus… The main difference comes from the additional panels and views.
In KWrite You won't see the side tool views These features do appear in Kate for the project explorer, docked terminal, and other plugin-derived panels. The default settings for the toolbar and URL bar (file path) also change; these can be enabled or disabled depending on the mode.
At a behavioral level, KWrite It does not share instances or sessionsEach time you open it, it's like a standalone editor and doesn't get involved in advanced session management. It also doesn't load complex plugins, so you won't have some of the "fancy" features that Kate offers.
In both you can use tabs with very similar behaviorOpening multiple documents, quick opening, splitting the view into panels, etc., is a significant improvement over the strict single-window version of KWrite from 20 years ago. Today, thanks to code sharing with Kate, KWrite can support tabs without burdening the other features.
Real-world use: from light editing to professional development
Among KDE users there are fairly clear opinions about when it makes sense to use KWrite, Kate or even KDevelopIn general, KWrite is seen as the lightest, KDevelop as the heaviest geared towards large projects, and Kate as somewhere in between, ideal for the day-to-day work of programmers who don't need a mega-IDE.
Many people new to KDE ask which one to choose, and the usual answer is something like this: If you just want to edit text, take notes, or play some scripts or configuration files, KWrite is more than enough.If you program regularly, handle many files, and appreciate features like projects, an integrated terminal, and sessions, then Kate is a much better fit.
There are even users who, even without using KDE as their primary desktop environment, They continue to rely on KWrite because they like its balance between simplicity and power.A typical example is someone in XFCE who maintains some KDE applications like Krusader or KWrite because they are essential to them, and adjusts the dependencies to avoid what they consider "bloat" (components like kactivities, knewstuff or kuserfeedback if they don't take advantage of them).
There are also cases of people trying look for non-KDE alternatives to KWrite (like certain standalone GTK or Qt editors) and, when testing them, they find they lack key features such as block editing mode (partial vertical selection of lines) or robust behavior when commenting multiple lines. Until they find a replacement that fulfills all these functions, they end up sticking with KWrite as their primary tool.
Other editors in the KDE environment: KDevelop and KEdit
Within the KDE ecosystem, not everything is KWrite and Kate; There are other applications related to text editing and development, like KDevelop or the veteran KEdit.
KDevelop is a Full IDE, much heavierDesigned for large projects, complex refactoring, integrated debugging, wizards, and a wide range of tools, it also leverages KTextEditor as its editing engine. So, the writing experience will feel familiar if you're used to Kate or KWrite, but in terms of interface and resource requirements, it's in a completely different league.
KEdit, for its part, It still exists in some environments as an alternative editor.One of its historical features is its support for bidirectional text, relevant for right-to-left languages. It was once part of the kdeaddons package and served a specific niche in terms of text type.
In any case, the average KDE user today mostly operates within KWrite as a lightweight editor, Kate as an advanced editing environment And, when you need even more, KDevelop as a specialized IDE.
Licensing, technology and maintenance
On a technical level, KWrite (and by extension Kate) It is written in C++ using Qt for the interface. and distributed under the LGPL license. This makes it free software, integrable into other projects, and maintained by a fairly large team of developers within the KDE community.
Their code repositories are hosted on the KDE infrastructure and mirrored on platforms like GitHubThis applies both to the editor itself and to the underlying frameworks, such as KTextEditor and KSyntaxHighlighting. There are also bug tracking systems where errors can be reported and their resolution monitored.
The team constantly encourages that new collaborators join the developmentWhether it's to add features, polish details, or improve performance, the fact that KWrite and Kate now share almost all of their code means that every fix or improvement automatically impacts both editors, reducing duplicate effort and increasing overall quality.
In practice, this translates into Every small improvement that enters the repository benefits the entire KDE editor ecosystemnot only to Kate and KWrite, but also to the applications that use their frameworks, reinforcing their role as a reference within the Plasma desktop.
Looking at the whole picture, for an end user of KDE it's hard to find a better balance today between a lightweight but powerful editor like KWrite y a versatile development tool like Kateespecially knowing that both run in parallel, share the same foundation, do not conflict with each other, and cover everything from the simplest use of notepad to very demanding programming workflows.
