# WinCompose brings the X11 compose key to Windows, and stopped shipping in 2021

> A free compose-key implementation for Windows that borrows its rule set from Xorg and dotXCompose, sitting in the system tray, and whose newest published release is more than five years old.

**samhocevar/wincompose** — 🔣 Compose Key for Windows

- Repository: https://github.com/samhocevar/wincompose
- Website: http://wincompose.info/
- Stars: 2,942 · Forks: 106
- Language: C#
- License: NOASSERTION
- Published: 2026-10-07 · Updated: 2026-10-07 · Language: en
- Canonical page: https://hysenlabs.com/projects/samhocevar-wincompose

## A compose key, explained by its own output

A compose key lets you type characters that are awkward on a keyboard layout, using short key combinations. The README demonstrates it with Latin characters first: ö comes from o then a double quote, à from the compose key, a backtick and a, é from the compose key, an apostrophe and e, î from the caret and i, ñ from tilde and n, ø from slash and o, ü from double quote and u. Then the character range widens to ©, ±, ÷, circled digits like ⑦, and symbols including a heart and a hammer and sickle.

That is a genuinely different philosophy from an emoji picker or a character map. No window opens, no search box, no mouse. The sequence is typed in place and the character appears where the cursor is, which means it composes inside whatever application has focus, including applications that have no extension mechanism of their own.

Emoji sequences use a doubled compose key as the prefix, then spell the name out: two compose hits followed by angry gives the frowning face, grinning gives a grinning face, sushi gives a sushi piece, and snake gives a snake. A special Unicode input mode, enabled in the options, takes a hex code and Enter to produce any character at all, such as U+058D or U+23F0.

The implementation language is C#, the project is created by Sam Hocevar, and it is free and open source. The homepage is wincompose.info.

## Installation, the system tray, and why the binaries are unsigned

After installation the program lives in the system tray. You press and release the compose key, which defaults to Right Alt, and the tray icon changes to signal that a sequence is in progress. Typing A then E produces the AE ligature. If Right Alt is wrong for your layout, the options let you change it.

The README offers both an installer and a portable archive for version 0.9.11, with older builds kept in the releases section. For trying it out, the portable zip is the lower-friction option because it leaves the system untouched.

One line in the README is worth reading twice: this software is not digitally signed. It pairs that fact with a link to donate, and in practice it means Windows SmartScreen will warn you on an unsigned installer. That is a real friction point on a current Windows install, and it is the kind of thing that decides whether a utility gets adopted.

There is one piece of good news about privilege. The June 2021 release notes list among the changes the ability to run without elevated privileges, alongside a tweak that disables Caps Lock as soon as the key is released. A tray utility that does not require administrator rights is much easier to deploy on a work machine, where installing elevated software usually needs a ticket.

## 1700 rules from Xorg and dotXCompose, plus your own

WinCompose supports the standard Compose file format and ships more than 1700 compose rules taken from the Xorg project and the dotXCompose project. That is the substantive reason to use it rather than a simpler remapping tool: the rule set is not invented, it is the same one a Linux user gets.

Custom rules go in a file named `.XCompose` or `.XCompose.txt` in the `%USERPROFILE%` folder, and WinCompose has to be restarted for changes to take effect. The restart requirement is worth internalising, since it applies to editing as well as creating the file.

Two behaviours make the sequences behave like the originals rather than like a lookup table. Rules longer than two characters work, so the compose key followed by 3 followed by ) gives ③, which is a real difference from implementations that only pair two keys. And there are early exits: pressing the compose key and then q immediately types a plain q, because no rule begins with q, so the keypress is not swallowed while you reconsider.

The full list of sequences is reachable by clicking the tray icon or using the Show Sequences menu entry, and that window can filter what it lists. A June 2021 release added searching for specific keys in the sequence window using a `key:a` style syntax, which is the practical way to find out what a given key is already mapped to.

The naming convention follows the Compose file format rather than anything Windows-specific, which is why a rule written for a Linux .XCompose file works here unchanged.

## Where state and settings live on disk

Two separate things are stored in two separate places, and confusing them is the usual first misunderstanding.

Settings and sequence metadata both live under `%APPDATA%\wincompose`. Within that folder, `settings.ini` holds the settings and `metadata.xml` holds the metadata associated with sequences. So the tray icon behaviour, the compose key choice and window preferences are in the ini file, while anything about individual sequences is in the XML.

Your own rules are somewhere else entirely. They are a file called `.XCompose` or `.XCompose.txt` in `%USERPROFILE%`, not in the appdata folder:

```text
%APPDATA%\wincompose
settings.ini
metadata.xml
.XCompose
.XCompose.txt
%USERPROFILE%
```

That separation matters for two practical reasons. Backing up your custom rules means copying one file from your profile, not archiving an appdata directory. And if WinCompose stops behaving as expected after an upgrade, the two locations let you tell an application-state problem apart from a rule problem, which is otherwise hard to see from the tray icon.

The tree is small, which suits a utility of this size: `.gitattributes`, `.gitmodules`, `COPYING`, `README.md`, `RELEASE.md`, then `src/`, `tests/` and `web/`. The presence of `.gitmodules` matters for anyone building from source, since the README instructs you to fetch all Git submodules first.

## Building from source needs Visual Studio and Inno Setup

Development instructions are brief. Fetch all Git submodules, open `src/wincompose.sln` in Visual Studio, and you have a build. If you want to produce the installer as well, you also need Inno Setup.

That is the entire toolchain description, and it implies the project targets Windows and Windows tooling specifically. There is no cross-platform build path mentioned, which fits the scope: this is a Windows tray application, and the interesting portability question is handled by other projects entirely.

Bug reports go to the GitHub issue tracker, with email to the author as the alternative. A `tests/` directory exists in the tree, and `RELEASE.md` at the root suggests release notes are maintained in the repository rather than only on the releases page.

The project also has substantial translation coverage, which is more than you would expect from a tray utility. It is described as almost fully translated into Afrikaans, Belarusian, Catalan, Chinese, Czech, Dutch, Estonian, French, German, Greek, Italian, Japanese, Lithuanian, Norwegian, Polish, Portuguese, Brazilian Portuguese, Russian, Sardinian, Spanish and Swedish, and partially translated into Danish, Esperanto, Finnish, Hungarian, Indonesian, Irish, Romanian, Serbian, Slovak and Slovenian. Translation happens through a Weblate project, so adding a language is a pull request rather than a patch to resource files.

## Maintenance reality: 2021 release, 2026 commits

Here is the fact that should drive the decision. The README points at WinCompose 0.9.11, dated September 3, 2021, as the latest download, and that matches the release history in this repository, where the three most recent releases are 0.9.11 from September 2021, a hotfix in June 2021 for a rendering issue in the options window, and a June 2021 release that added key search, the Caps Lock tweak and unprivileged running.

At the same time, GitHub reports 2940 stars, 106 forks, 199 open issues, and a last push on 2026-09-15. So work is landing in the repository while no new binary is being published. Both facts are true at once, and neither the README nor the releases page resolves the tension for you.

The 0.9.11 notes themselves are a decent summary of what kind of maintenance this software has needed: a startup failure caused by a missing `System.ValueTuple.dll`, unwanted debug messages in the log file, interference with monitor sleep, a tooltip appearing at random times, and erratic Scroll Lock behaviour. Every one of those is the sort of bug a global keyboard hook produces on a new Windows build, and the fact that they cluster around runtime integration rather than the compose logic is reassuring about the core.

Practical consequence: if you need Unicode input on Windows today, budget for verifying that 0.9.11 behaves on your Windows build, and read the open issues before you install. If your requirement is a compose key today rather than a maintained one, the alternatives are worth weighing, and several of the SERP searches for this project lead there.

## Conclusion

WinCompose does one job, does it with a rule set most other Windows tools do not have, and does it without demanding administrator rights. The reason to hesitate is not quality but date: the newest published release is 0.9.11 from September 2021, the README still points at that same build, and Windows has changed a great deal since. The good news for anyone evaluating it is that the README, the issue tracker and the source are all still there, GitHub reports a push on 2026-09-15, and the rules are plain text files you can inspect and extend. Start by downloading the portable zip and placing `.XCompose` in your user profile to test your own rules before committing to the installer, and remember the binaries are not digitally signed, which is what SmartScreen will complain about.

## FAQ

### What is a compose key?

A modifier key that starts a short key sequence for typing a character your keyboard layout does not have. Press the compose key, then one or more keys, and the character appears directly in the focused application. On X11 systems this is built in, and WinCompose implements the same idea on Windows using the standard Compose file format.

### How do I add my own compose sequences in WinCompose?

Create a file named `.XCompose` or `.XCompose.txt` in your `%USERPROFILE%` folder and write rules in the standard Compose format. WinCompose has to be restarted for the change to take effect, and your file is separate from the application state, which lives in `%APPDATA%\wincompose` as `settings.ini` and `metadata.xml`.

### Is WinCompose still being maintained?

Work continues in the repository, with GitHub reporting a push on 2026-09-15, but no new binary has been published since version 0.9.11 on September 3, 2021, and the README still lists that build as the latest download. So the source is active while the released artifact is five years old, which is worth checking against the open issues before you rely on it.

## Sources

- [Issues](https://github.com/samhocevar/wincompose/issues)
- [Project website](http://wincompose.info/)
- [README](https://github.com/samhocevar/wincompose/blob/master/README.md)
- [Releases](https://github.com/samhocevar/wincompose/releases)
- [samhocevar/wincompose on GitHub](https://github.com/samhocevar/wincompose)

---

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