What you are looking at is the QGIS Expression language. For a geospatial audience, the most useful way to understand it is as a lightweight, map-aware scripting language embedded directly inside QGIS. It allows you to generate geometry, symbols, styles, labels, and derived attributes dynamically, using both feature attributes and spatial properties such as geometry, slope, or aspect.

Conceptually, it sits between classical cartographic rules and full programming. It is more expressive than styling sliders or rule-based symbology, but far simpler than writing a Python plugin. Most importantly, expressions operate at render time. Geometry and appearance do not need to be stored permanently in the dataset; they are generated on the fly from rules you define.

This opens the door to procedural cartography: maps that are defined by behaviour rather than by fixed shapes.

Hachures as a First Example: Geometry Generated from Terrain

The QGIS Hachure Map Generator plugin is a good illustration of this idea. Instead of merely symbolizing existing features, it uses expressions to generate new geometry at draw time. Hachures are short line segments whose length, spacing, and orientation encode terrain properties such as slope and aspect. In classical cartography this was a manual process. In QGIS, it becomes algorithmic.

A simplified version of a hachure-generating expression looks like this:

make_line(
    $geometry,
    project(
        $geometry,
        15 + 100 * “slope_1” / 90,
        radians((“aspect_1” – 90) + rand(0, 8))
    )
)

Here, make_line() constructs a line from two points. The first point is the feature’s geometry, often a point derived from a raster cell or centroid. The second point is computed using project(), which shifts the geometry by a given distance and direction.

The distance depends on the slope. Steeper slopes produce longer hachures. The direction is derived from aspect, rotated so the line points downslope, with a small random perturbation added via rand() to avoid visual regularity. The result is a field of lines that encodes terrain morphology rather than just elevation.

Visual emphasis can be further modulated by scaling opacity or width based on aspect orientation:

1 – abs(“aspect_1” – 180) / 180

This expression returns values close to 1 for south-facing slopes and closer to 0 for north-facing ones, allowing selective emphasis through line width or opacity. The key point is that geometry and styling are driven by physical terrain properties, not static design choices.

Flow and Movement Mapping

Flow maps are a natural application of expression-driven geometry in QGIS. When you have origin–destination lines or point features with attributes for direction and magnitude, you can create symbols that vary in width, color, and orientation based on your data.

Dataset source: HydroATLAS, HydroSHEDS – provides river networks and discharge values used for flow visualization.

• Line width by flow magnitude: 

scale_linear(
    “DIS_AV_CMS”,
    min_flow,
    max_flow,
    min_width,
    max_width
)

This scales the line thickness according to the discharge (DIS_AV_CMS) value, making larger flows visually more prominent.

• Line color based on magnitude:
  You can apply a gradient from light to dark using your chosen palette:

with_variable(
    ‘val’,
    “DIS_AV_CMS”,
    color_rgb(
        scale_linear(@val, 0, 500, 240, 39),   — Red channel
        scale_linear(@val, 0, 500, 238, 87),   — Green channel
        scale_linear(@val, 0, 500, 255, 245)   — Blue channel
    )
)

This maps low flow to light blue and high flow to dark blue, producing a continuous, data-driven color gradient.

Wind and Current Visualization

Point-based vector fields, such as wind or ocean currents, can be effectively visualized by converting points into oriented arrows. Each arrow’s geometry can respond dynamically to the speed and direction values from the dataset, providing an intuitive representation of flow patterns. Using ERA data, the arrow length is scaled by the wind or current speed, and the orientation is derived from the direction field.

Here’s an example QGIS Geometry Generator expression for creating arrows from ERA dataset:

— Main vector line
with_variable(
    ‘main’,
    make_line(
        $geometry,
        project(
            $geometry,
            0.05 * “speed”,              — scales arrow length by speed
            “direction” * pi()/180       — converts degrees to radians
        )
    ),
 
    — Arrowhead at the tip
    collect_geometries(
        @main,
        make_line(
            end_point(@main),
            project(
                end_point(@main),
                0.01,                        — short length for narrow tip
                “direction” * pi()/180 + pi()/12   — left wing
            )
        ),
        make_line(
            end_point(@main),
            project(
                end_point(@main),
                0.01,
                “direction” * pi()/180 – pi()/12   — right wing
            )
        )
    )
)

Procedural Cartography Inside QGIS

Taken together, these examples point to a broader practice that is emerging inside QGIS: procedural cartography. Expressions are used to generate dot densities, sketch-style strokes, irregular buffers, noise-based textures, and data-driven ornamentation. The ideas borrow from computer graphics and scientific visualization, but remain accessible to everyday GIS users.

No external scripting environment is required. Everything happens inside the styling and geometry tools that users already know.

The key idea for a geospatial audience is that the QGIS Expression language turns GIS layers into parametric objects. Geometry is no longer a fixed result stored on disk. Instead, you describe how geometry should behave in response to data. The underlying capability, however, is already available to any QGIS user willing to think a bit more like a cartographer and a bit more like a programmer.

Did you like this post? Follow us on our social media channels!

Read more and subscribe to our monthly newsletter!