Fellowship Forge

November 2025

A gear optimizer for Fellowship, the indie action RPG. Calculates optimal loadouts across 9 hero classes, handles the combinatorial explosion of gear slots + stat priorities + gem socketing, and lets you share builds without creating an account.

Gear Optimizer - Best-in-slot calculations with customizable stat weights
Gem System - Socket optimization across all gear pieces
Build Import - Parse your current loadout from combat logs
Build Sharing - URL-encoded builds, no accounts needed

Fellowship Forge Architecture — System architecture - stateless frontend with URL-encoded builds, Python optimizer backend

Fellowship Forge Home — Hero selection - 9 classes, each with unique stat priorities

The Problem

Fellowship has 9 classes, 8 gear slots, dozens of items per slot, and a gem socketing system that affects stat totals. Figuring out optimal gear manually means spreadsheets or trial and error. The game’s community needed a proper optimizer - something that could handle stat priorities, gem distribution, and spit out the actual best loadout for your build goals.

The Solution

The optimizer uses a two-pass algorithm. You pick a class, set your stat priorities (damage vs survivability vs utility), and it calculates the optimal combination of gear and gems. The stat weight system lets you express preferences like “I care 80% about damage and 20% about health” rather than forcing binary choices. Pass 1 greedily fills each slot with the best-scoring item; Pass 2 does local search to find swaps that improve overall distribution.

Gear Optimizer — Optimizer output with gear slots, stats, and gem sockets

Gems add another layer. They provide flat stat bonuses but you have limited sockets. The algorithm distributes gems across your gear to maximize weighted stat totals while respecting socket constraints - finding the optimal distribution for your specific weights rather than just stacking one type.

Gem System

Gem Bonuses — Gem ranks, bonuses, and slot allocation

Each gem type (Amethyst, Topaz, Emerald, etc.) has a rank system - the more you socket, the higher the rank, and each rank unlocks stronger bonuses. The optimizer tracks total gem power, slot usage, and which rank thresholds you’re hitting. Sometimes it’s worth sacrificing a few stat points to hit the next rank bonus.

Build Import

Nobody wants to manually input their current gear. The combat log parser reads Fellowship’s log files and extracts your equipped items and gems. Paste your combat log, and it reconstructs your current build automatically. From there you can tweak stat weights and see what upgrades the optimizer recommends.

Every build is URL-encoded. Share your optimized loadout by copying the URL - gear, gems, stat weights, everything is in the query string. No accounts, no login, no database lookup. If someone sends you a build link, you see exactly what they see. This was a conscious choice to keep the tool frictionless.

Data Pipeline

Item stats aren’t available via API. Playwright scrapes the Fellowship wiki periodically, normalizes the data, and loads it into PostgreSQL. When the game patches with new items, I re-run the scraper and the optimizer immediately has access to the new gear. Not glamorous, but it works.

The item database is also exposed directly - players can browse and filter all 1400+ items by hero, equipment slot, drop zone, and quality. Useful for planning what to farm.

Under the Hood

Optimizer Algorithm Flow — Two-pass optimization: greedy selection followed by local search refinement

The optimizer runs in two passes. Pass 1 is greedy slot-by-slot selection - each item is scored by how well its stat distribution matches your target weights using squared error. A 10x penalty for unwanted stats keeps the results clean. Pass 2 does local search optimization, trying single-slot and pairwise swaps to reduce total distribution error. It’s not brute force (that would be combinatorially explosive with 14 slots), but the local search catches cases where the greedy pass made a locally-optimal choice that hurts the global result.

Gem distribution targets specific rank thresholds rather than maximizing raw stats. Rank 10 needs 2640 power (5 Splendid gems), Rank 6 needs 1200 power (2 Splendid + 1 Large). The algorithm allocates slots to hit these breakpoints because rank bonuses often outweigh marginal stat gains.

Two-pass optimizer (greedy + local search)
Squared-error scoring against target stat distribution
Gem distribution targeting rank thresholds (10/6/6)
Combat log parser with regex-based item extraction
URL-encoded state (no user accounts, fully shareable)
PostgreSQL for item/stat data
Playwright scraper for wiki data ingestion

Stack: Next.js, FastAPI, PostgreSQL, Playwright

A smaller project than EQRaidBot, but satisfying in its own way - solves a specific problem cleanly, people use it, and it just works. I found myself begining to create spreadsheets to do this and decided to build this instead.