Guide

Different image on each instance in Blender

Give every object, array copy or Geometry Nodes instance its own image in Blender: one material per image, an atlas with UV offsets, UDIM, or a faster add-on.

Tested by Pavel at Mendbox Studio

In Blender 4.2 and 5.2 · Updated 16 November 2026

Blender has no "image index per object" input, so one shared material shows one image everywhere. To give each object or instance its own picture, either use one material per image, or pack all images into one atlas and let each object pick its cell through a number the shader can read (an object custom property, or a named attribute stored on a Geometry Nodes instance). The first is fine for a handful of images. The second is the one that scales to dozens, and I ran every step below in Blender 4.2, 4.5 and 5.2.

Why the obvious node setup only gives colours

The first thing most people try is Object Info. Its Random output is a different number from 0 to 1 for every object, and for every Geometry Nodes instance too. Plug it into a Color Ramp and each object gets its own colour.

That is a colour, not a picture. The Image Texture node loads one image and has no socket for "which image". Random into a Color Ramp suits randomised tints and stops there. What you need is a number per object that chooses an image.

Method 1: one material per image

For a handful of pictures this is the simplest thing that works and needs no node maths.

  1. Select the object and open the Material Properties tab.
  2. Create a material, add an Image Texture node, open the picture and connect Color to the Base Color of the Principled BSDF.
  3. Duplicate the object (Shift D) and give the copy the next material, one object per picture.

It breaks down when pictures multiply: every new one means a new material and a manual assignment. Instances from Instance on Points or the Array modifier share the material of their source, so they cannot get different pictures this way at all.

Method 2: an atlas with a UV offset per object

This is the method that scales. All pictures go into one image laid out in a grid, and the shader shifts the UVs so each object looks at one cell.

Make the atlas

Put your pictures into a grid of equal cells in any image editor, for example 2 columns by 2 rows for four images, and save one image. Cell 0 is bottom-left, cell 1 is to its right, and rows count upward, because UV space starts at the bottom-left.

Set the Image Texture node's Interpolation to Closest while you test. With Linear, neighbouring cells can bleed into each other at the edges, so leave a few pixels of padding between pictures when you switch it back.

Build the shader

Use an index number i from 0 to the number of cells minus one. For a grid with cols columns and rows rows, the cell column is i modulo cols and the row is floor(i / cols).

  1. Add Texture Coordinate and take its UV output into a Mapping node. Set Type to Point.
  2. Set Mapping Scale to 1/cols, 1/rows, 1. For the 2 by 2 atlas that is 0.5, 0.5, 1. This shrinks the UV square to one cell.
  3. Add a Math node set to Floored Modulo with the second value cols. This is the column.
  4. Add a Math node set to Divide by cols, then a Math node set to Floor. This is the row.
  5. Divide the column by cols and the row by rows with two more Math > Divide nodes, and put the results into X and Y of a Combine XYZ node.
  6. Connect Combine XYZ to the Location input of the Mapping node.
  7. Connect Mapping Vector to the Image Texture Vector, and its Color to the Principled BSDF Base Color (or to an Emission node for a screen).

Now the only missing piece is how the index i gets to each object.

Option A: random index from Object Info

Connect Object Info > Random to a Math > Multiply by the number of cells, then to a Math > Floor, and feed the result into the chain above as i. In my test, four planes with one shared material got green, blue, blue and red. Random picks repeat, with few objects some pictures may not appear at all, and you cannot choose which object shows what.

Option B: a custom property per object

When you want control, or no repeats:

  1. Select an object. Open the Object Properties tab, Custom Properties panel, and press New. Name it img_index, type Float.
  2. Type the cell number as the value.
  3. In the shader add an Attribute node, set Type to Object and Name to img_index, and connect its Fac output to the index chain.

For many objects, set it from the Scripting workspace:

import bpy
for i, ob in enumerate(bpy.context.selected_objects):
    ob["img_index"] = float(i % 4)

In my test, planes given 3, 0, 2 and 1 showed the cells 3, 0, 2 and 1 of the atlas.

Option C: Geometry Nodes instances

Instances do not have custom properties, but they can carry a named attribute.

  1. In your Geometry Nodes tree, after Instance on Points, add a Store Named Attribute node. Set Data Type to Float and Domain to Instance. The domain is the thing people miss, because the default is Point.
  2. Set the Name to img_index, and connect Index (from the Index node) to Value. Use a Math > Modulo if you have more instances than images.
  3. In the shader, add an Attribute node with Type set to Instancer and Name img_index, and feed its Fac into the same index chain.

The instanced geometry must use that material (a Set Material node before Instance on Points). My four instances showed four different cells. For random picks only, Object Info > Random also differs per instance, so Option A works on instances without any attribute.

The Index node follows the order the points were generated, which for a Grid is column by column in my test. To put a specific picture at a specific place, check the order first.

Method 3: UDIM tiles

A UDIM image has numbered tiles. Tile 1001 is the UV square from 0 to 1, tile 1002 the next square to the right, and so on. You can load files named name.1001.png and name.1002.png as one tiled image.

Each object still has to look at its own tile, so the shader is the same job as the atlas: a Mapping node whose Location X comes from an Attribute node. I tested it. With a custom property udim_u of 0 or 1 on four planes, they showed tile 1001 and tile 1002 alternately.

UDIM does not save work here. You still need an index per object, plus one file per tile and the naming convention. It suits one model with several high-resolution texture areas, not a hundred different posters.

Method 4: an image sequence with a frame offset

An image sequence is a numbered series of files that Blender steps through by frame. Set the Image Texture node to a sequence and use its Offset to shift where each material starts.

The offset belongs to the node, so every object with that material shares it. I rendered three planes with three materials at offsets 0, 1 and 2 on frame 1 and got three different pictures. That works, but it is Method 1 again: one material per offset. I did not find a stock way to drive the offset per object from one material, so for a different picture per object an atlas is easier.

What goes wrong

  • Pictures look squashed. A portrait picture in a square cell is stretched. Make the cells the shape of your pictures.
  • Seams show neighbouring pictures. Linear filtering reads across cell borders. Leave padding or inset the UVs a pixel or two.
  • All instances show the same cell. The named attribute is stored on the Point domain, not Instance, or the shader Attribute node is set to Geometry instead of Instancer.
  • Every object shows the first picture. The Attribute node finds no attribute with that name and returns 0. Check that img_index is spelled the same in the property or Store Named Attribute and in the Attribute node. I tested a misspelled name and a missing property in 4.2.23 and 5.2.2, and all four planes showed cell 0.
  • More fixes are on the Image Per Instance troubleshooting page.

Which method fits

MethodGood forBreaks when
One material per imageUp to about ten picturesInstances, many pictures, later changes
Atlas + Object Info RandomRandom look on many objectsYou need a chosen or even spread
Atlas + custom propertyChosen picture per separate objectInstances, since they have no custom properties
Atlas + Store Named AttributeArray and Instance on PointsNeeds a Geometry Nodes tree and a shader chain
UDIMOne model with several texture areasMany different pictures
Image sequenceAnimated or numbered picturesPer-object offset on one material

Faster with Image Per Instance

Image Per Instance builds the atlas method for you, using the same technique as above. It stores an img_index value (an object custom property on separate objects, and a Store Named Attribute on the Instance domain on instances), and one shared material reads it with an Attribute node. That is the setup you just built by hand.

What it does in practice:

  1. Pick a folder of images in the sidebar tab (N, Image Per Instance) and press Build Atlas. The images are packed into one atlas inside the .blend, in file-name order.
  2. Select objects and press Apply To Selected Objects, or make the object with the Instance on Points or Array modifier active and press Add To Instances (Geometry Nodes).
  3. Set Order to Shuffle to use every image once before any repeats, and change the Seed for another arrangement.

It also covers padding between cells, tile shape and fit modes so pictures are not squashed, choosing a picture per object or matching it by object name, and mapping without UVs. The limits (one atlas per file, 16384 px per side) are on the product page, and the steps are in the Image Per Instance workflows. It needs Blender 4.2 or newer. The free Image Per Instance Lite builds the atlas and applies it to separate objects, up to 20 images, without Geometry Nodes instances or Shuffle. For a few pictures once, the manual atlas above is free and works.

Image Per Instance — $12
Blender add-on that packs a folder of images into one atlas and gives every object, array element or Geometry Nodes instance its own picture on one material.