Familiar

Your AI co-pilot for Foundry VTT

194 tools. 23 AI providers. Zero prep.

Run combat, set the mood, and voice your NPCs, all by talking to your AI.

You bought Foundry to run the game for everyone else. Familiar takes the dungeon master's side: the rules, the dice, the monsters, every NPC in its own voice. So you finally get to play. Solo, one on one, or a full group.

Install Familiar · Connect your AI · Pricing · FAQ · Roadmap

Plays at any table

However many show up, you get to play. Familiar covers the DM's side of the table — the cast, the dice, the monsters, the lighting — so you take a seat at the game you usually run for everyone else.

And it scales to whoever shows up. The fewer humans at the table, the more of the world Familiar runs. With a full group, it quietly co-pilots the monsters and the mood while you tell the story.

| Your table | What Familiar runs for you | |---|---| | Solo (just you) | You play your character. Familiar runs everything around it: every NPC in its own voice, every monster's turn, the scene, with 2024 D&D 5e rules enforced. Campaign memory carries the world from one session to the next. | | Duet (you and one other) | Neither of you has to be the DM. Familiar runs the world for both of you, the cast, the encounters, the rulings, so you stay players and the story still moves. | | Small table (you and a few) | The supporting cast and the monsters' turns run for you, with the lighting, the music, and the rulings, so nobody steps out of the game to keep it moving. | | Full group (you DM for four or more) | The tactical load comes off the GM. You run the encounter and tell the story; Familiar handles initiative, the monster turns, and the bookkeeping. You run the scene, not the spreadsheet. |

A co-pilot, not a replacement DM. Whoever is at the table, you are still telling the story, and the dice and the math are always right. No "you rolled a 47."

What can Familiar do?

You stay in the story; Familiar runs the table. Say what you want and it happens, without breaking the scene to click through Foundry:

"Roll initiative for all the goblins, have them attack the nearest player, and play battle music."

"I swing at the bandit captain with my greataxe. Roll my attack, and have her hit back."

"Dim the lights, start rain and thunder, and have the innkeeper whisper a warning about the road ahead, in his voice."

"Spawn two wolves from the compendium as reinforcements, place them near the forest edge, and add them to combat with initiative rolled."

"What did the party promise the duke last session, and what was his daughter's name?"

"We're done for tonight. Summarize what happened this session and save it to the journal."

Familiar exposes 194 tools across 24 domains through the Model Context Protocol. Tools load as your AI needs them.

Highlights

Combat & AI

32 tools cover encounters end to end: initiative, attacks, spells, grapples and shoves, damage, conditions, death saves, and XP. A rules engine sits between the AI and your game: every action is checked against the D&D 5e (2024) rules before it lands, illegal moves come back refused with the reason, and every narrative override is written to the chat log. Foundry's own dice roll every result. When you want a break, Familiar resolves each NPC's turn from a battlefield snapshot, scoring movement and reading cover, with multiattack, reactions, opportunity attacks, and legendary actions included. You stay the DM.

Auto-Pilot

Click "Run NPC" and walk away. Familiar plays every enemy turn in the encounter for you, with safety caps and optional turn-by-turn confirmation.

Live Transcription

Speak instead of type. Familiar transcribes your session in real time across three providers, color-codes per speaker, and saves it to a Foundry journal you can edit and search later. Broadcast a read-only transcript to your players, export to SRT or Markdown, and the AI remembers what was said.

Scenes & Canvas

Build the whole scene by asking. Create scenes, place tokens, draw walls and doors, set lighting and darkness, add weather effects, and configure trigger regions. Full control over tiles, drawings, ambient sounds, fog of war, and camera. Familiar places it, you direct it.

NPC Voices & Image Generation

Give every NPC its own voice across three providers. Have the tavern keeper actually speak his lines, in his own voice, and Familiar remembers who sounds like whom. Generate character portraits, item art, and battle-map backgrounds inline, mid-session.

Audio & Atmosphere

Play, stop, and crossfade playlists and individual tracks with volume and fade control. Cue battle music, build ambient soundscapes, or silence everything without touching Foundry's sidebar.

Knowledge & Memory

Full-text search across every journal, character, scene, item, and recorded transcript. A persistent memory bank stores campaign facts that carry over between sessions, plus a continuously rewritten plot summary the GM can read later.

Multi-Session Chat

Pin, archive, and switch between named campaign threads. Each thread persists as a Foundry journal entry with a full audit log, so you can return to any conversation later, even months apart.

Characters & Items

Build NPCs, manage party inventory, apply buffs, and clone monsters from any compendium. Active effects, ownership, and player permissions all wired up.

Combat that enforces the rules

Most AI tools narrate combat; Familiar referees it. A deterministic rules engine sits between the AI and your game: every attack, spell, and move is checked against the D&D 5e (2024) rules before it lands. Out of range, out of turn, no slot left, action already spent — the move comes back refused with the reason, the AI reads the error and picks a legal move, and Foundry's own dice roll every result. Narrative overrides exist for the edge cases, and each one is written to the chat log.

What runs today: the full turn loop (initiative, movement checked against speed and walls, multiattack, legendary actions), reactions that fire themselves (opportunity attacks, Shield, Counterspell, Uncanny Dodge, Hellish Rebuke, Legendary Resistance), weapon mastery riders, grapple and shove as the 2024 contest, concentration checks at the real DC, persistent zones like Spirit Guardians, summons that join the initiative, Polymorph as a real transformation, death saves, massive-damage instant death, and an undo that survives a reload. Where a rule needs a judgement call — flanking, house rules, readied triggers — Familiar leaves the decision to you, and where an effect is not modelled yet it flags the gap instead of guessing.

It runs standalone. No MidiQOL, DAE, Times Up, Chris's Premades, or Gambit's Premades required — the automation layer is built in, one module under one roof, written for an AI driver from the first line. Every rule is verified in a live Foundry game before it ships.

Read the deep dive: How Familiar runs combat.

| Domain | Tools | What it does | |---|--:|---| | Scenes & Tokens | 19 | Build scenes, place and move tokens, configure vision and movement | | Canvas Environment | 18 | Walls, lights, weather effects, fog of war, darkness levels | | Combat & Initiative | 17 | Start encounters, roll initiative, advance turns and rounds | | Characters & Actors | 16 | Create, inspect, update, and manage player characters and NPCs | | Combat AI | 16 | NPC tactical decisions, target selection, ability usage, positioning, class features | | Audio & Playlists | 14 | Play, stop, and crossfade music and ambient sound | | Journals & Notes | 10 | Create and edit journal entries, map pins, and handouts | | Card Decks | 9 | Create, draw, shuffle, and reset card stacks and decks | | Canvas Drawing | 8 | Draw shapes, text, and freehand annotations on the canvas | | Rollable Tables | 7 | Create tables and roll on them for random encounters or loot | | Macros | 7 | Create, edit, and execute Foundry macros | | World & System | 7 | World info, system settings, time, pause, and user management | | Items | 6 | Create, update, delete, and search world-level items | | Ember Events | 6 | Quests, story events, and hex-crawl exploration via the Ember module | | Active Effects | 5 | Apply, remove, and toggle buffs, debuffs, and status effects | | Folders | 5 | Organize documents into folder hierarchies | | Regions | 5 | Define map regions with triggered behaviors | | Knowledge & Memory | 5 | Campaign knowledge base, session memory, context retrieval | | Compendium & Rules | 4 | Search and import from compendium packs and rule references | | Voice Generation | 4 | Generate NPC speech audio with distinct AI voices | | Chat Messages | 2 | Send and read chat messages in the Foundry sidebar | | Scene Generator | 2 | Generate AI battle-map backgrounds from a text description (image only, no walls or tokens) | | Dice | 1 | Roll any dice expression with full Foundry roll parsing | | Image Generation | 1 | Generate character portraits, item art, or concept art on demand |

Installation

Familiar is listed in Foundry's package directory, so it installs like any other module.

1. In Foundry, open Configuration → Add-on Modules → Install Module.
2. Search "Familiar" and click Install.
3. Enable Familiar in your world, open its settings, pick a provider, and paste an API key.

That is the whole setup for the built-in chat.

Newly listed packages can take a little while to surface in Foundry's search. If Familiar has not appeared yet, or you would rather paste it in, drop this manifest URL into the Install Module → Manifest URL field instead:

https://github.com/Ryanjansen92/familiar-releases/releases/latest/download/module.json

If you would rather drive your game from an MCP client (Claude Desktop, Claude Code, Codex CLI / Desktop, Antigravity CLI / Editor, LM Studio, or ChatGPT), you also need the local MCP server:

npx familiar-vtt

The MCP Setup Wizard on the MCP / Subs tab in Module Settings → Familiar walks you through connecting your client step by step, including the auto-generated FAMILIAR_WS_SECRET. No JSON editing.

Compatibility

| | Supported | |---|---| | Foundry VTT | v13, v14 | | Game System | D&D 5e (2024 rules): full support. Other systems get the general features (chat, journals, scenes, audio) but not system-specific tools like character sheets or combat automation. |

Connect your AI

There are two ways to connect an AI to your game. Both reach the same 194 tools. The difference is where the model runs and who you pay.

Option 1: Built-in chat (API key)

No server, no terminal, no config files. Install the module, pick a provider, paste an API key, and start talking to your game. Your key goes straight from your browser to the provider, which bills you per token for what you use.

Familiar connects directly to 23 AI providers across four categories:

| Category | Providers | |----------|-----------| | Chat (14) | OpenRouter¹, Anthropic, OpenAI, Google, Groq, Mistral, Together AI, DeepSeek, xAI, Cohere, Perplexity, Fireworks AI, Cerebras, SambaNova | | Voice (3) | ElevenLabs, Cartesia, OpenAI TTS | | Image (3) | OpenAI (GPT Image), fal.ai, Leonardo AI | | Transcription (3) | Gladia, Deepgram, AssemblyAI |

¹ OpenRouter unlocks 300+ models on a single key.

This is the right choice if you want the simplest setup, or if you want voice, images, and live transcription alongside chat. For an open model at near-zero cost, pick a hosted open-weight provider (Groq, Cerebras, DeepSeek, OpenRouter). A Thinking control lets you set how hard the model reasons: up for hard fights, down for quick lookups.

Option 2: MCP (your existing subscription)

Already paying for Claude, ChatGPT/Codex, or have a Google account for Antigravity? Put that subscription to work. Connect it to Familiar through the Model Context Protocol and your existing plan drives the game at no extra API cost. No second invoice, no credits to run dry mid-session. It uses your plan's normal usage quota, so a long, heavy night can still hit your plan's rate limits, the same as any other use of that app.

Familiar supports eight MCP clients out of the box:

| Client | Subscription | Transport | Setup | |--------|-------------|-----------|-------| | Claude Desktop | Anthropic Pro / Max / Team | stdio | Add to claude_desktop_config.json with env: { FAMILIAR_WS_SECRET } | | Claude Code (CLI) | Anthropic Pro / Max / Team | stdio | claude mcp add --scope user --env FAMILIAR_WS_SECRET=… familiar -- npx familiar-vtt | | Codex CLI | ChatGPT Plus / Pro / Team | stdio | codex mcp add familiar --env FAMILIAR_WS_SECRET=… -- npx -y familiar-vtt | | Codex Desktop | ChatGPT Plus / Pro / Team | stdio | Add [mcp_servers.familiar] block to ~/.codex/config.toml (shared with CLI / IDE) | | Antigravity CLI (agy) | Google free / Pro / Ultra | stdio | Generates ~/.gemini/config/mcp_config.json; sign in via agy → Google OAuth | | Antigravity Editor | Google free / Pro / Ultra | stdio | Add to ~/.gemini/antigravity/mcp_config.json (desktop IDE; separate install from CLI) | | LM Studio | Local models (free, no key) | stdio | In LM Studio → Program tab → Edit mcp.json, paste the familiar block (LM Studio 0.3.17+, tool-trained model ≥14B) | | ChatGPT | ChatGPT Plus / Pro / Team | Streamable HTTP | Remote URL via Cloudflare tunnel |

You don't configure each client by hand. The MCP Setup Wizard on the MCP / Subs tab detects your connected client and generates the exact config, including the auto-generated FAMILIAR_WS_SECRET baked in. On hosted Foundry, like The Forge, it also bakes in your game's URL as FAMILIAR_WS_ALLOWED_ORIGINS. Copy and paste. Your model and how hard it reasons are set in your own client, not here.

Which should I pick?

| I want to... | Use | |--------------|-----| | Get started in under a minute | Built-in chat with any API key | | Use my Claude / ChatGPT / Codex / Antigravity subscription | MCP | | Run everything offline | MCP with a local model in LM Studio | | Have live transcription, auto-pilot, and drag-and-drop | Built-in chat (these live only in the Foundry chat window) | | Run long, multi-step chains | MCP (external clients handle long chains better) |

What's different between the two paths

All 194 tools work from both paths. Two things differ:

• Media renders in Foundry, not in your MCP client. When an external client (ChatGPT, Claude Desktop, Codex) calls a voice or scene tool, the audio plays and the scene updates in your Foundry browser tab. The MCP client only gets a text confirmation. Generated images are the exception: they come back inline, so clients that render images can show them.
• A few features are built-in-chat only. Live transcription, auto-pilot for NPC turns, automatic memory and knowledge-base context, slash commands, and drag-and-drop attachments live only in the in-Foundry chat window. MCP clients reach every tool, but not these chat-UI features.

A full surface-by-surface capability comparison lives at familiarvtt.com.

Works with what you already have

Familiar doesn't replace your modules, maps, or campaigns. It reads them, runs them, and stays out of your way. The Foundry community has spent years building incredible modules, battle maps, character sheets, compendium packs, and ready-to-play adventures. The more content your world has, the better Familiar gets.

Open Ember, Dragon of Icespire Peak, or any published adventure, and Familiar reads the journal entries, NPCs, and encounters that came with it, then runs them at the table without inventing contradictions. Drop a Czepeku or Patreon map, and it fetches the tokens, lights, walls, and ambient sound you set up. Your custom NPCs, your house rules, your D&D Beyond imports: Familiar reads what's already in your world instead of making things up.

Here's the part that's harder than it looks. Bolting a chat box onto a virtual tabletop is a weekend project. The real work is the engine underneath: teaching the AI how a real table actually operates, how initiative and reactions resolve, what a spell does to which token, when a saving throw is forced, why you can't swing a melee weapon from thirty feet away. Most AI tabletop tools skip that and rebuild a thin, simplified game inside their own walled garden, inventing the rules as they go. Familiar runs on the real thing, with real dice and real 5e enforcement on the mechanics that matter, on top of a decade of Foundry content. It runs the dungeon master's side of the table instead of faking one.

So the on-ramp is short. Buy a Foundry-ready adventure (official D&D modules run about $20–30, with the maps, walls, and lighting already built), drop in a battle map or two (plenty are free), enable Familiar, and you're playing. Import the adventure without reading it, and Familiar reads its journals so it knows the story you're about to discover. Then, as you play, it pulls monsters and items straight from your compendia, places the tokens, and runs the encounters, while you stay the player.

Familiar doesn't ship its own adventures, maps, or compendia. The content is yours. Your AI tells the story you bring, it doesn't invent one.

Pricing

$4 a month, or $36 a year — the annual plan saves you three months. Start with a free 1-month trial: every feature unlocked, no restrictions, cancel anytime. That price is the whole cost of Familiar — no markup, no per-message fee, no token metering, no credits to top up. Your AI provider bills you directly for the tokens you spend; we never touch that.

Do I pay twice?

Fair question. You pay for Familiar, and you pay for the AI that powers it, but never to us and never marked up. Here is how it breaks down:

| What you pay for | Who you pay | Typical cost | |---|---|---| | Familiar (the module + all 194 tools) | Us | $4 / month or $36 / year | | The AI itself | Your provider, directly | $0.50–$3 per session, or $0 |

That $0 is real. If you connect a subscription you already pay for (Claude, ChatGPT/Codex, or Antigravity) through MCP, the AI cost is already covered. The same goes for a local model run in LM Studio and connected through MCP: nothing leaves your machine, and nothing hits a bill. Bring your own API key instead, and a typical session costs about the price of a coffee, paid straight to the provider.

Your keys, your cost

Most AI tabletop tools lock you into their ecosystem. They charge per turn, per credit, or per token, and you're stuck with whatever model they picked for you. Run out of credits mid-session? Too bad.

Familiar works differently. You bring your own AI, an API key you already have or a subscription to Claude, ChatGPT/Codex, or Antigravity. Your keys go straight from your browser to the provider. Familiar never proxies, meters, or marks up your usage: no middleman, no per-turn limits, no credits to run out of. With MCP, your existing subscription handles it.

Why I built this

I'm Ryan. Dad of two young kids, married to my favorite person, with the free time you'd expect.

My wife and I play D&D together, just the two of us, 1-on-1 campaigns. It's our thing. But solo DMing is a lot. You're the storyteller, every NPC, the rules engine, the sound guy, and the atmosphere all at once. Mid-monologue as a mysterious stranger, I'd have to break character to roll initiative, look up a spell range, adjust the lighting, and find that one tavern ambience track I swore I bookmarked. By the time I got back to the scene, the moment was gone.

I wanted something that could handle the mechanical side of the table so I could stay in the story. Not a replacement DM, a co-pilot. Something I could say "roll initiative for the goblins, dim the torches, and start combat music" to, and it would handle it. While I kept talking.

So I started building. First it was a handful of tools to move tokens and roll dice. Then I added combat tracking. Then scene management. Then "what if it could also generate NPC portraits on the fly?" and "what if it could voice the tavern keeper?" That's how you end up with 194 tools across 24 domains and 23 AI providers.

I took my time with this. I ran Familiar at my own table, session after session, before opening it up. I didn't want to ship another AI that turns your campaign into nonsense the moment it forgets last week.

It started as a personal itch-scratcher for a dad who wanted to run better D&D games for his wife. It turns out a lot of GMs have the same itch.

FAQ

No. There's no telemetry, no analytics, and no calls home. Familiar runs entirely inside your local Foundry world, and your data only leaves your machine when you choose to send a message to an external AI provider. If you run a local model in LM Studio on the same machine, connected through MCP, nothing ever leaves it. (In MCP mode, the server validates your license with Polar; that request carries only your license key, never any world content.)

For the built-in chat, about as easy as it gets: install the module, open Familiar's settings, pick a provider, paste an API key, and start talking. No terminal, no config files. If you'd rather use an existing Claude, ChatGPT/Codex, or Antigravity subscription through MCP, there's one extra piece, a small local server you start with npx familiar-vtt, and the in-app MCP Setup Wizard detects your client and generates the exact config to copy and paste.

Familiar sanitizes every document update, so the AI can't change ownership, permissions, or internal IDs. Prototype-pollution protection is built in, and WebSocket connections use shared-secret authentication. Risky actions are flagged for confirmation: the built-in chat shows an inline approval row before running them, and external AI clients receive the same "destructive" hints so they can prompt you. The AI also can't create or edit script macros or code-running region behaviors, though it can run ones you wrote yourself. Keep backups anyway. Good practice with or without AI.

The trial is a full month with every feature unlocked, no restrictions. Billing runs through Polar. Cancel any time before the month is up and you won't be charged. If you do cancel, Familiar simply stops running new AI tool calls once the license check lapses; everything the AI already created stays in your Foundry world, untouched.

Everything stays in your Foundry world. Memory banks, knowledge base indexes, session transcripts, generated portraits, all of it lives in your local Foundry data directory, owned by your world. Cancelling stops Familiar from running new tool calls once the license check lapses, but nothing the AI already created gets touched.

No meaningful impact on Foundry's frame rate. The chat window is a plain DOM panel; it doesn't touch the canvas renderer, so it doesn't add to the per-token rendering cost that bogs down big battles. The AI's tool calls run the same Foundry operations you'd do by hand, just triggered by text. The only thing that takes a moment is the AI itself thinking and streaming its reply, which happens on the provider's side, not in your game.

Yes, both paths. Built-in chat works anywhere Foundry runs; the module calls your AI provider straight from the browser. MCP works too, because the small MCP server runs on your own computer and your browser connects to it locally, so your hosting provider is never in the path. Run the MCP Setup Wizard from your hosted game and the generated config already includes the one extra setting this needs: your game's URL in FAMILIAR_WS_ALLOWED_ORIGINS. Two caveats. Safari blocks this kind of local connection, so use Chrome, Edge, or Firefox. And image generation half-works: the image saves to your hosted asset library and is usable in Foundry, but your MCP client reports the tool call as failed instead of showing the image inline, because the local server can't read files from hosted storage.

Built-in chat runs inside Foundry with no extra server, the fastest way to start. MCP connects Familiar to external clients (Claude Desktop, Codex CLI / Desktop, Antigravity CLI / Editor, ChatGPT, LM Studio) through a small local server, letting you use existing subscriptions and handling complex multi-step tasks better. Both reach the same 194 tools, though media (voice, scenes) renders in your Foundry tab rather than the MCP client.

For the best experience: Claude Opus 4.8 or Sonnet 4.6 (Anthropic), GPT-5.5 (OpenAI), Gemini 3.1 Pro (Google), Grok 4.3 (xAI), Mistral Large 3 (Mistral), or DeepSeek V3.2 (DeepSeek). Familiar works with any model these providers expose, but the larger flagship models follow multi-step tool instructions most reliably. That reliability matters most in combat, where one turn is a chain of tool calls. For a budget option, DeepSeek V3.2 is capable and inexpensive; for fully offline play, run a strong local model in LM Studio and connect it through MCP.

Reasoning headroom is the other lever. The built-in chat has a Thinking control you can turn up for a hard combat or a tangled scene and back down for quick lookups; over MCP, that dial lives in your own client.

That's one of the main reasons it exists. Most people who own Foundry are the GM, the one who never gets to play. Familiar runs the rules, the monsters, and the NPCs, and remembers your campaign across sessions, so you can sit in a player's seat at your own table, solo or one-on-one. I built it for 1-on-1 campaigns with my wife. (It still needs GM-level access; see the next question.)

Two honest notes. Familiar runs the DM's side. It doesn't yet play a companion character adventuring next to you (that's on the roadmap). And the surprises come from the adventure you're playing and Foundry's own fog-of-war and hidden doors, not from the AI "keeping secrets." An AI can't truly hide what it can read. What it can do is run a real, rules-accurate game so you finally get to be the player.

Familiar requires GM permissions. It's designed as a GM tool that reads and modifies world data. Players can interact with it through the built-in chat if the GM enables it, but the module itself needs GM-level access to function.

Full support is D&D 5e (2024 rules) only. Generic features like dice rolling, scene management, journals, and audio work everywhere, but system-specific tools (character creation, spell resolution, combat automation) are built around the dnd5e data model and won't work elsewhere without changes. Pathfinder 2e, Call of Cthulhu, and Savage Worlds are on the roadmap.

No. Familiar operates through its own namespaced flags and doesn't monkey-patch or override core Foundry functionality. It works alongside any other module you have installed.

Roadmap

Things I'm working toward. No promises on timelines, but this is roughly the priority order.

Better solo and duet play

For the DM who runs the table for everyone else and wants to play for once. Familiar already runs the DM's side; these sharpen it for a table of one or two.

• Companion party-fill: let the AI run a designated ally's combat turns, so one hero against four goblins is a fight again, not a mugging
• Encounter scaling: balance a fight for a solo or duet party
• Solo mode: a one-click preset for what already works manually today — it puts the AI on the rules, the monsters, and the NPC voices in a single toggle, so you can sit in a player's seat at your own table

Module integrations

Let Familiar drive the rest of your Foundry stack: animations, loot, and visual effects. Combat automation itself is built in and runs standalone — integrations target the visual and quality-of-life layer.

| Module | What Familiar will do with it | |--------|-------------------------------| | Sequencer + JB2A | Orchestrate animation sequences and trigger spell effects | | Token Magic FX | Apply shader effects to tokens and tiles (fire auras, glowing shields) | | Item Piles | Create and manage loot drops, merchants, and treasure hoards | | DFreds Convenient Effects | Apply and manage curated status effects and buffs |

Game system support

Expanding beyond D&D 5e with full system-specific tools: character sheets, combat automation, and spell resolution.

| System | Status | |--------|--------| | D&D 5e (2024) | Supported | | Pathfinder 2e | Planned | | Call of Cthulhu | Planned | | Savage Worlds | Planned |

Plug-and-play adventures

Import a published adventure, enable Familiar, and the AI already knows the story, NPCs, maps, and encounters. Starting with Ember, Foundry's own 500-hour sandbox campaign, and expanding to more published modules.

Sharpening what already ships

• Combat AI: retreat behavior, morale, and group coordination beyond what ships today
• Voice generation: emotion control, more natural multi-voice conversations
• Image generation: consistent character portraits across sessions, plus style presets
• MCP: richer notifications/message feedback so external clients see tool progress in real time

Feedback

Got an idea? The Discord is the best place to push something up the list, file a bug, or just tell me about the weird thing the AI did to your goblin encounter.

License

Familiar is licensed under the PolyForm Shield License 1.0.0: you can use and self-host it for any purpose except building a competing product. It ships as a compiled build, and the source repository is private. See LICENSE for the full text.

Familiar is an independent product. It is not affiliated with, endorsed, sponsored, or approved by Wizards of the Coast LLC. Dungeons & Dragons and D&D are trademarks of Wizards of the Coast LLC.

This work includes material from the System Reference Document 5.2.1 ("SRD 5.2.1") by Wizards of the Coast LLC, available at https://www.dndbeyond.com/srd. The SRD 5.2.1 is licensed under the Creative Commons Attribution 4.0 International License, available at https://creativecommons.org/licenses/by/4.0/legalcode.

Built for the DM who has more ideas than free time, and wouldn't mind playing for once.

Install Familiar, free for a month

May your rolls be high, your prep be low, and your players never notice the AI is helping.