| Latest version | 2.3.0 |
|---|---|
| Minimum Core | |
| Compatible Core | |
| Last updated | 1 month ago |
| Created | 4 months ago |
| Authors | |
| Languages |
English |
| Systems |
Dnd5e |
| Project source | Project URL |
Encounter Forge is a Foundry VTT (v12-v14) module for D&D 5e that builds brand-new, balanced NPCs on demand, sized to your party, not a generic XP table or basic CR.
Instead of pulling a stat block from a compendium and hoping the CR math works out, Encounter Forge assembles a creature from a chassis, traits, actions, and (optionally) spells, then tunes its HP, AC, and damage toward the difficulty you asked for. The estimate is built from party HP and damage per round, so it can't account for tactics, terrain, control effects, or what your party has left in the tank. Read the creature before you run it.
Status: Actively developed. Foundry v12-v14, dnd5e system 4.0+ (verified on 5.3.3 and 6.0.5).
Most CR generators (and most homebrew stat blocks) work backwards from the Dungeon Master's Guide CR/XP tables: pick a CR, look up its "expected" HP and damage, and build (or pull) a creature around those numbers. The problem is that those tables assume a "standard" party, and most parties aren't standard. A CR 5 monster can be a joke or a TPK depending on who's sitting at the table.
Encounter Forge flips that process around:
In short: a "Hard" fight with two generated enemies and a "Hard" fight with four generated enemies should both feel like a Hard fight for your specific table, just split up differently. That's not something CR-table-driven generators do well enough, because they're matching a number on a chart, not your party, and not by output.
Encounter Forge contains/requires no AI and no language model. Every creature is assembled procedurally from local JSON content pools (chassis archetypes, traits, actions, spells, names) using deterministic math you can read in plain JavaScript. There's nothing to configure, no API key, no tokens, and nothing about your world or your party is ever sent anywhere. Generating a creature needs no internet connection at all (other than being online to play obviously). The only network request is the update check, which asks GitHub if there's a newer release. It sends nothing else, and there's no setting to turn it off yet. The difficulty targets are deterministic from the same inputs, and the creature built to hit them varies (actions, traits, etc are randomizes via the pool of said items, so that differs or fights would be boring).
This section is a summary, see the Wiki for the full breakdown with worked examples.
A party estimate is { dpr, hp }:
Each difficulty maps to a target "rounds to defeat the enemy" and "rounds the enemy needs to threaten the party":
| Difficulty | Rounds to Defeat | Rounds to Threaten | Outlook |
|---|---|---|---|
| Easy | 2 | 6 | Easy |
| Medium | 3 | 5.4 | Manageable |
| Hard | 4 | 4.4 | Risky |
| Deadly | 5 | 3.5 | Dangerous |
groupHP = party.dpr * roundsToDefeat
groupDPR = (party.hp / roundsToThreaten) * economyFactor
economyFactor is a small multiplier (1 + 0.04 * (enemyCount - 1), capped at 1.2) that accounts for more attackers contributing slightly more total damage per round. Both totals are then divided by the enemy count to get each creature's HP/DPR target. Solo Boss further multiplies its single creature's targets by HP x1.5 / DPR x1.3.
The per-creature HP/DPR target is matched against a CR baseline table to find the closest CR. That CR drives only the chassis stat tier, trait/action/spell availability, and AC/save-DC baseline, it is not the creature's final HP or DPR.
Every generated creature is then tuned to hit its envelope target exactly:
The result: the pre-generation readout and the post-generation results should track closely, regardless of party size, level, enemy count, or Solo Boss status.
A world setting (dprFirstDamage, Boolean, default off) changes how action dice counts are assigned during creature assembly. In the default tier-based path, each action uses a fixed dice formula per tier (example, a multi-hit melee action always uses its tier 3 formula at CR 5-7, regardless of the creature's actual DPR target). When enabled, dice counts are instead derived from the per-creature DPR target values: the engine extracts the die size from the action's damage_fallback and computes how many dice of that size are needed to hit the target DPR. Calibration (step 4) still runs afterward and closes any gap. The effect is a closer ceiling on high-variance attacks. An action at tier 3 uses the number of dice appropriate for that creature's budget, not a tier-baked maximum. Intended for playtesting balance comparisons so I can get input on the better approach; leave off for the standard v 1.0 path if you prefer.
A world setting (combatIntensity, integer -3 to +3, default 0) scales the roundsToThreaten target before the envelope is computed:
adjustedRoundsToThreaten = roundsToThreaten / (1 + offset * 0.12)
Positive offset = shorter drain time = enemies built to hit harder. Negative = longer drain = softer enemies. roundsToDefeat is never changed. Set from Module Settings -> Combat Intensity Calibration; changes take effect immediately for the next generation.
In Foundry's Add-on Modules tab, click Install Module.
Paste the manifest URL:
https://github.com/ElemorSeru/encounter-forge/releases/latest/download/module.json
Enable GM Tools: Encounter Forge in your world's module list.
Or find it on the Foundry package list: GM Tools: Encounter Forge
Add your own homebrew feats, weapons, and spells to the randomization pools without editing JSON:
See the Wiki for the full field-by-field reference.
Encounter Forge exposes game.modules.get("encounter-forge").api with generate(), openDialog(), and openDialogFor(overrides) for generating creatures from your own module, plus encounterForge.generationStarted, encounterForge.creatureCreated, and encounterForge.encounterComplete hooks for reacting to generation.
The API also exposes exportCustomContent() and importCustomContent(payload), the same machinery behind the Custom Content manager's Export/Import buttons. If your module ships its own bestiary, item pack, or homebrew content, you can bundle an Encounter Forge content pack (JSON) alongside it and call importCustomContent() to drop those traits, actions, and spells straight into the randomization pools, no manual setup for the GM. This works well both ways: a lore/compendium module can feed Encounter Forge new content, and Encounter Forge's openDialogFor() can hand a freshly generated NPC straight back to that module's UI.
If you're building a module that could pair well with Encounter Forge, feel free to reach out, I'd be happy to help with integration or cross-promote.
Full API reference, options tables, hook payloads, and code samples live in the Wiki.
Have a feature request or found a balance edge case? Open an issue on GitHub or drop a note on Patreon. See links below.
Built and maintained by Elemor.
If you find this useful and want to support continued development, the Patreon link above is the best way to do that.
Bug reports and feature requests are welcome via the Issues tab.
To install this package, open your Foundry Setup screen and navigate to your Module tab and click the Install Module button.
From there, you can either search for the package unique name: encounter-forge or copy its manifest URL:
And paste it to the input box at the bottom of your window.

You can install this package directly to your Forge account.