The difference between INSERT and MINSERT

INSERT places one editable reference

INSERT (or the Blocks palette) creates a single block reference at the point you pick, with the scale and rotation you specify. That reference is a normal, fully editable object: you can move it, copy it, rotate it, change its layer, explode it, or edit its dynamic parameters. It points at the block definition in the block table like any other reference, so redefining the block updates it.

This is the everyday command and the one you reach for the vast majority of the time. One INSERT, one independent block you can do anything with. To place many, you typically INSERT once and then COPY or ARRAY the result, keeping each copy fully editable.

MINSERT places a locked array

MINSERT inserts the same block multiple times in a rectangular grid, prompting you for the number of rows and columns and the spacing between them. The catch is that the entire grid is created as a single block reference with array properties baked in — not as many separate references. You get one object representing, say, a 4-by-6 grid of identical chairs.

Because it is one object, MINSERT is memory-efficient: a large grid of identical blocks is stored very compactly. That was its original appeal in the era of tight memory budgets. But that single-object nature is also the source of every limitation that follows, because the individual blocks in the grid have no independent existence.

The big limitation: MINSERT cannot be exploded normally

A MINSERT array carries a serious restriction: you cannot explode it the way you explode an ordinary block. The array structure prevents a clean explode, so you cannot break it apart into individual blocks or edit one cell of the grid on its own. You cannot select and delete a single chair from the array, move just one, or give one a different rotation.

This trips people up constantly. They MINSERT a grid of desks, then need to remove one for a doorway, and discover the array will not let them. The only ways out are to erase the whole MINSERT and rebuild with editable copies, or to use a workaround to convert it — neither of which is convenient. It is the principal reason MINSERT has fallen out of favour.

Editing a MINSERT array

What you can change on a MINSERT is the array as a whole. Through the Properties palette you can adjust the number of rows and columns, the row and column spacing, and the array's overall position, scale and rotation. Change the column count and the grid regenerates with that many columns. So the array is parametric at the grid level even though its individual cells are untouchable.

If you rotate a MINSERT, the whole grid rotates together, including the spacing directions. That can be useful for a tilted grid, but it reinforces the point: everything happens to the array as one unit. For anything that needs per-instance control, MINSERT is the wrong tool.

Modern alternatives: ARRAY and copy

Today the ARRAY command is almost always the better choice for repeating a block. An associative rectangular array gives you a grid you can re-parameterise (rows, columns, spacing) much like MINSERT, but you can edit, replace or suppress individual items, and you can explode the array into independent blocks when you need to. It delivers MINSERT's convenience without the editing dead end.

For irregular placement, plain INSERT plus COPY keeps every block fully independent from the start. And for a furnished layout where you will inevitably need to nudge one chair or remove one desk, independent copies or an associative array save you the rebuild that MINSERT would eventually force. MINSERT survives mainly for legacy compatibility and the rare case where a truly fixed, compact grid is genuinely all you need.

Choosing between them

Reach for INSERT for single blocks and any situation where you will edit instances individually — which is most of the time. Reach for ARRAY when you want a repeating grid you can still adjust and break apart later. Reserve MINSERT for the narrow case of a permanent, uniform grid where compactness matters more than editability and you are confident no cell will ever need individual attention.

- INSERT: one independent, fully editable reference. - MINSERT: a compact rectangular array locked as one object, not explodable normally. - ARRAY: the modern middle ground — grid convenience plus per-item editing.

In practice, most drafters use INSERT and ARRAY for everything and never touch MINSERT, precisely because its inability to edit or explode individual blocks outweighs its memory savings on modern hardware.