How to Split an Image for Instagram Grid & Carousel

Image splitting takes one wide or tall photo and cuts it into multiple tiles that reassemble as a single panorama on your Instagram profile or carousel. Scroll past a grid account and you'll recognize the effect instantly: a dramatic landscape spread across nine squares, or a product reveal that forces visitors to swipe through six slides to see the full picture.

The technique works in two different contexts with different rules:

• Carousel posts — all tiles are in one post, viewers swipe left, and Instagram preserves the sequence automatically.
• Grid splits — each tile is a separate post. Your profile grid stitches them visually, but you must post them in a specific order or the mosaic breaks.

Both require precise dimensions. Get them wrong and you'll see gaps, misalignment, or content cropped by Instagram's forced 1:1 display on the profile page.

Grid Split Types and Tile Dimensions

Every split type at 1080px standard resolution:

All tiles are square (1080×1080 px) for standard feed posts. Instagram allows carousel slides up to 1080×1350 px (4:5 portrait), but mixing portrait tiles in a carousel causes inconsistent display — stick with square tiles for splits.

Understanding Instagram Dimensions

Before you split anything, the source image needs to be correct. Instagram renders feed images at 1080px wide. Upload smaller and Instagram upscales — which softens your image. Upload larger and Instagram downscales, which is fine.

Key specs that affect splits:

For a full breakdown of every Instagram size across all placements, see the Instagram image size guide.

Prepare your source image first. Before splitting, get the source image to the exact target size. For a 3×3 grid, that's 3240×3240 px — not approximately, exactly. Any rounding error accumulates across nine tiles and you'll see pixel-wide gaps on the profile grid.

Use Pixotter's resize tool to get exact dimensions before running any split command. You can also crop to the right aspect ratio in one step.

How to Split for a Carousel Post

A carousel split is forgiving: all tiles live in one post and Instagram preserves order. The challenge is the source image width — a 3-panel panorama is 3240×1080 px, which means you need a landscape shot with enough subject matter to sustain interest across all three slides.

What works: Cityscapes, landscapes, wide product flats, infographics, before/after comparisons.

What doesn't: Portrait photos (you'd need to pad them massively), dense text layouts (cutting across a word looks terrible), faces near the center (the cut lands right on someone's nose).

For a 3×1 carousel at 1080px:

• Source: 3240×1080 px
• Tile 1 (leftmost in the panorama): x=0, y=0, width=1080, height=1080
• Tile 2 (center): x=1080, y=0, width=1080, height=1080
• Tile 3 (rightmost): x=2160, y=0, width=1080, height=1080

Upload them to a single carousel post in order left-to-right. Viewers swipe left → right, so tile 1 appears first.

How to Split for a Grid Post (3×3)

A 3×3 grid split is where things get tricky. Nine separate posts must arrive on your profile in the right order, and Instagram's grid fills from top-right to bottom-left — the most recent post goes in position (row 1, column 3).

3×3 Grid Upload Order

Your source image coordinate system maps to grid positions like this:

Source image layout:        Instagram profile grid:
+-------+-------+-------+  +-------+-------+-------+
| [0,0] | [1,0] | [2,0] |  | col3  | col2  | col1  |
+-------+-------+-------+  | post9 | post8 | post7 |  ← row 1 (top)
| [0,1] | [1,1] | [2,1] |  +-------+-------+-------+
+-------+-------+-------+  | post6 | post5 | post4 |  ← row 2
| [0,2] | [1,2] | [2,2] |  +-------+-------+-------+
+-------+-------+-------+  | post3 | post2 | post1 |  ← row 3 (bottom)
                           +-------+-------+-------+
                           (oldest)              (newest)

Post order for a 3×3 grid (bottom-right to top-left):

The reason to number tiles and post in strict order: Instagram's grid is immutable once posts are live. If you post tile 7 before tile 4, the whole mosaic is broken and you can't reorder without deleting and reposting.

For more on grid dimensions and aspect ratios, see social media image sizes.

Method 1: ImageMagick 7.1 CLI

License: Apache 2.0 | Download: imagemagick.org

ImageMagick 7.1 is the fastest option once you have the command right. It processes a 3240×3240 px source into nine tiles in under a second.

Install ImageMagick 7.1

# macOS (Homebrew)
brew install imagemagick

# Ubuntu / Debian
sudo apt update && sudo apt install imagemagick

# Windows — download the installer from imagemagick.org
# Verify version:
magick --version
# Should output: Version: ImageMagick 7.1.x

Split a 3×1 Carousel (3 tiles)

# Source: panorama.jpg (3240×1080 px)
# Output: tile_01.jpg, tile_02.jpg, tile_03.jpg

magick panorama.jpg \
  -crop 1080x1080+0+0    +repage tile_01.jpg \
  -crop 1080x1080+1080+0 +repage tile_02.jpg \
  -crop 1080x1080+2160+0 +repage tile_03.jpg

Each -crop WxH+X+Y specifies width, height, and the top-left corner offset. +repage removes the virtual canvas offset so downstream tools see clean images.

Split a 3×3 Grid (9 tiles, named by upload order)

# Source: grid_source.jpg (3240×3240 px)
# Named by upload order: post_01 = post first (bottom-right), post_09 = post last (top-left)

magick grid_source.jpg -crop 1080x1080+2160+2160 +repage post_01.jpg  # bottom-right
magick grid_source.jpg -crop 1080x1080+1080+2160 +repage post_02.jpg  # bottom-center
magick grid_source.jpg -crop 1080x1080+0+2160    +repage post_03.jpg  # bottom-left
magick grid_source.jpg -crop 1080x1080+2160+1080 +repage post_04.jpg  # middle-right
magick grid_source.jpg -crop 1080x1080+1080+1080 +repage post_05.jpg  # center
magick grid_source.jpg -crop 1080x1080+0+1080    +repage post_06.jpg  # middle-left
magick grid_source.jpg -crop 1080x1080+2160+0    +repage post_07.jpg  # top-right
magick grid_source.jpg -crop 1080x1080+1080+0    +repage post_08.jpg  # top-center
magick grid_source.jpg -crop 1080x1080+0+0       +repage post_09.jpg  # top-left

Automate with a Shell Loop

If you do this regularly, a single command is cleaner:

#!/usr/bin/env bash
# split_grid.sh — splits a 3240×3240 image into 9 Instagram grid tiles
# Usage: ./split_grid.sh source.jpg

SOURCE="$1"
TILE=1080

# Order: bottom-right to top-left (upload order)
declare -a COORDS=(
  "2160:2160"  # post_01
  "1080:2160"  # post_02
  "0:2160"     # post_03
  "2160:1080"  # post_04
  "1080:1080"  # post_05
  "0:1080"     # post_06
  "2160:0"     # post_07
  "1080:0"     # post_08
  "0:0"        # post_09
)

for i in "${!COORDS[@]}"; do
  IFS=':' read -r X Y <<< "${COORDS[$i]}"
  NUM=$(printf "%02d" $((i+1)))
  magick "$SOURCE" -crop ${TILE}x${TILE}+${X}+${Y} +repage "post_${NUM}.jpg"
  echo "Created post_${NUM}.jpg (offset ${X},${Y})"
done
echo "Done. Post in order: post_01.jpg first, post_09.jpg last."

Method 2: Python Pillow 10.4

License: HPND (Historical Permission Notice and Disclaimer) — effectively public domain | Install: pip install Pillow==10.4.0

Pillow gives you more control than a shell script if you want to add captions, borders, or watermarks to each tile, or if you're integrating into a larger automation pipeline.

Install Pillow 10.4

pip install Pillow==10.4.0

# Verify:
python -c "from PIL import Image; print(Image.__version__)"
# Output: 10.4.0

Split Script for 3×3 Grid

#!/usr/bin/env python3
"""
instagram_grid_split.py — Split a 3240×3240 image into 9 Instagram grid tiles.
Tiles are named by upload order (post_01 = bottom-right, post_09 = top-left).

Requires: Pillow 10.4.0
Usage: python instagram_grid_split.py source.jpg
"""

import sys
from pathlib import Path
from PIL import Image

TILE_SIZE = 1080

# Upload order: (col, row) in source image coordinates
# col 0 = left, col 2 = right | row 0 = top, row 2 = bottom
UPLOAD_ORDER = [
    (2, 2),  # post_01 — bottom-right
    (1, 2),  # post_02 — bottom-center
    (0, 2),  # post_03 — bottom-left
    (2, 1),  # post_04 — middle-right
    (1, 1),  # post_05 — center
    (0, 1),  # post_06 — middle-left
    (2, 0),  # post_07 — top-right
    (1, 0),  # post_08 — top-center
    (0, 0),  # post_09 — top-left
]


def split_grid(source_path: str, tile_size: int = TILE_SIZE) -> None:
    source = Path(source_path)
    img = Image.open(source)

    expected_w = tile_size * 3
    expected_h = tile_size * 3
    if img.size != (expected_w, expected_h):
        raise ValueError(
            f"Source must be {expected_w}×{expected_h} px, got {img.width}×{img.height} px. "
            f"Resize first at pixotter.com/resize/"
        )

    output_dir = source.parent / f"{source.stem}_tiles"
    output_dir.mkdir(exist_ok=True)

    for idx, (col, row) in enumerate(UPLOAD_ORDER, start=1):
        left = col * tile_size
        upper = row * tile_size
        right = left + tile_size
        lower = upper + tile_size

        tile = img.crop((left, upper, right, lower))
        out_path = output_dir / f"post_{idx:02d}.jpg"
        tile.save(out_path, "JPEG", quality=95, optimize=True)
        print(f"post_{idx:02d}.jpg — col {col}, row {row} (offset {left},{upper})")

    print(f"\nTiles saved to: {output_dir}/")
    print("Upload post_01.jpg first, post_09.jpg last.")


if __name__ == "__main__":
    if len(sys.argv) != 2:
        print(f"Usage: python {sys.argv[0]} source.jpg")
        sys.exit(1)
    split_grid(sys.argv[1])

Run it:

python instagram_grid_split.py grid_source.jpg
# Creates: grid_source_tiles/post_01.jpg through post_09.jpg

The script validates source dimensions before running — if you pass the wrong size image, it tells you what size is needed and stops before producing broken tiles.

Method 3: GIMP 2.10

License: GPL v3 | Download: gimp.org

GIMP is the right choice if you want to visually inspect where the cuts land before committing — useful when you're placing a face or focal point and need to nudge the composition slightly.

Set Up Guides for a 3×3 Split

1. Open your 3240×3240 px source image.
2. Image → Guides → Create Guides by Percent…
   • Horizontal: 33.33, 66.67
   • Vertical: 33.33, 66.67
   • Click OK. Six guide lines appear dividing the canvas into a 3×3 grid.
3. Verify guides landed at exactly 1080 px and 2160 px. Image → Print Size or check guide position by dragging with the Move Tool and watching the coordinates in the bottom bar.

Export Tiles Using Script-Fu

GIMP 2.10's Script-Fu console (Filters → Script-Fu → Console) lets you automate the crop and export:

; GIMP 2.10 Script-Fu — export 3x3 grid tiles in Instagram upload order
; Run from: Filters → Script-Fu → Console
; Assumes: 3240x3240 px image is open

(let* ((image (car (gimp-file-load RUN-NONINTERACTIVE
                     "/path/to/grid_source.jpg"
                     "grid_source.jpg")))
       (tile 1080)
       ; Upload order: (col . row), 0-indexed, col 0=left, row 0=top
       (order (list '(2 . 2) '(1 . 2) '(0 . 2)
                    '(2 . 1) '(1 . 1) '(0 . 1)
                    '(2 . 0) '(1 . 0) '(0 . 0))))
  (let loop ((pairs order) (n 1))
    (when (not (null? pairs))
      (let* ((col (car (car pairs)))
             (row (cdr (car pairs)))
             (x (* col tile))
             (y (* row tile))
             (copy (car (gimp-image-duplicate image)))
             (drawable (car (gimp-image-get-active-drawable copy)))
             (filename (string-append "/path/to/output/post_"
                                      (if (< n 10) "0" "")
                                      (number->string n) ".jpg")))
        (gimp-image-crop copy tile tile x y)
        (file-jpeg-save RUN-NONINTERACTIVE copy
                        (car (gimp-image-get-active-drawable copy))
                        filename filename
                        0.9 0 0 0 "" 0 1 0 2 0)
        (gimp-image-delete copy))
      (loop (cdr pairs) (+ n 1)))))

Replace /path/to/grid_source.jpg and /path/to/output/ with your actual paths before running.

For manual export without Script-Fu: use Filters → Web → Slice (GIMP 2.10) or crop each region manually with the Rectangle Select Tool, then File → Export As for each tile.

Tips for Clean Grid Splits

Avoid cuts through faces. A split line through someone's eyes or mouth looks accidental, not artistic. If your composition has a face, either center it on one tile entirely or place it far enough from a seam that the cut lands in background space.

Avoid cuts through text. Text split across two tiles reads as broken unless you planned it that way with very clean typography and a clear visual joke. Usually it just looks like a mistake.

Maintain visual flow across seams. A horizon line, a diagonal shape, or a color gradient that flows continuously across tiles makes the split feel intentional. Test by assembling the tiles side by side in any image viewer before posting.

Use image compression after splitting. Each 1080×1080 tile should be under 500 KB for fast upload. Instagram recompresses everything on upload anyway, but starting from a smaller file means less compression artifact from their pipeline. See how to compress an image to 500KB for JPEG quality settings that keep file size low without visible quality loss.

Test the grid before you commit. Create a test Instagram account (or use a private account) and post all nine tiles in order. Check the profile grid view before you commit to posting on your real account. Fixing a broken 3×3 requires deleting all nine posts and reposting in order — not fun with an active audience.

Batch resize before splitting. If you have multiple grid sets to produce, batch resize images to the exact source dimensions first, then run the split command. Doing it per-image individually is where errors creep in.

Check aspect ratio math. A 3×3 grid needs a 1:1 square source. A 3×1 carousel needs a 3:1 landscape source. Use the image aspect ratio calculator if you're cropping a photo to fit — starting from the wrong crop kills the whole composition.

FAQ

What size should my source image be for a 3×3 Instagram grid?

3240×3240 pixels exactly. Each of the nine tiles is 1080×1080 px, and three tiles across equals 3240 px. If your source is even one pixel off, your split command will produce tiles with inconsistent dimensions and you'll see gaps or misalignment on the profile grid.

What order do I upload Instagram grid tiles?

Bottom-right first, top-left last. Instagram fills your profile grid from left to right within each row, with the newest post always going in the top-right slot. So the first post you publish lands at row 3, column 3 (bottom-right). The ninth post lands at row 1, column 1 (top-left). The numbered tile list in the Method 1 and Method 2 sections above follows this order.

Can I use a 4:5 portrait tile instead of square tiles?

For carousel splits, yes — but only if all tiles are the same ratio. The first slide's aspect ratio locks the ratio for every other slide in that carousel post. For grid splits, no: Instagram's profile grid always displays posts as 1:1 squares, so a 4:5 tile will be center-cropped in the grid view.

How many slides can a carousel split have?

Instagram allows up to 10 slides per carousel post. That gives you a maximum 10×1 panorama split at 10800×1080 px source, or a 2×5 split at 2160×5400 px. Most effective panoramas are 3–6 slides — beyond six, the payoff of the reveal rarely justifies the swiping.

Why do my grid tiles show a white gap between them on my profile?

This happens when tiles are not exactly 1080×1080 px. Even a 1-pixel rounding error accumulates across the row. Check your source dimensions first (magick identify source.jpg outputs exact pixel dimensions). If the source is correct and you still see gaps, it may be Instagram's display scaling on certain screen sizes — most devices show it clean.

Does the split work the same way for Reels cover images?

No. Reels covers display at 1080×1920 px (9:16) in the grid view, not 1:1. If you're splitting a grid that includes Reels, those posts will be cropped to 1:1 in the grid regardless of the cover image. For consistent grid aesthetics, stick to photo posts for your grid split.

Do I need to compress the tiles before uploading?

Instagram recompresses everything on upload, so compression artifacts from their pipeline are unavoidable. Uploading at higher quality (JPEG 90–95) gives Instagram's encoder better source material to work with. Keep individual tiles under 2 MB to avoid slow uploads. Use the Pixotter compress tool to hit that target without visible quality loss.

Can I split an animated GIF for Instagram?

Instagram does not support animated GIFs as posts — it converts them to video. For grid or carousel purposes, treat the GIF as a static image: export the frame you want as a JPEG, then split it. If you want the animation, convert each tile segment to a short video clip and post as a carousel of videos.