What Does Dissolve Do in GIS?

Dissolve combines vector features that belong together and removes boundaries that are no longer meaningful in the output. You can dissolve an entire layer into one feature or use an attribute to combine only features that share the same value.

For example, suppose a dataset contains individual district polygons and each district has a region field. Dissolving by region can turn all districts belonging to the same region into one regional feature. Boundaries between districts in the same region disappear, while boundaries between different regions remain.

Dissolve therefore changes more than the appearance of a map. It changes what each feature in the dataset represents.

Dissolve at a glance

Suppose this is your input attribute table:

District: A1; Region: North; Population: 18,000
District: A2; Region: North; Population: 27,000
District: A3; Region: North; Population: 15,000
District: B1; Region: South; Population: 22,000
District: B2; Region: South; Population: 31,000

If you dissolve the layer using Region, the five district features can become two features:

North, containing the geometry of A1, A2, and A3;
South, containing the geometry of B1 and B2.

The boundaries separating A1, A2, and A3 are no longer needed because those districts now contribute to one feature. The same happens to the internal boundary between B1 and B2.

But this raises an important question: what happens to values such as Population?

Geometry can be combined mechanically. Attributes often require a decision.

That distinction is one of the most important things to understand about Dissolve.

Dissolve groups features

A useful mental model is:

Group features, then combine the geometry within each group.

The grouping can be based on one or more attributes.

If you dissolve a district dataset by Region, every distinct region value defines a group. If ten districts contain North and eight contain South, the operation can create one output feature for North and one for South.

If you instead dissolve by both Region and Land_Type, features only belong to the same group when both values match.

You can also dissolve without choosing a field. In that case, every input feature belongs to the same group and the operation attempts to combine them into one output feature.

QGIS, for example, describes its Dissolve operation as combining features sharing selected attribute values, or dissolving all features when no dissolve field is supplied. For polygon layers, shared boundaries between adjacent polygons in the same dissolved result are removed. See the QGIS Documentation — Dissolve.

Dissolve removes internal boundaries

Consider four adjacent polygons:

+------+------+
|  A   |  A   |
+------+------+
|  B   |  B   |
+------+------+

If the letters represent the dissolve field, dissolving by that field produces something conceptually closer to:

+-------------+
|      A      |
+-------------+
|      B      |
+-------------+

The boundary between the two A features disappears because it no longer separates two output features. The same happens between the B features.

The boundary between A and B remains because those areas still belong to different groups.

This is why Dissolve is often used to move from a finer geographic classification to a coarser one: districts to regions, parcels to ownership groups, habitat fragments to categories, or administrative subdivisions to higher-level units.

But the operation does not inherently know whether those groupings make geographic sense. It follows the values supplied to it.

A misspelled category, inconsistent identifier, or unexpected null value can therefore create a separate dissolved feature even when the user intended the records to belong together.

The dissolved features do not have to touch

A common misunderstanding is that Dissolve only works on adjacent polygons.

Suppose three islands all belong to the same administrative region. They are geographically disconnected, but they share the same dissolve value.

They can still become one multipart feature representing the region.

That feature contains several separate geometric parts while remaining one record in the dataset.

This distinction matters because:

one feature does not necessarily mean one continuous shape;
a dissolved polygon can contain disconnected pieces;
feature count and visible polygon count are not always the same thing.

Some GIS tools also provide an option to keep disconnected results as separate features rather than putting them into one multipart feature. That is an implementation choice rather than a different geographic concept.

If you need to understand the data-model distinction itself, multipart geometry deserves separate treatment from Dissolve.

Dissolve can combine overlapping geometry too

Dissolve is often illustrated using perfectly adjacent polygons, but its geometric effect is not limited to removing shared borders.

If geometries in the same dissolve group overlap, a true geometric dissolve can combine those overlapping areas so that the output no longer contains separate overlapping polygon pieces representing the same dissolved group.

At the geometry level, this is closely related to a union operation.

PostGIS makes the relationship particularly visible: its ST_Union function computes the point-set union of input geometries and merges overlaps. See PostGIS — ST_Union.

This does not mean that every GIS tool named Union is equivalent to Dissolve. As explained in Clip vs Intersect vs Union, a layer-overlay Union may preserve boundaries and attributes from multiple inputs rather than removing them.

The shared geometric mechanism does not make the analytical operations interchangeable.

What happens to the attributes?

This is where Dissolve becomes more consequential than the simple before-and-after diagram suggests.

Suppose three district features become one region:

District: A1; Region: North; Population: 18,000
District: A2; Region: North; Population: 27,000
District: A3; Region: North; Population: 15,000

After dissolving by Region, there is only one North feature.

What should its District value be?

There is no single correct answer. The output represents several districts, so keeping one district name would be misleading.

And what should happen to Population?

Keeping 18,000, 27,000, or 15,000 would all misrepresent the new regional feature. If population is meant to describe the resulting region, the values probably need to be summed, producing 60,000.

Other attributes require different treatment:

a population count might be summed;
a rate might require a weighted calculation rather than a simple mean;
a category might be identical within the dissolve group and therefore safe to retain;
a unique feature identifier may no longer have any sensible meaning;
free-text notes may not be meaningfully combinable at all.

The correct attribute treatment depends on what the field represents.

This is why a Dissolve tool's default attribute behaviour should not automatically be treated as analytically correct. For example, QGIS's native Dissolve currently retains the fields of the input layer but uses values from the first processed input feature for output fields. Its documentation explicitly distinguishes Dissolve from the separate Aggregate operation, where aggregation expressions can be defined. The behaviour of other GIS implementations can differ.

If the resulting attributes matter, inspect them rather than assuming that combining geometry also combined the data correctly.

Dissolve is not the same as aggregation

Dissolve and aggregation are closely related because both can turn many features into fewer features.

The difference is one of emphasis.

Dissolve is primarily concerned with combining geometry according to a grouping rule.

Aggregation generally makes the attribute summarisation an explicit part of the transformation as well.

Imagine dissolving districts into regions.

If all you need is regional geometry, Dissolve may be sufficient.

If you need regional geometry plus total population, mean income, facility count, minimum elevation, and another set of calculated values, you are performing a broader aggregation task.

Some GIS software packages expose these as separate operations; others allow statistical aggregation within a dissolve workflow.

Conceptually, however, it helps to keep the questions separate:

Which features belong together?
How should their geometries combine?
How should their attributes combine?

The first two describe the core dissolve operation. The third requires statistical and semantic judgement.

Dissolve is not Merge

Merge can also take many features and produce one output layer, but it usually does not mean that those features become one feature.

Suppose three district files contain 20, 15, and 25 features. Merging the compatible layers can produce one dataset containing all 60 features. Their original boundaries remain and the feature count is still approximately the sum of the inputs.

Dissolve may instead take those 60 features and turn them into, say, five regional features.

So:

Merge combines datasets.

Dissolve combines features or their geometry according to a grouping rule.

The difference matters even when both operations leave you with a single output file.

The planned Merge vs Append vs Union article will treat those dataset-combination operations separately.

Dissolve is not an overlay Union

The word union causes another common source of confusion.

A polygon-overlay Union generally combines two layers while preserving the spatial subdivisions created by both. Its purpose is to retain where either input exists and record how their boundaries relate.

Dissolve generally moves in the opposite structural direction: it removes boundaries that no longer distinguish output features.

Suppose a layer contains:

+---+---+---+
| 1 | 2 | 3 |
+---+---+---+

If all three features belong to the same dissolve group, Dissolve can remove the two internal boundaries.

An overlay operation whose purpose is to preserve differences between layers would not do that merely because the polygons touch.

For the broader distinction among common operation families, see Common GIS Vector Operations Explained.

Dissolving everything is a special case

If no grouping field is supplied, a Dissolve operation can attempt to combine the entire input layer.

This can be useful when the internal feature structure is irrelevant and only the overall footprint matters.

For example, suppose a protected-area dataset contains hundreds of adjoining or overlapping polygons, but the next step requires only the geographic area covered by any of them. Dissolving all features can create a representation of that combined footprint.

However, the resulting feature may still be multipart when the input contains disconnected areas.

And once everything becomes one feature, distinctions between the original records are no longer represented geometrically. If those distinctions may be needed later, preserve the original dataset rather than treating the dissolved output as a replacement.

What can go wrong?

Inconsistent dissolve values create unexpected groups

North, NORTH, and North may look equivalent to a human but be different values to a GIS operation.

If an output contains more groups than expected, inspect the actual attribute values before assuming the geometry operation failed.

Null values can form their own group

Records with missing grouping attributes can be handled together or differently depending on the software. Either way, a null dissolve value deserves inspection because it may represent incomplete classification rather than a meaningful geographic category.

Attributes can become misleading

The geometry may look correct while the attribute table silently retains a value from only one of several source features.

Always ask whether each surviving field still describes the new feature.

Multipart output can surprise later workflows

Several disconnected areas with the same dissolve value may become one multipart feature. If later processing assumes one contiguous geometry per record, this structural change matters.

Dissolve does not fix the meaning of bad source geometry

Unexpected gaps, overlaps, or invalid geometry in the input can affect the dissolved result. Dissolve may remove some visible boundaries, but that does not make an inaccurate or malformed source dataset correct.

When should you use Dissolve?

Dissolve is a good fit when your question sounds like:

“These features belong to the same category, and I no longer need the boundaries between them.”

Typical examples include:

districts grouped into regions;
parcels grouped by owner or land-use category;
overlapping buffers combined into a single coverage area;
detailed polygons reduced to one overall footprint;
features grouped by a shared classification before further analysis.

It is less appropriate when you merely want to place several datasets into one layer, preserve the subdivisions created by two overlapping layers, or calculate statistics without changing the geometry.

Those tasks point towards Merge, overlay operations, or aggregation instead.

Dissolve changes the unit of the dataset

The central idea behind Dissolve is not simply that some lines disappear.

Before the operation, one row may represent a district. Afterwards, one row may represent a region.

Before dissolving, a boundary separates two distinct features. Afterwards, that same boundary may no longer represent a distinction that exists in the output.

That is why Dissolve should be thought of as a change in feature structure and geographic meaning, not merely as a cartographic cleanup tool.

Before running it, identify the grouping rule, decide whether disconnected parts should remain one feature, and determine what should happen to attributes that described the original records.

If those decisions are clear, Dissolve becomes straightforward: features that should represent the same thing are grouped, and boundaries that no longer distinguish them are removed.

References

QGIS Documentation — Dissolve. Documents attribute-based and whole-layer Dissolve behaviour, removal of shared polygon boundaries, multipart outputs, treatment of disjoint features, and the current attribute-handling behaviour of QGIS's native Dissolve algorithm.
PostGIS — ST_Union. Defines geometric union as combining input geometries into a result without overlapping regions, supporting the geometric relationship between dissolving boundaries and unioning geometry while remaining distinct from an attribute-based GIS Dissolve workflow.