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. Its default resolution depends on your map size and 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 higher resolution tokens and sharper map details. In that case, double everything: a 20x20 map becomes 2800 x 2800 pixels, 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, set the canvas size to match your pixel dimensions. If you're aiming for 2100x1400 pixels, that's your canvas. Inkarnate Pro users can enter custom dimensions; free users need to work within the preset options.

Enable the grid overlay in Inkarnate and set the columns and rows to match your planned grid. For a 30x20 map, set 30 columns and 20 rows. This gives you a visual guide while building. One warning: Inkarnate's grid isn't perfectly accurate. If you set 40 columns, you might get 42 or 44. Count the actual squares manually before trusting the display.

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, two medium creatures can't pass each other in a 5-foot hallway without squeezing. 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. This is the setting that matters most. When you click Export, select the VTT (Grid) option. 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. 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 (unless you exported at 140 pixels per square, in which case set it to 2).

Upload your exported map image to your Roll20 library. Drag it onto the Map layer (not the Token layer). The image should fill the page exactly if your dimensions are correct.

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.

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 Goes Black at High Resolution

Inkarnate occasionally fails when exporting very large maps, particularly at 4K or higher resolutions. The browser runs out of memory and produces a black image. 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 it doesn't snap imported images to hex alignment the way it does with square grids. You lose the automatic alignment entirely.

The workflow for hex maps requires more manual adjustment. Export your Inkarnate map with the hex grid turned off. In Roll20, set your page to use a hex grid and 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, set the cell width to 2 so the grid draws at 140-pixel intervals. The tokens and grid will look identical to players, but the underlying map image will be twice as sharp.

The tradeoff is file size. A 4200 x 2800 PNG is roughly four times larger than a 2100 x 1400 PNG. 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 squares it contains.

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 dimensions to match your planned squares. Foundry calculates the rest.

Inkarnate doesn't currently export the UVTT file format that some Foundry modules use for automatic wall and lighting detection. You'll need to configure walls and lighting manually after import, or use a third-party module like Myxelium's Battlemap Importer to speed up the process.

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. Create Inkarnate templates at those sizes.

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.