# pyfa for EVE Online Ship Fitting and Loadout Planning

> pyfa is an open source Python desktop fitting assistant for EVE Online. It lets players create, experiment with, and save ship fittings outside the game on Windows, macOS, and Linux.

**pyfa-org/Pyfa** — Python fitting assistant, cross-platform fitting tool for EVE Online

- Repository: https://github.com/pyfa-org/Pyfa
- Stars: 1,804 · Forks: 469
- Language: Python
- License: GPL-3.0
- Published: 2026-10-16 · Updated: 2026-10-16 · Language: en
- Canonical page: https://hysenlabs.com/projects/pyfa-org-pyfa

## Why pyfa Exists for EVE Online Pilots

pyfa addresses the part of ship fitting that happens before a pilot commits to a configuration in EVE Online. The README describes it as a Python fitting assistant whose purpose is to create, experiment with, and save fittings without being in game. That makes it useful for pilots, fleet planners, and players who want to compare equipment choices while outside the game. It also gives a player a persistent place to record a configuration instead of rebuilding it from memory during a later session.

The tool is tied to EVE Online rather than being a general-purpose inventory or loadout editor. Its repository includes directories and packages such as `graphs/`, `staticdata/`, `service/`, `gui/`, and `eos/`, which matches a desktop application that combines game-related data with a graphical interface. The README identifies the application as cross-platform and says it is available on Windows, macOS, and Linux wherever Python 3 and wxWidgets are available.

There is a clear boundary around the product. pyfa is for planning and experimentation with fittings. The README does not claim that it automates actions inside EVE Online, reads live game state, or replaces the in-game fitting interface. A player who needs an immediate in-game decision still has to use the game itself. pyfa is more relevant when the configuration needs to be prepared, reviewed, or saved beforehand.

## How pyfa's Python and wxWidgets Structure Fits the Job

The repository layout shows a desktop application with separate areas for the interface, data, services, graphics, localization, and tests. The `gui/` directory is consistent with an application built around a graphical user interface. The project description and topic list identify Python and wxPython as the primary implementation technologies. pyproject.toml requires Python 3.12 or later and declares the wxPython dependency through optional dependency groups.

The dependency configuration also shows that the project is not a minimal script. It uses `numpy`, `matplotlib`, `sqlalchemy`, `requests`, `python-jose`, `beautifulsoup4`, `pyyaml`, and other libraries. The presence of `graphs/` and the plotting dependency suggest that the application includes visual representations, although the README does not document the exact controls or graph formats. `db_update.py`, `staticdata/`, and `service/` indicate that repository and service responsibilities are separated rather than placed in one entry-point file.

The top-level `pyfa.py` file is the application entry point, while `config.py` and `version.yml` support configuration and versioning. pyproject.toml explains that tools read the version from `version.yml`, so the version field in pyproject.toml is described as a fake version for tooling purposes. This distinction matters to contributors and packagers: changing the package metadata alone does not establish the application release.

## Installing pyfa on Windows, macOS, and Linux

For most users, the documented installation path is a self-contained build from the project's releases page. The README says that Windows, macOS, and Linux users are supplied with these builds. That route is the clearest first choice because it does not require the reader to assemble Python and wxWidgets first. The releases page also provides the latest version and release notes, and the README says pyfa notifies users when they run an outdated version.

On macOS, the README also documents a third-party Homebrew cask. It is important to distinguish this from an official pyfa release: the README says the Homebrew package is maintained by a third party and is not evaluated by the pyfa developers. The documented command is:

```bash
brew install --cask pyfa
```

After the installation completes, the reader should expect a local pyfa application available through the platform's normal application launch path. The README does not specify a first-launch wizard, account login step, database import command, or exact fitting-creation menu sequence, so those details should be taken from the installed application rather than inferred.

For Linux distributions, the README names an Arch package and a Gentoo overlay. These are distribution-specific options maintained outside the main project documentation, so the package source and its update policy should be checked before installation.

## A First Fitting Workflow and Its Documented Limits

pyfa's documented workflow starts outside EVE Online. A user can launch the application and use it to create a ship fitting, try alternative equipment choices, and save the result for later. The README does not provide a command-line interface or a scripted import example for this process, so a precise tutorial cannot go beyond the supported workflow without inventing menu names or file formats.

The first practical use is therefore version-independent: obtain a supported build, launch pyfa, create a fitting, compare changes, and save it. The repository's static data and database update components suggest that game information is part of the application setup, but the README does not say whether a new installation performs that update automatically or whether the user must run a separate command. It also does not document how a saved fitting can be transferred into the game.

That silence matters for adoption planning. pyfa is attractive for offline experimentation, but users who require a documented export-to-game procedure should confirm the expected workflow with the current application and release notes before depending on it. The project does not present pyfa as an automation tool for changing a live EVE Online session.

## Maintenance Signals and Dependency Upgrade Work

The repository is not archived. Its last push was on 2026-10-08, and the recent releases listed for the project include `v2.69.2` on 2026-10-08, `v2.69.1` on 2026-10-06, and `v2.69.0` on 2026-09-22. These dates and releases indicate recent project activity based on the repository history, but they do not by themselves establish that every supported platform receives identical updates.

The upgrade surface is visible in pyproject.toml. The project requires Python `>=3.12` and pins many dependencies, including `numpy==2.5.1`, `matplotlib==3.11.1`, `requests==2.34.2`, `sqlalchemy==2.0.51`, and `cryptography==50.0.0` for platforms other than Intel macOS. Intel macOS uses `cryptography==48.0.1` because the project comment explains that newer versions no longer publish Intel macOS wheels and can raise the minimum macOS version when built locally.

The wxPython setup also has separate binary and source groups. Linux CI can use a binary `wxPython` package, while local builds can use a source group linked against system libraries. These choices create packaging work beyond application code. Contributors using `uv` should read the full pyproject.toml because the visible file is truncated, especially if they change dependencies or build on Linux or Intel macOS.

## GPL-3.0 Licensing and Platform Boundaries

pyfa is released under the GNU GPL v3.0. The README points readers to the `LICENSE` file, and pyproject.toml declares the package license as `GPL-3.0-or-later`. That metadata makes the licensing intent explicit, although it does not answer every question about distribution, modification, or how a particular deployment must provide source code. The license file should be reviewed for those decisions.

The project also includes a CCP Copyright Notice. The README states that EVE Online, its logos, and related artwork and designs belong to CCP, and that CCP has permitted pyfa to use them for promotional and information purposes without endorsing or affiliating itself with pyfa. This distinction matters for anyone considering a fork, branded build, or redistribution involving game assets. The repository's code license and the permission covering CCP-owned visual material are separate topics.

The practical platform boundary is equally concrete. Official or self-contained builds are documented for Windows, macOS, and Linux. Source execution is possible where Python 3 and wxWidgets are available, but the README points contributors to `CONTRIBUTING.md` for interpreter-based instructions. pyfa is not documented as a mobile application or a headless service.

## Why pyfa Differs from Manual Planning

The closest documented alternative is recording and comparing fittings manually, such as with notes or a spreadsheet, rather than using a dedicated fitting assistant. The difference is structural: pyfa is an application designed around EVE Online fittings, with a graphical interface, game-related static data, services, and persistence for saved configurations. A manual process may serve someone who only needs a short list of ship names and modules, but it does not provide pyfa's fitting-specific model or its dedicated experimentation workspace.

This comparison has limits. The README does not quantify the amount of configuration work saved, and it does not document a comparison feature, collaboration system, or automatic synchronization with other players. Those claims should not be inferred from the word assistant. The clear alternative is simply not using a specialized desktop application for planning.

pyfa is the better fit when the configuration is recurring, detailed, or worth retaining. It is the wrong choice when the user needs only a quick temporary note, or when the requirement is to operate directly inside the live game. Its value comes from having a dedicated place to create and save the fitting, not from replacing every part of EVE Online.

## Conclusion

Adopt pyfa if you plan EVE Online ship loadouts outside the game and want an open source desktop tool with saved fitting data. Do not choose it as a substitute for in-game fitting execution, because the README describes planning and experimentation rather than controlling the game. Verify first that your operating system has a supported release build or development setup, and check the project releases before relying on a specific version.

## FAQ

### How do I install pyfa on macOS?

The README documents a third-party Homebrew cask. The documented command is `brew install --cask pyfa`, while the project also supplies self-contained macOS builds on its releases page.

### Does pyfa let me plan EVE Online fittings outside the game?

Yes. The README says pyfa allows users to create, experiment with, and save ship fittings without being in game.

### What platforms does pyfa support?

The README says pyfa is available on Windows, macOS, and Linux. It also describes the application as available wherever Python 3 and wxWidgets are available.

### What license is pyfa released under?

pyfa is licensed under the GNU GPL v3.0. The README points to the `LICENSE` file, and pyproject.toml declares `GPL-3.0-or-later`.

### Does pyfa have a documented command-line workflow?

The README provides release-build and Homebrew installation instructions, but it does not document a command-line fitting workflow or a scripted fitting export. It describes a graphical fitting application.

## Sources

- [Issues](https://github.com/pyfa-org/Pyfa/issues)
- [License: GPL-3.0](https://github.com/pyfa-org/Pyfa/blob/master/LICENSE)
- [pyfa-org/Pyfa on GitHub](https://github.com/pyfa-org/Pyfa)
- [README](https://github.com/pyfa-org/Pyfa/blob/master/README.md)
- [Releases](https://github.com/pyfa-org/Pyfa/releases)

---

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