# Far Manager: a Windows file manager built as a host for plugins

> A text mode file and archive manager for Windows whose real architecture is the plugin API behind it, shipped under a BSD licence with CI builds for three compilers.

**FarGroup/FarManager** — File and Archive Manager

- Repository: https://github.com/FarGroup/FarManager
- Website: https://farmanager.com
- Stars: 2,233 · Forks: 249
- Language: C++
- License: BSD-3-Clause
- Published: 2026-10-06 · Updated: 2026-10-06 · Language: en
- Canonical page: https://hysenlabs.com/projects/fargroup-farmanager

## A text mode file manager, and why that is the point

The README describes Far Manager as a program for managing files and archives in Windows operating systems, working in text mode and providing a simple and intuitive interface for performing most of the necessary actions.

The three actions named are viewing files and directories, editing, copying and renaming files, and many other actions. That reads like an ordinary file manager until you notice it is a console program. On a modern Windows machine this puts it in a small category alongside Total Commander, which the related search terms suggest is its most common comparison.

Text mode has real consequences. It means the program is scriptable and keyboard-driven, which suits an audience that already thinks in command-line terms. It also means no thumbnail previews or shell extensions, and the interface has to earn its usability through layout rather than through visual affordances.

What the README offers in return is configuration. Far Manager has a multi-language, easily configurable interface, and file system navigation is made easier through the use of colour highlighting and sort groups. Colour as a navigation mechanism rather than decoration is the detail that tells you the intended user: someone moving through large directory listings quickly and needing the relevant entries to stand out.

## Archive support and FTP are plugins, not built-ins

This is the architectural fact that matters most about Far Manager, and the README states it clearly. The functionality is greatly extended by external DLL modules called plugins, made possible by a special set of interfaces, the Plugins API. The examples given are archive support, an FTP client, a temporary panel and a network browser, and all four are described as implemented as plugins included in the standard distribution of Far.

That last clause carries the weight. The distinction between plugins that ship by default and plugins you must find yourself is the difference between a feature and an ecosystem, and Far Manager treats archives and FTP as defaults.

The Plugins API has its own documentation site at api.farmanager.com, linked from the README. A documented plugin interface is what keeps a 1990s-era program architecture alive, and it means third-party work is a supported path rather than a hack. The repository topics reflect the same range, listing `plugins`, `lua`, `shell`, `ftp-client`, `7-zip`, `editor` and `command-line`.

Two languages appear among the topics, Lua and shell, alongside a `far/` directory and a `plugins/` directory in the source tree. The `misc/` and `enc/` directories in the tree are consistent with the encoding and localisation work that a multi-language console interface requires.

## Three compilers, two CI systems, and one gap

The build matrix at the top of the README is the most technical thing in it, and it tells you more about the project's health than the star count does.

Visual Studio builds run on both AppVeyor and Azure Pipelines. GCC builds run on AppVeyor, and the Azure cell reads TBD. Clang builds also run on AppVeyor, with Azure marked TBD.

So the project ships two compiler toolchains on AppVeyor, one compiler on Azure, and is partway through extending the Azure coverage. The CI configurations exist as separate files in the tree: `appveyor.yml`, `appveyor-gcc.yml`, `appveyor-clang.yml` and `azure-pipelines.yml`.

For a C++ project with a long history, supporting three compilers is a deliberate cost. It constrains which C++ features can be used, because anything that only compiles under one toolchain breaks the other builds. It also means portability bugs surface in CI rather than in a user's terminal.

The repository tree also contains `_build/`, an `extra/` directory, and `.editorconfig`, `.gitattributes` and `.gitignore` at the root. An editor config in a project with three compilers is a quiet admission that consistent formatting across toolchains is worth enforcing automatically.

## Releases are continuous integration builds, several per day

The three most recent releases are all tagged with a `ci/` prefix and all fall on the same day, 2026-09-25. They are v3.0.6739.5001 at 20:19, v3.0.6739.5000 at 18:53, and v3.0.6738.4999 at 14:39.

The release bodies are one line each, naming the version and a commit hash. That is what an automated publish looks like, and it has a direct practical implication: there is no release cadence to follow and no changelog to read on the releases page, because every commit that passes CI becomes a tagged build.

For a file manager, that is a reasonable distribution model. Nobody wants a stable channel that lags development by months, and the plugin ecosystem does better when the host program moves often. For anyone tracking changes, the commits mailing list at the farcommits Google group is more useful than the releases.

The default branch is master. The project has 2,231 stars, 248 forks and 158 open issues, and the last push was on 2026-09-25, the same day as the newest release. The repository is not archived, and it is written in C++.

## Community infrastructure around a mature project

The README lists six contact points, which is a lot for a program most people only install once.

There are two support forums, an English one at enforum.farmanager.com and a Russian one at forum.farmanager.com. A bug tracker at bugs.farmanager.com. And three Google groups: fardeven for developers in English, fardev for developers in Russian, and farcommits for commit notifications.

The split between English and Russian developer lists reflects where the project comes from and where its contributors are. Having a Russian and an English forum rather than one forum with two languages is also a meaningful choice, because translation quality in technical discussion is a real problem.

The README is itself multilingual, with translation links at the top for Polski and Русский, and the tree holds `README-PL.md`, `README-RU.md`, matching `CONTRIBUTING-PL.md`, `CONTRIBUTING-RU.md` and `CONTRIBUTORS-PL.md` beside their English counterparts. So localisation is treated as a first-class repository concern rather than left to a translation service, which is the same approach Far Manager takes with its interface languages.

The homepage is farmanager.com.

## Licence, scope and what the README leaves out

The repository is licensed BSD-3-Clause, which is worth noting in a field where older Windows utilities often carry proprietary or unclear terms. That permissiveness is presumably one reason the plugin ecosystem is as large as it is.

The README is a project description rather than documentation. It covers what the program is, that it is extensible through plugins, how to reach the community and where the source lives. It does not describe configuration, key bindings, the panel layout, how to install a plugin, or how to build from source. None of that is a criticism, since the site and the plugin API documentation are the natural homes for it, but it does mean the README will not get you running.

Two topics suggest a scope beyond simple file management. `ofm` is short for Orthogonal File Manager, which was Far Manager's original name, and `winscp` suggests a WinSCP integration plugin. The mention of `7-zip` as a topic aligns with archive support being a plugin rather than a built-in engine.

So the accurate summary is: a console file and archive manager for Windows, extensible through a documented DLL plugin interface, with archive, FTP and network support shipped by default, built in C++ across three compilers, and published as continuous integration builds under a permissive licence.

## Conclusion

Far Manager is a good fit if you want keyboard-driven file work on Windows and do not mind a text interface, and its distinguishing feature is that archive support, the FTP client and the network browser are all plugins shipped in the standard distribution rather than separate downloads. That plugin architecture is also the answer to anyone wondering whether a niche Windows tool is still being developed, since the API has its own documentation site and the source tree keeps a `plugins/` directory. Note that releases are continuous integration builds tagged `ci/v3.0.6739.5001`, several per day, so there is no meaningful version cadence to track, and the CI matrix covers Visual Studio on AppVeyor and Azure while GCC and Clang on Azure are marked as to be determined.

## FAQ

### What is a good free file manager for Windows?

Far Manager is one worth considering if you prefer keyboard-driven, text mode work over Explorer. It is free, licensed BSD-3-Clause, handles archives through plugins that ship in the standard distribution, and is scriptable in a way a shell-integrated file manager is not.

### What does Far Manager do that Explorer does not?

It runs in text mode and is extended through DLL plugins. Archive support, an FTP client, a temporary panel and a network browser are all implemented as plugins included in the standard distribution, and the Plugins API at api.farmanager.com is a documented way to write your own. Navigation also relies on colour highlighting and sort groups.

### How is Far Manager built and tested?

The CI matrix builds with Visual Studio on AppVeyor and Azure Pipelines, with GCC and Clang on AppVeyor, and the Azure cells for GCC and Clang marked TBD. The tree holds `appveyor.yml`, `appveyor-gcc.yml`, `appveyor-clang.yml` and `azure-pipelines.yml`.

### How often is Far Manager released?

Continuously. Recent releases are tagged with a `ci/` prefix and dated the same day, for example v3.0.6739.5001 and v3.0.6739.5000 both on 2026-09-25, each body naming a commit hash. There is no stable cadence to follow; the farcommits Google group is the better place to track changes.

## Sources

- [FarGroup/FarManager on GitHub](https://github.com/FarGroup/FarManager)
- [License: BSD-3-Clause](https://github.com/FarGroup/FarManager/blob/master/LICENSE)
- [Project website](https://farmanager.com)
- [README](https://github.com/FarGroup/FarManager/blob/master/README.md)
- [Releases](https://github.com/FarGroup/FarManager/releases)

---

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