Inkarnate to Roll20: Grid Alignment Guide

The problem is simple: Inkarnate's grid and Roll20's grid don't speak the same language. Roll20 uses 70 pixels per grid square as its baseline. Inkarnate uses a different system entirely. Unless you configure your export correctly, your carefully placed furniture will be floating between squares, and your 5-foot hallways will be impassable.

This guide covers the math, the workflow, and the specific settings you need to get your Inkarnate battle maps into Roll20 with grids that actually align.

Why the Grids Don't Match

Roll20's grid system is built on a fixed baseline: 70 pixels equals one grid cell. When you create a page in Roll20 and set it to 20 squares wide, the platform expects an image that's 1400 pixels wide (20 multiplied by 70). If your image is 1500 pixels wide, Roll20 either stretches it to fit or leaves you with partial squares at the edges.

Inkarnate doesn't automatically export at 70 pixels per square. The pixel size of an export depends on your map's aspect ratio, the resolution you choose, and your subscription tier. Free accounts export at up to 2K resolution. Creator accounts can export up to 8K. Neither of these automatically aligns with Roll20's grid math.

The result: you import a beautiful map and spend twenty minutes manually resizing it, holding Alt to disable snapping, dragging corners pixel by pixel. Even then, the alignment drifts toward the edges of the map. Tokens that fit perfectly in the center are half a square off near the corners.

The Math You Need

Roll20's formula is straightforward. Total pixels equals number of squares multiplied by 70. A 30x20 battle map needs to be 2100 pixels wide and 1400 pixels tall. A 40x40 dungeon floor needs to be 2800 by 2800 pixels.

Here are common battle map sizes and their Roll20-compatible dimensions:

Small encounter (20x20 squares): 1400 x 1400 pixels
Medium encounter (30x20 squares): 2100 x 1400 pixels
Large encounter (40x30 squares): 2800 x 2100 pixels
Dungeon floor (50x50 squares): 3500 x 3500 pixels

These dimensions assume you want Roll20's default 70 pixels per square. Some GMs prefer 140 pixels per square for sharper map details. In that case, double everything: a 20x20 map becomes 2800 x 2800 pixels, the Roll20 page becomes 40 by 40 (Roll20 measures the page in 70-pixel units), and you set Roll20's cell width to 2 (which draws lines every 140 pixels instead of 70).

Step-by-Step: Inkarnate to Roll20

Step 1: Plan Your Dimensions First

Before you place a single tree in Inkarnate, decide how many squares your map will be. This is the decision you can't easily change later. Think about what the encounter needs: a tavern brawl might only need 15x15 squares, while a forest ambush might need 40x30 to give the party room to maneuver.

Write down two numbers: your grid dimensions (e.g., 30x20) and your pixel dimensions (e.g., 2100x1400). You'll need both.

Step 2: Set Up Your Inkarnate Map

When creating a new map in Inkarnate, you don't set a size in pixels. You choose an aspect ratio, measured in grid tiles. If you're aiming for 30x20 squares, choose Custom and enter 30 columns and 20 rows. Custom aspect ratios need a paid plan (Creator or Studio); free users get the Landscape preset, which is 40 x 30 tiles.

Show the Grid layer in Inkarnate (a new battle map has one, hidden by default) and check that its columns and rows match your planned grid. For a 30x20 map, that's 30 columns and 20 rows. This gives you a visual guide while building.

Step 3: Build Your Map

With your grid visible, place assets on grid boundaries. Doors should align with square edges. Walls should follow grid lines. Tables and chairs can float anywhere, but structural elements need to snap to the grid or your players will spend the combat arguing about whether they can squeeze past the bookshelf.

Pay attention to doorways and corridors. A standard 5-foot hallway is one square wide. In D&D, a Medium creature takes up one 5-foot square, and you can't willingly end a move in a space occupied by another creature. If your corridor looks one square wide but renders as 1.3 squares in Roll20, you've created a headache for yourself.

Step 4: Export with the Right Settings

Inkarnate's VTT Export feature lets you specify grid size in pixels at export time. It comes with Inkarnate's paid plans, not the Free plan, and it needs a square grid on the map. This is the setting that matters most. Open the Main Menu, choose Export as Image, and select the VTT (Grid) export mode. You'll see fields for grid size in pixels and for columns and rows.

Set your pixel grid size to 70 (or 140 if you're doubling for higher resolution). Set columns and rows to match your planned grid. The export will calculate the total image dimensions automatically.

Turn off the visible grid before exporting, using the "Show Main Grid" checkbox in the VTT (Grid) settings. Roll20 draws its own grid on top of your map. If you export with Inkarnate's grid visible, you'll have two grids that don't quite overlap, creating visual noise and making the misalignment obvious.

Step 5: Import to Roll20

In Roll20, create a new page. Under Page Settings, set the width and height in squares to match your map. For a 30x20 map, enter 30 and 20. Leave the cell width at 1. If you exported at 140 pixels per square, enter 60 and 40 instead, because Roll20 measures the page in 70-pixel units, and set the cell width to 2.

Upload your exported map image to your Roll20 library. Drag it onto the Map layer (not the Token layer). Roll20's Smart Sizing prompt then offers to resize the page to match your image or resize your image to fit the page. If your dimensions are correct, the image fills the page exactly either way.

If the map doesn't align perfectly, right-click the image, select Advanced, then Set Dimensions. Enter the pixel dimensions of your export (e.g., 2100 x 1400). This forces Roll20 to display the image at its native size.

Step 6: Fine-Tune the Alignment

Sometimes the map is close but not perfect. The grid lines in the center align, but they drift by a few pixels near the edges. This happens when your export dimensions are slightly off from the mathematical ideal.

Hold Alt while dragging the map to disable grid snapping. Move the image until the center of the map aligns with Roll20's grid. Center alignment is more important than corner alignment because most combat happens in the middle of the map.

If vertical grid lines are consistently to the left of where they should be, increase the image width in Set Dimensions. If horizontal lines are above where they should be, increase the height. Small adjustments of 5-10 pixels can make the difference between "close enough" and "perfect."

Common Problems and Fixes

The Map Looks Stretched

Roll20 is resizing your image to fit the page dimensions you specified. Your image is either too large or too small for the page. Check that your Roll20 page settings (width and height in squares) match the grid dimensions you planned in Inkarnate. Then use Set Dimensions to force the image to its native pixel size.

The Grid Drifts at the Edges

Your total pixel dimensions aren't evenly divisible by 70. A map that's 2000 pixels wide should be 2100 pixels wide for 30 squares, or 1960 pixels wide for 28 squares. The partial pixel per square accumulates across the map, causing drift. Re-export at corrected dimensions. A custom export size needs a paid Inkarnate plan; on the Free plan, resize the image in an image editor instead.

Doorways Don't Fit Tokens

You built the map without a grid overlay, or your Inkarnate grid wasn't set to the same number of squares as your Roll20 page. The visual alignment is off even if the mathematical alignment is correct. This requires rebuilding the map with the grid visible from the start.

The Export Fails at High Resolution

Inkarnate's export dialog warns that higher export resolutions require a lot of RAM and video memory and may not work well on all systems. Its recovery dialog says that layers going black usually means your system ran out of RAM. Try exporting at a lower resolution, or break a large dungeon into multiple map files.

Hex Grids: A Different Beast

Hex grids add complexity. Roll20 supports hex grids, but Inkarnate's VTT (Grid) export only works with a square grid. You lose the automatic sizing entirely.

The workflow for hex maps requires more manual adjustment. Export your Inkarnate map with the hex grid showing, so there is a pattern to line up against. In Roll20, set your page to use a hex grid, then use the Align to Grid tool on the Map Layer, whose new version works with hex grids, or adjust the cell size until it visually matches the hex pattern in your map. Hold Alt while positioning the image. Expect to spend more time fine-tuning.

Some GMs skip the hex alignment entirely and just use the map as a visual backdrop without mechanical grid precision. For theater-of-the-mind encounters where exact positioning doesn't matter, this works fine. For tactical combat where hex facing and distance matter, you'll need to invest the time in manual alignment.

Higher Resolution Options

Roll20's 70-pixel baseline produces maps that look acceptable on most screens but can appear blocky when zoomed in. If your players are on high-DPI displays or you frequently zoom for dramatic close-ups, consider exporting at 140 pixels per square.

The workflow is identical except you double all your pixel dimensions. A 30x20 map becomes 4200 x 2800 pixels. In Roll20, enter the page size as 60 by 40, because the page is measured in 70-pixel units, and set the cell width to 2 so the grid draws at 140-pixel intervals. Each square then has twice as many map pixels across.

The tradeoff is file size. A 4200 x 2800 image has four times as many pixels as a 2100 x 1400 one. Roll20's free tier has storage limits, and larger images take longer to load during sessions. For most home games, 70 pixels per square is sufficient.

Beyond Roll20: Foundry VTT

Foundry VTT uses a different approach to grid alignment. Instead of forcing images to match a fixed pixel-per-square ratio, Foundry lets you configure the grid size after importing the image. You upload your map at whatever resolution you exported, then tell Foundry how many pixels wide each square is.

This makes the import process simpler. Export your Inkarnate map at the highest resolution your subscription allows. Upload it to Foundry. In the scene configuration, set the grid size in pixels. Foundry reads the image's dimensions on its own.

Inkarnate doesn't currently export the UVTT file format that some Foundry modules use to import walls and lighting. You'll need to configure walls and lighting manually after import. A third-party module like Myxelium's Battlemap Importer can build the scene and detect the grid from a plain image, but it only imports walls and lights from a JSON export.

Building the Habit

The fastest way to avoid grid alignment headaches is to standardize your map sizes. Pick two or three dimensions you use repeatedly: maybe 30x20 for combat encounters, 50x50 for dungeon floors, and 60x40 for outdoor battlefields. Memorize the pixel dimensions for each. Keep a blank Inkarnate map at each of those sizes and clone it when you start a new one.

When your dimensions are consistent, the workflow becomes automatic. You stop calculating pixels for every map. You know that your standard encounter map is always 2100 x 1400 pixels, and you know it will always import cleanly to Roll20. The alignment problem disappears because you've engineered it away at the start of the process.

The ten minutes you spend planning dimensions before building saves thirty minutes of adjustment after exporting. Your players never see the technical work, but they notice when tokens fit through doors and the grid lines up with the walls. Good maps start with good math.