Development
Everything you need to build, run and release eve-online-tooling from source. For what the app is and how to install a prebuilt binary, see the README.
Built with Tauri 2 (Rust core) + React / TypeScript (Vite). Market and character data come from EVE’s ESI API; blueprint/material data from the SDE.
Getting started
1. Install prerequisites
- Node.js
^20.19.0 || >=22.12.0(the floor of the locked Vite 7; CI and releases use 26) and npm. - Rust via rustup:
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh - Linux only — WebView/build libraries (without these the Rust build fails at
glib-sys):sudo apt-get update && sudo apt-get install -y libwebkit2gtk-4.1-dev build-essential \ curl wget file libxdo-dev libssl-dev libayatana-appindicator3-dev librsvg2-dev pkg-config(macOS: Xcode command-line tools. Windows: the WebView2 runtime + MSVC build tools.)
2. Install dependencies
npm install
3. Run the app
npm run tauri dev # launches the desktop app with hot reload
The first time you open the Production module it downloads the EVE SDE (a few hundred MB, Fuzzwork’s SQLite build) into your app data dir; that’s a one-off.
No audio /
GStreamer element appsink not foundon Linux? The WebView plays audio (the Scriptsplay_sound) through GStreamer. A snap terminal (e.g. Alacritty-as-snap) exportsGST_PLUGIN_SYSTEM_PATH/GST_PLUGIN_SCANNER/LD_LIBRARY_PATHpointing at its own sandbox, which lacks those plugins. The app now strips those snap paths at startup so audio works regardless; if you still hit it (an unusual snap layout), launch from a non-snap terminal or run:env -u GST_PLUGIN_SYSTEM_PATH -u GST_PLUGIN_SCANNER -u GST_PLUGIN_PATH_1_0 -u LD_LIBRARY_PATH npm run tauri dev.
4. EVE SSO
Logging a character in works out of the box: the app ships with its own public
EVE developer-application Client ID (CLIENT_ID in
src-tauri/src/esi/oauth_exchange.rs, native PKCE, no secret) and the loopback
callback http://localhost:8765/callback. The requested scopes are the SCOPES
list in the same file. Only if you point a fork at your own application at
developers.eveonline.com do you need to
register your own Client ID, that callback, and enable every scope in SCOPES
(SSO rejects the whole login otherwise). Not required for the market/production
calculations, which use public data.
Common commands
| Command | What it does |
|---|---|
npm run tauri dev |
Run the desktop app (hot reload) |
npm run tauri build |
Build distributable bundles |
npm run build |
Type-check + build the frontend |
npm run generate:bindings |
Regenerate the tauri-specta TS bindings (CI fails if the committed files drift) |
node scripts/check-tauri-versions.mjs |
Check Tauri crate/npm major.minor versions match in the lockfiles |
npm run test |
Frontend unit tests (Vitest) |
cd src-tauri && cargo test |
Rust unit tests |
Every PR runs two GitHub Actions workflows: CI
(.github/workflows/ci.yml) — the merge gate: lint, format, tests,
npm run build, the bindings drift check, the Tauri version-alignment check,
cargo fmt/clippy/test. npm run tauri build is not part of every PR:
a Linux tauri build --bundles appimage,deb job runs only for release PRs
(chore/v*) and PRs/pushes that touch Cargo.toml, Cargo.lock,
package.json, package-lock.json or tauri.conf.json. Windows/macOS-only code
is compiled only by the post-merge cache warm and the Release workflow. And Security
(.github/workflows/security.yml) — CodeQL (JS/TS + Rust) and dependency
audits (npm audit, cargo audit). Security also runs weekly against
main, so newly-disclosed advisories surface without a new PR. Its audit
jobs are currently informational (continue-on-error) rather than merge-
blocking, since the existing dependency tree has known advisories that need
a deliberate, tested bump rather than a silent CI-driven one — flip that off
once those are triaged.
SDE-gated tests (fitting golden suite)
The fitting engine’s golden tests (modules::fitting::golden_tests and the
other tests that need game data) run against the real Fuzzwork SDE. Point
EVE_SDE_PATH at the sde.sqlite file — the one the app downloaded, e.g.
~/.local/share/com.thlange.eve-online-tooling/sde/sde.sqlite (Linux), or any
decompressed copy of https://www.fuzzwork.co.uk/dump/latest-sqlite.db.gz:
EVE_SDE_PATH=~/.local/share/com.thlange.eve-online-tooling/sde/sde.sqlite \
cargo test --manifest-path src-tauri/Cargo.toml --lib modules::fitting
Without the variable those tests print a “skipping” note and pass; with it set
to a path that isn’t a file they fail. The shared helper
test_support::test_sde() (src-tauri/src/test_support.rs) opens the file and
derives the app-data directory the engine expects (<dir>/sde/sde.sqlite; a
temp-dir symlink is made when the file lives elsewhere) — use it for any new
SDE-gated test rather than reading the variable yourself. The
Fitting (real SDE) workflow (.github/workflows/fitting-sde.yml) runs them
in CI on PRs touching src-tauri/src/modules/fitting/** or
src-tauri/src/sde/**, on pushes to main and weekly (the SDE archive is
cached by Fuzzwork’s md5, so it only re-downloads when the dump changes).
See CLAUDE.md for architecture and EVE domain notes, and the
other docs for subsystems: plugins, scripts,
MCP.
Implementation notes
- App shell — Tauri 2 + React/TS, module-based navigation. The sidebar groups modules into labelled sections (Industry · Trading · Market · Character · Combat/Intel · Support), with drag-to-reorder, pinning and per-module colour tags. A ⌘K / Ctrl+K command palette fuzzy-jumps to any module and looks up any item type (routing to Market Search).
- SDE service — download/verify the Fuzzwork SQLite; query blueprint materials, products, and type info. The static data only re-downloads when Fuzzwork’s published md5 changes, with a best-effort daily check on startup.
- Market service — live ESI prices as a multi-vector model (spot sell/buy, daily average, N-day moving average, volume), cached.
- Conditional ESI caching — all ESI traffic flows through one client that
revalidates with ETags (cheap
304 Not Modified), honours each response’s cache timer, persists across restarts, and backs off ESI’s error budget. Data pages show an “Updated N ago” freshness label. - Production engine — ME-adjusted material cost + EIV job fee + revenue → profit/margin/per-unit, with recursive build-vs-buy down the component tree, T2 invention (datacores + job fee + BPC copy, over success probability), T3 relics, and a per-material drill-down. Validated against EVE-Guru-style output.
- Fitting engine — a data-driven dogma engine validated exact against PYFA
across a golden test suite (DPS, ranges, EHP/resists, cap sim, speed/align,
targeting; implants/boosters, T3 subsystems, projected effects). Fleet
boosts (command/expedition/mining bursts, #1279) are modelled as warfare
buffs: a burst charge names buff IDs + magnitudes, and
engine/warfare_buffs.rsholds the per-ID table of what each buff boosts (ship or module/charge targets, % vs add, stacking-penalised or not), applied inresolveafter the fit’s own modifiers; per buff ID only the strongest source applies. Booster skills are assumed at V; the hull bonus and mindlink are inputs. The per-ID behaviour follows pyfa (Fit.__runCommandBoosts,commandLink.py), re-expressed as our own data. - Weapon application (
engine/application.rs, #1183/#1267) — re-implemented from pyfagraphs/data/fitDamageStats/calc/application.py. Missiles:min(1, S/E, (S·Ve/(E·Vt))^drf)(S target sig, EaoeCloudSize654, VeaoeVelocity653, Vt target speed, drf chargeaoeDamageReductionFactor1353; speed term skipped when Vt ≤ 0 or drf ≤ 0). Turrets and drones:turret_chance_to_hitis the hit probability only; applied damage usesturret_damage_multiplier(cth) = 3·min(cth, 0.01) + (cth − min(cth, 0.01))·((0.01 + cth)/2 + 0.49)(1% wrecking hits at 3×, uniform 0.5–1.5 roll otherwise), so it is 1.015 at cth 1 and 0.395 at cth 0.5. Drones that keep pace use multiplier(1.0) = 1.015 (pyfa parity). Applied ÷ paper DPS can therefore slightly exceed 100%. - EVE SSO (multi-character) — OAuth2 PKCE; each refresh token in the OS keychain, roster persisted across restarts.
Releasing
Installers are produced by the Release GitHub Actions workflow
(.github/workflows/release.yml). To cut a release:
- On a
chore/vX.Y.Zbranch, bump the version everywhere at once:scripts/bump-version.sh 0.25.0(editspackage.json,src-tauri/Cargo.toml,src-tauri/tauri.conf.jsonand regenerates both lockfiles). Review the diff and commitchore(release): v0.25.0. - Open a PR and enable auto-merge
(
gh pr merge --auto --merge --delete-branch); CI gates it. Never push tomaindirectly (see AGENTS.md). - Tag the resulting merge commit on
mainand push only that tag:git tag v0.25.0 <merge-commit> && git push origin v0.25.0.
The workflow builds Windows, macOS (universal) and Linux installers on every
v* tag. It refuses to run from a non-tag ref and fails fast if the tag does
not match the versions in package.json, Cargo.toml and tauri.conf.json. It
attaches the installers to a draft GitHub Release, which is published (with the
changelog and the unsigned-build note, see
SIGNING.md)
only once every platform leg has succeeded.
Keep @tauri-apps/cli at ≥ 2.12 (bundler ≥ 2.10): older bundlers copy the
build host’s /usr/bin/xdg-open into the AppImage whenever
tauri-plugin-opener is a dependency. On the ubuntu-22.04 runner that is
xdg-utils 1.1.3, AppRun puts it ahead of the system one on PATH, and its
open_kde() only handles KDE_SESSION_VERSION 4 and 5 — on KDE Plasma 6 it
exits 0 without doing anything, so EVE SSO (and every other external link)
silently never opened a browser (#1140).
Status & tracking
Work is tracked as
GitHub issues
(afk = mergeable without a human, hitl = needs a human).