POE2 How To Craft

A web app that works out how to craft the item you want in Path of Exile 2, and what it will cost. It runs the probability math exactly — no simulation, no sampling — over the real 0.5.0 modifier pools, prices every route from a daily poe.ninja sheet, and shows you the trade-off between the cheapest way and the surest way. The crafting runs entirely in your browser, and there is nothing to install.

Try it now at poe2htc.com · Join us on Discord

If you find this tool helpful, consider supporting its development!

• ✨ Features
• 🚀 Quick Start
• 👤 About Me & the Project
• 📖 How Does It Work?
• 💻 Development
• 🤝 Contributing
• 📚 Documentation
• 🐛 Known Issues
• 🗺️ Roadmap
• 📄 License
• 🙏 Acknowledgments
• 📞 Contact

• 🧠 True expected cost, from an optimal policy — the headline feature, and the one thing no other PoE2 crafting tool does. Most calculators price a fixed recipe: do these five steps, and if step three misses, start over. Real crafting isn't like that — after a bad roll you look at what you're holding and pick the best move from there. The engine solves that as a Markov decision process, so the cost it quotes is the cost of playing well, recovering in place, not of restarting.
• 🎯 Optimal crafting paths — the currency sequence to reach the mods and tiers you asked for, with exact per-step odds, cross-checked against Craft of Exile and a Monte-Carlo simulator
• 💰 Cost ↔ success trade-off — a Pareto frontier of plans, cheapest through surest, each priced in Exalted-Orb equivalents from poe.ninja
• 🛒 Start from an item you buy instead — every craft from scratch also lists the items already carrying some of your targets, what finishing from each one costs, and what it is worth paying for. Type the trade prices you find and it tags the best buy, and draws the route from any of them.
• 🎥 Streamer gear — browse real endgame items from streamers' characters and hand any of them to the planner: craft it from scratch, aim at it from the item you hold, or load it as the item you own
• 🎒 "I already have this item" — enter what's actually on your item, mid-craft, and get the best move from where you are, not from a white base
• 🦴 The currency that matters — Basic, Greater and Perfect orbs, Essences and Perfect Essences, Desecration with every bone (Ancient included) and the Omen of Abyssal Echoes, omens, fractured mods
• 💸 Budget mode — say what you can spend and get the closest item that money can actually finish, with the probability of finishing it inside the budget
• 🚫 Currency exclusions — don't own Perfect Exalts, or refuse to use Omens? Tick them off and the planner routes around them
• 🔗 Share a craft — Copy link reproduces the exact base, mods, tiers and budget in anyone's browser, and your own workspace is kept between visits
• ⏱️ Search effort — Quick, Standard or Exhaustive. When a big craft doesn't settle, the app says so and offers to compute it again one level up, in one click
• ⚡ Runs in your browser — every solve runs client-side, in a Web Worker. What leaves the page: anonymous page-view counts, an error report if the app breaks (with a replay of that session, so the bug can be reproduced), and a rating if you choose to send one
• 💛 Rate the app — stars and a few words, straight to the maintainer, with no email and no account

Visit poe2htc.com — that's the whole install step. It works in desktop and mobile browsers.

New here? The User Guide walks through a first craft end to end. Used it before? What's new in 1.0 is the tour of what the site does now.

Prerequisites: Node.js 20+ (no Java, no database)

git clone https://github.com/Dboire9/POE2_HTC.git
cd POE2_HTC
npm install      # .npmrc already sets legacy-peer-deps, which React 19 needs

npm run dev      # dev server on http://localhost:5173
npm run build    # or build the static site into dist/

Everything works locally except Rate the app, which posts to a Vercel server function that npm run dev doesn't serve.

Hi! I'm Dorian, a former student at 42 Paris.

I built this project while actively searching for an internship, both to strengthen my skills and to add a meaningful, technical project to my portfolio. As someone passionate about both gaming and software development, combining Path of Exile 2's complex crafting system with algorithm optimization was the perfect challenge.

Why this project?

• 🎓 Demonstrates end-to-end product skills (React, TypeScript, Web Workers) — and a full engine rewrite from a Java backend to a pure-TS client-side engine
• 🧠 Showcases algorithm design (exact weight-pool probability, Pareto cost/success optimization, a Markov decision process solved by policy iteration, Monte-Carlo validation)
• 🎮 Solves a real problem for the PoE2 community
• 📈 Continuous learning through community feedback

📘 For more about my journey, motivation, and project philosophy, see About Me & the Project.

Three ways in, depending on where you're starting from.

From a white base — Plan from scratch:

1. Select your base item type, item level, and the modifiers and tiers you want
2. Compute — the engine evaluates candidate plans with exact weight-pool probability math
3. Review a Pareto frontier, cheapest through likeliest, each with step-by-step instructions and per-step odds — plus the true expected cost of playing optimally rather than following one fixed script, and the items worth buying instead of a white base
4. Craft in-game following the currency sequence

From an item you're holding — I have an item: enter the mods already on it, say what you want it to end up as, and the engine answers from that state. It will tell you when the best move is to keep going, and when it's to stop.

From someone else's item — Streamer gear: pick an item a streamer actually built, and send it to either tab. The gear is a dated snapshot, and the app names every modifier it could not carry over.

The engine accounts for item rarity transitions, modifier weights, currency behaviours and strengths (Basic / Greater / Perfect), omens, family conflicts, item-level gates, fractured mods and slot limits. Monte-Carlo simulation is used only to validate the analytic math, never to produce the numbers you see.

Two solvers run on every craft, and the app shows both because they answer different questions.

The step planner returns a Pareto frontier — the set of plans where no other plan is both cheaper and likelier. Each plan is a fixed sequence of currencies, and its probability is computed analytically from the modifier weight pools at each step: exact math over the affix pools, not sampling. That answers "what's the recipe, and what are my odds per attempt?"

The policy solver models the craft as a Markov decision process — every reachable item state, every legal move from it — and solves it by policy iteration for the true expected cost: what the craft costs if, after every roll good or bad, you make the best move from wherever you actually are. That answers "what will this really cost me?", and it is almost always cheaper than the frontier's number, because the frontier can only restart where a real crafter would recover.

Key properties:

• Exact, sampling-noise-free probability for each step and the plan as a whole
• Costs in exalt-equivalents from a poe.ninja price sheet refreshed daily, so plans can be ranked by money
• Full PoE2 semantics: rarity transitions, orb strengths, omens, essences, desecration, family exclusion, item-level gates, currency tier floors, fractured mods
• Honest bounds: when a solve doesn't fully settle, the app prints "≥ x" or "≤ x" rather than a confident number
• Runs locally in a Web Worker — no network during a solve, cancellable, with a progress bar

📘 For a walkthrough of every panel and what each number means, see the User Guide. For the maths, see How it works.

Architecture:

• App: React 19 + TypeScript + Vite, a static site; the UI lives in src/features/, driven by the browser facade src/lib/engine.ts
• Engine: packages/engine — a pure-TS crafting engine (no I/O, no DOM) doing exact weight-pool probability math per currency
• Optimizer: packages/optimizer — the Pareto frontier, the from-item planner, and the MDP policy solver, with Monte-Carlo self-checks
• Data: data/patches/<patch>/*.json — versioned mod, base and price data (the app ships 0.5.0); data/streamers/ is the streamer-gear snapshot, built by tools/streamers/
• Server: api/feedback.ts is the one server function — the Rate the app endpoint, a Vercel Function behind Vercel's BotID. Nothing else runs on a server.
• Automation: a GitHub workflow refreshes the price sheet from poe.ninja every day and merges its own pull request when the market data passes a liquidity check

The verify chain — what CI runs on every push:

npm test -- --run
npm run type-check && npm run type-check:engine && npm run type-check:optimizer
npm run lint
npm run build && npm run test:e2e

📘 For detailed setup instructions, project structure, and contribution guidelines, see the Development Guide.

We welcome contributions! Here's how you can help:

1. Report Bugs - Open an issue with reproduction steps, or use Report a problem in the app
2. Suggest Features - Share your ideas for improvements
3. Submit Pull Requests - Fix bugs or add features
4. Update Data - Help keep modifier data current with game patches

📘 For detailed contribution guidelines, development setup, and code style, see the Contributing Guide.

Everything in docs/, so nothing is only findable by knowing it exists.

If you play the game

If you want to know whether to trust it

If you want to work on it

These are the real limits, named rather than hinted at. None of them make a shown number wrong — where the engine is uncertain, it says so on screen.

• The desecrated spawn weight is measured, not published. poe2db reports a weight of 1 for every desecrated mod, which cannot be right. The shipped value (2500) comes from 40 bone offerings on one base — good enough to trust, not good enough to be sure it doesn't vary by item category. A plan that uses a Desecration without a boss omen says so in the app and marks those odds as an estimate; every other probability is exact.
• The step planner has no concept of filler. Every step it emits names a target mod, so it cannot express "roll junk, annul it off, then Desecrate" — a route that works in game. The policy solver can find those, which is one reason the two models' numbers differ.
• Charms and Jewels are not supported. Both are classed differently from ordinary gear (charms are flasks in the game data, jewels have their own affix model), so neither fits the 3-prefix/3-suffix rare that this optimizer plans for. Every equipment slot IS supported.
• Big crafts need patience. A six-mod target at top tiers can take the Exhaustive search effort and several minutes to settle; until it does, the app shows a bound rather than a guess.

docs/copy-audit.md is the full inventory of what the app claims and what actually enforces it. See the Issues page for reported bugs.

• Pure-TypeScript engine (retired the Java/Maven backend — the crafting is now fully client-side)
• Cost ↔ success Pareto optimizer with Monte-Carlo validation
• "I already have this item" flow (per-currency odds + from-item planner)
• Heavy solves moved off the main thread into a Web Worker
• Crafting cost estimation — every plan priced in Exalted-Orb equivalents from a poe.ninja sheet, plus the MDP's true expected cost of playing optimally
• Budget mode — the best item a given number of exalts can actually finish, with the probability of finishing it in budget
• Orb strengths — Basic, Greater and Perfect are searched for every add currency, on both the step planner and the policy solver (Chaos strengths are searched by the step planner; the policy solver models Chaos at basic strength, which was measured in 2026-09 to change no answer)
• Currency exclusions — plan around the currency and omens you don't have
• Belts — every equipment slot is now supported
• Omen of Whittling — the Chaos Orb that removes your lowest-level modifier
• Omen of Greater Exaltation — one Exalted Orb landing two modifiers, searched by the step planner (the policy solver was measured in 2026-09 and never plays it: it re-decides after every orb, and this omen is a promise not to)
• Automated daily price refresh — the sheet updates itself from poe.ninja and merges its own pull request when the market data passes a liquidity check
• Share links — a craft travels as a URL, and the workspace survives a reload
• Streamer gear — real endgame items from streamers' characters, sent straight to the planner
• Ancient bones and the Omen of Abyssal Echoes — weighed on every Desecration, and Desecration offered in the Quick currency check
• Start from an item you buy instead — which item to buy as a head start, with typed trade prices and the route from it
• Rate the app — feedback with no email and no account, protected by an invisible bot check

• A measured desecrated spawn weight, from players' own bone counts rather than one 40-bone sample

• Integration with trade API for cost optimization
• Crafting simulator with step-by-step execution

This project is licensed under the GNU Affero General Public License v3.0 (AGPL-3.0) - see the LICENSE file for details.

• Grinding Gear Games for creating Path of Exile 2
• The PoE community and POE2db for modifier data and crafting knowledge
• @fZpHr for the help and advices.
• farmer for giving me this idea through his streams and his discord (Modikin, Bad Architect).
• Morce Faster for the tablet rolling data — 19,147 modifiers counted across Ritual, Overseer and Temple tablets. Every odds figure on the Tablets tab rests on it; nothing else publishes tablet weights.
• Exiled Exchange 2 (MIT) for the trade-site stat ids the tablet and gear searches are built from, and the trade site's item categories.

• Discord: discord.gg/RvxCWyFF3D
• Issues: GitHub Issues
• Discussions: GitHub Discussions

Note: This is a third-party tool and is not affiliated with or endorsed by Grinding Gear Games.