# 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.

- Page: https://mendboxstudio.com/guides/different-image-per-instance
- Updated: 2026-11-16
- Publisher: Mendbox Studio (Dynamic Flower Unipessoal LDA, Portugal)

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:

```python
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](https://mendboxstudio.com/docs/image-per-instance/troubleshooting).

## Which method fits

| Method | Good for | Breaks when |
|---|---|---|
| One material per image | Up to about ten pictures | Instances, many pictures, later changes |
| Atlas + Object Info Random | Random look on many objects | You need a chosen or even spread |
| Atlas + custom property | Chosen picture per separate object | Instances, since they have no custom properties |
| Atlas + Store Named Attribute | Array and Instance on Points | Needs a Geometry Nodes tree and a shader chain |
| UDIM | One model with several texture areas | Many different pictures |
| Image sequence | Animated or numbered pictures | Per-object offset on one material |

## Faster with Image Per Instance

[Image Per Instance](https://mendboxstudio.com/addons/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](https://mendboxstudio.com/docs/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.

---
Source: https://mendboxstudio.com/guides/different-image-per-instance
