g.gui.gmodeler(1)

📦

version 8.4.2 · 10 versions

g.gui.gmodeler 💖

okay bestie, welcome to the GRASS GIS User's Manual page for g.gui.gmodeler(1) — yes that's the whole name, the manual name lives right there in the title, we're not repeating it again, we're moving ON ✨

✨ NAME ✨

g.gui.gmodeler — the Graphical Modeler. 💅

It lets you interactively create, edit and manage models. That's the whole vibe. 👑

🎀 KEYWORDS 🎀

general, GUI, graphical modeler, workflow

🦋 SYNOPSIS 🦋

g.gui.gmodeler
g.gui.gmodeler --help
g.gui.gmodeler  [file=name.gxm]   [--help]  [--verbose]  [--quiet]
[--ui]

🌸 Flags 🌸

--help — Print usage summary
--verbose — Verbose module output
--quiet — Quiet module output
--ui — Force launching GUI dialog

🌈 Parameters 🌈

file=name.gxm — Name of model file to be loaded

💜 DESCRIPTION 💜

The Graphical Modeler is a wxGUI component, and what it does is let you create, edit, and manage simple and complex models through an interface that's genuinely easy to use. 🫶

Here's the thing, bestie — when you're doing analytical operations in GRASS GIS, those operations are never just floating there alone. They're part of a chain of operations. And the Graphical Modeler lets you wrap a whole chain of processes (aka GRASS GIS modules) into one single process (aka a model). Which means later on, running that model again — even with slightly different inputs or parameters — is so much easier. Obsessed, honestly. 😭

Models represent a programming technique used in GRASS GIS to concatenate single steps together to accomplish a task. And it's advantageous when you can see boxes and ovals connected by lines that represent some tasks, rather than staring at lines of coded text. Main character energy for the boxes, fr fr. ✨

The Graphical Modeler can be used as a custom tool that automates a process. Created models can simplify or shorten a task which can be run many times, and it can also be easily shared with others. 🔥

Important to note, no cap: models cannot perform specified tasks that one cannot also manually perform with GRASS GIS. So like, it's not doing magic, it's doing automation. 💀

It is recommended to first develop the process manually, note down the steps (e.g. by using the Copy button in module dialogs) and later replicate them in model. Do the homework first, then slay. 📝

The Graphical Modeler allows you to:

define data items (raster, vector, 3D raster maps)
define actions (GRASS commands)
define relations between data and action items
define loops (e.g. map series) and conditions (if-else statements)
define model variables
parameterize GRASS commands
define intermediate data
validate and run model
save model properties to a file (GRASS Model File|*.gxm)
export model to Python script
export model to Python script in the form of a PyWPS process
export model to an actinia process
export model to image file

👑 Main dialog 👑

The Graphical Modeler can be launched from the Layer Manager menu File -> Graphical modeler or from the main toolbar. It's also available as a stand-alone module g.gui.gmodeler. 🌟

The main Graphical Modeler menu contains options which enable the user to fully control the model. Directly under the main menu one can find a toolbar with buttons (see figure below). There are options including:

Create new model
Load model from file
Save current model to file
Export model to image
Export model to a (Python/PyWPS/actinia) script
Add command (GRASS module) to model
Add data to model
Manually define relation between data and commands
Add loop/series to model
Add comment to model
Redraw model canvas
Validate model
Run model
Manage model variables
Model settings
Show manual
Quit Graphical Modeler

Figure: Components of Graphical Modeler menu toolbar.

There is also a lower menu bar in the Graphical modeler dialog where one can manage model items, visualize commands, add or manage model variables, define default values and descriptions. The Script editor dialog window allows seeing and exporting workflows as basic Python scripts, as PyWPS scripts, or as actinia processes. The rightmost tab of the bottom menu is automatically triggered when the model is activated and shows all the steps of running GRASS modeler modules; in the case some errors occur in the calculation process, they are are written at that place. 🙈

Figure: Lower Graphical Modeler menu toolbar.

🧚 Components of models 🧚

The workflow is usually established from four types of diagrams. Input and derived model data are usually represented with oval diagrams. This type of model elements stores path to specific data on the user's disk. It is possible to insert vector data, raster data, database tables, etc. The type of data is clearly distinguishable in the model by its color. Different model elements are shown in the figures below. 🌈

(A) raster data:
(B) relation:
(C) GRASS module:
(D) loop:
(E) database table:
(F) 3D raster data:
(G) vector data:
(H) disabled GRASS module:
(I) comment:

Figure: A model to perform unsupervised classification using MLC (i.maxlik) and SMAP (i.smap).

Another example:

Figure: A model to perform estimation of average annual soil loss caused by sheet and rill erosion using The Universal Soil Loss Equation.

Example as part of landslide prediction process:

Figure: A model to create parametric maps used by geologists to predict landslides in the area of interest.

💖 EXAMPLE 💖

Bestie, let's actually do the thing. In this example we're using the zipcodes_wake vector data and the elev_state_500m raster data from the North Carolina sample dataset (original raster and vector data) to calculate the average elevation for every single zone. And the star of the show here? The Graphical Modeler, specifically its whole thing about process automation. It's giving efficiency. It's giving slay. ✨

🎀 The workflow shown as a series of commands 🎀

Okay so in the command console the procedure looks like this, no cap:

# input data import
r.import input=elev_state_500m.tif output=elevation
v.import input=zipcodes_wake.shp output=zipcodes_wake
# computation region settings
g.region vector=zipcodes_wake
# raster statistics (average values), upload to vector map table calculation
v.rast.stats -c map=zipcodes_wake raster=elevation column_prefix=rst method=average
# univariate statistics on selected table column for zipcode map calculation
v.db.univar map=zipcodes_wake column=rst_average
# conversion from vector to raster layer (due to result presentation)
v.to.rast input=zipcodes_wake output=zipcodes_avg use=attr attribute_column=rst_average
# display settings
r.colors -e map=zipcodes_avg color=bgyr
d.mon start=wx0 bgcolor=white
d.barscale style=arrow_ends color=black bgcolor=white fontsize=10
d.rast map=zipcodes_avg bgcolor=white
d.vect map=zipcodes_wake type=boundary color=black
d.northarrow style=1a at=85.0,15.0 color=black fill_color=black width=0 fontsize=10
d.legend raster=zipcodes_avg lines=50 thin=5 labelnum=5 color=black fontsize=10

Like. Look at all that. Iconic behaviour, honestly. 💅

🦋 Defining the workflow in the Graphical Modeler 🦋

To start performing all those steps above as an automatic process with the Graphical Modeler, you press the icon or you type g.gui.gmodeler. That's it. That's the vibe check. The simplest way of inserting elements is by adding the complete GRASS command to the Command field in the GRASS command dialog (see figure below). With full text search one can do faster module hunting, which is lowkey a game changer. Next, the label and the command can be added. And in case that only a module name is inserted, after pressing the Enter button, the module dialog window is displayed and it is possible to set all of the usual module options (parameters and flags). Chef's kiss. 👑

Figure: Dialog for adding GRASS commands to model.

🌸 Managing model parameters 🌸

All used modules can be parameterized in the model. That causes launching the dialog with input options for model after the model is run. In this example, input layers (zipcodes_wake vector map and elev_state_500m raster map) are parameterized. And here's the little detail you need to know: parameterized elements show their diagram border slightly thicker than those of unparameterized elements. So thick. So main character. ✨

Figure: Model parameter settings.

The final model, the list of all model items, and the Script editor window with Save and Run option are shown in the figures below.

Figure: A model to perform average statistics for zipcode zones.

Figure: Items with Script editor window.

For convenience, this model for the Graphical Modeler is also available for download here. Bestie, they gave us the files. So generous.

The model is run by clicking the Run button. When all inputs are set, the results can be displayed as shown in the next Figure:

Figure: Average elevation for ZIP codes using North Carolina sample dataset as an automatic calculation performed by Graphical Modeler.

🫶 Managing model properties 🫶

When the user wants to run the model again with the same data or the same names, it is necessary to use --overwrite option. It will cause maps with identical names to be overwritten. (Yes, that means exactly what it sounds like — it will steamroll right over the maps that already exist with those names. Be aware, bestie. 🙈) Instead of setting it for every module separately it is handy to change the Model Property settings globally. This dialog includes also metadata settings, where model name, model description and author(s) of the model can be specified. Cute and organised.

Figure: Model properties.

💜 Defining variables 💜

Another useful trick is the possibility to set variables. Their content can be used as a substitute for other items. Value of variables can be values such as raster or vector data, integer, float, string value or they may constitute some region, mapset, file or direction data type. Then it is not necessary to set any parameters for input data. The dialog with variable settings is automatically displayed after the model is run. So, instead of model parameters (e.g. r.import a v.import, see the Figure Run model dialog above) there are Variables.

Figure: Model with variable inputs.

The key point is the usage of % before the substituting variable and settings in the Variables dialog. For example, in the case of a model variable raster that points to an input file path and which value is required to be used as one of inputs for a particular model, it should be specified in the Variables dialog with its respective name (raster), data type, default value and description. Then it should be set in the module dialog as input called %raster. That's the whole ritual. The % is doing all the heavy lifting and honestly? We stan a single character carrying an entire workflow. 🔥

Figure: Example of raster file variable settings.

Figure: Example of raster file variable usage.

🌈 Saving the model file 🌈

Finally, the model settings can be stored as a GRASS GIS Model file with *.gxm extension. The advantage is that it can be shared as a reusable workflow that may be run also by other users with different data. Reusable. Shareable. Generous. We love to see it.

For example, this model can later be used to calculate the average precipitation for every administrative region in Slovakia using the precip raster data from Slovakia precipitation dataset and administration boundaries of Slovakia from Slovak Geoportal (only with a few clicks). A few clicks!! The way that this scales is genuinely so satisfying, iykyk. 💅

🍓 Handling intermediate data 🍓

There can be some data in a model that did not exist before the process and that it is not worth it to maintain after the process executes. They can be described as being Intermediate by single clicking using the right mouse button, see figure below. All such data should be deleted following model completion. The boundary of intermediate component is dotted line.

Heads up bestie: all such data should be deleted following model completion. Don't let that intermediate data linger, it's giving clutter. 💀

Figure: Usage and definition of intermediate data in model.

🧚 Using the Script editor 🧚

By using the Script editor in the Graphical Modeler, the user can add Python code and then run it with Run button or just save it as a Python script *.py. The result is shown in the Figure below:

Figure: Script editor in the wxGUI Graphical Modeler.

The second option in the Script type combobox exports a PyWPS script instead of a basic Python one. A PyWPS process based on the model will be generated then; for the PyWPS script, the Run button is disabled as users are expected to include this script in their web processing service and not to run it on itself. So no pressing Run, it's simply not that kind of script. 🙅

Figure: Script editor in the wxGUI Graphical Modeler - set to PyWPS.

The third option in the Script type combobox exports an actinia process chain (non-parameterized model) or an actinia template (parameterized model). An actinia JSON based on the model will be generated then; as for the PyWPS script, the Run button is disabled as users are expected to include this JSON in their web processing service and not to run it on itself.

Figure: Script editor in the wxGUI Graphical Modeler - set to actinia.

By default GRASS script package API is used (grass.script.core.run_command()). This can be changed in the settings. Alternatively also PyGRASS API is supported (grass.pygrass.modules.Module). Options upon options, the range is real. ✨

⭐ Defining loops ⭐

In the example below the MODIS MOD13Q1 (NDVI) satellite data products are used in a loop. The original data are stored as coded integer values that need to be multiplied by the value 0.0001 to represent real ndvi values. Moreover, GRASS GIS provides a predefined color table called ndvi to represent ndvi data. In this case it is not necessary to work with every image separately. Loops really said "I'll handle that" and honestly? Queen behaviour. 👑

The Graphical Modeler is an appropriate tool to process data in an effective way using loop and variables (%map for a particular MODIS image in mapset and %ndvi for original data name suffix). After the loop component is added to model, it is necessary to define series of maps with required settings of map type, mapset, etc.

Figure: MODIS data representation in GRASS GIS after Graphical Modeler usage.

When the model is supplemented by all of modules, these modules should be ticked in the boxes of loop dialog. The final model and its results are shown below.

Figure: Model with loop.

Figure: MODIS data representation in GRASS GIS after Graphical Modeler usage.

The steps to enter in the command console of the Graphical Modeler would be as follows:

# note that the white space usage differs from the standard command line usage
# rename original image with preselected suffix
g.rename raster = %map,%map.%ndvi
# convert integer values
r.mapcalc expression = %map = %map.%ndvi * 0.0001
# set color table appropriate for nvdi data
r.colors = map = %map color = ndvi

Note that the white space usage differs from the standard command line usage — yes, the spaces around the = are part of the whole thing here. Don't "fix" them, bestie, they're intentional. 💀

💫 SEE ALSO 💫

wxGUI, wxGUI components
See also selected user models available from GRASS Addons repository.
See also the wiki page (especially various video tutorials).

Like, the wiki page has video tutorials. Actual videos. Go watch them, they're so helpful. 🎀

👑 AUTHORS 👑

Martin Landa, GeoForAll Lab, Czech Technical University in Prague, Czech Republic
PyWPS support by Ondrej Pesek, GeoForAll Lab, Czech Technical University in Prague, Czech Republic
Various manual improvements by Ludmila Furkevicova, Slovak University of Technology in Bratislava, Slovak Republic

Genuine icons, all of them. Thank you for your service. 🫶

💻 SOURCE CODE 💻

Available at: wxGUI Graphical Modeler source code (history)

Accessed: Saturday Jan 17 05:42:35 2026

And that's a wrap, bestie! 🌈 This whole thing lives in the GRASS GIS 8.4.2 Reference Manual, © 2003-2025 GRASS Development Team, and it's g.gui.gmodeler(1) from GRASS 8.4.2. Go build something iconic with it, okay? Periodt. 💖✨

📦 where this page comes from

fedora 44: grass 8.4.2-4.fc44 · GPL-2.0-or-later
💖 girlified by deepseek-ai/DeepSeek-V4.1-Flash on 2026-10-13: a language model's rewrite of the original, under its terms