Repository: OSGeo/grass
Pull request #5207: docs: MkDocs index and nav redesign
Author: login: cwhite911
Labels: name: Python
description: Related code is in Python
name: CSS
description: Related code is in CSS
name: docs
name: markdown
description: Related to markdown, markdown files
Created: 2025-02-25T17:53:19Z | Merged: 2025-03-07T20:47:45Z

- Completely redesign index page to be Getting started page with overview and just couple links elsewhere.
- Add intro pages for interfaces (for now, getting started with interface and overview of interface are the same pages).
- Change navigation to highlight interfaces, concepts, and tools.

This is a first draft, and several issues should be addressed later. Besides the content, links to addons and libpython need a revision.

Related to issue #5162. (Originally raised as index page redesign, but index page does not have to make up for a menu anymore because we do have a menu with MkDocs.)

![image](https://github.com/user-attachments/assets/6d790c85-ac15-44dc-aa09-7505345b0a0d)



Diff:
diff --git a/man/Makefile b/man/Makefile
index d8cb1d84dde..4bbe145b49a 100644
--- a/man/Makefile
+++ b/man/Makefile
@@ -19,9 +19,15 @@ DSTFILES := \
 	$(MDDIR)/source/favicon.ico \
 	$(MDDIR)/source/grassdocs.css \
 	$(MDDIR)/scripts/hook_list_scripts.py \
+	$(MDDIR)/source/index.md \
 	$(MDDIR)/overrides/partials/footer.html \
 	$(MDDIR)/overrides/partials/actions.html \
-	$(MDDIR)/source/tags.md
+	$(MDDIR)/source/tags.md \
+	$(MDDIR)/source/development_intro.md \
+	$(MDDIR)/source/interfaces_overview.md \
+	$(MDDIR)/source/jupyter_intro.md \
+	$(MDDIR)/source/python_intro.md \
+	$(MDDIR)/source/command_line_intro.md
 
 categories = \
 	d:display \
@@ -159,10 +165,6 @@ $(HTMLDIR)/index.html: build_index.py build_html.py
 	$(call build,index)
 	touch $@
 
-$(MDDIR)/source/index.md: build_index.py build_md.py
-	$(call build,index)
-	touch $@
-
 $(HTMLDIR)/keywords.html: $(ALL_HTML)
 	$(call build_keywords)
 	touch $@
@@ -247,6 +249,9 @@ $(HTMLDIR)/parser_standard_options.css: parser_standard_options.css
 $(MDDIR)/mkdocs.yml: mkdocs/mkdocs.yml
 	$(INSTALL_DATA) $< $@
 
+$(MDDIR)/source/index.md: mkdocs/index.md
+	$(INSTALL_DATA) $< $@
+
 $(MDDIR)/source/grass_logo.svg: grass_logo.svg
 	$(INSTALL_DATA) $< $@
 
@@ -262,6 +267,21 @@ $(MDDIR)/source/grassdocs.css: mkdocs/grassdocs.css
 $(MDDIR)/source/tags.md: mkdocs/tags.md
 	$(INSTALL_DATA) $< $@
 
+$(MDDIR)/source/development_intro.md: mkdocs/docs/development_intro.md
+	$(INSTALL_DATA) $< $@
+
+$(MDDIR)/source/jupyter_intro.md: mkdocs/docs/jupyter_intro.md
+	$(INSTALL_DATA) $< $@
+
+$(MDDIR)/source/python_intro.md: mkdocs/docs/python_intro.md
+	$(INSTALL_DATA) $< $@
+
+$(MDDIR)/source/command_line_intro.md: mkdocs/docs/command_line_intro.md
+	$(INSTALL_DATA) $< $@
+
+$(MDDIR)/source/interfaces_overview.md: mkdocs/docs/interfaces_overview.md
+	$(INSTALL_DATA) $< $@
+
 $(MDDIR)/scripts/hook_list_scripts.py: mkdocs/scripts/hook_list_scripts.py | $(MDDIR)/scripts
 	$(INSTALL_DATA) $< $@
 
diff --git a/man/build.py b/man/build.py
index 4d5609c6c15..6cc6d798876 100644
--- a/man/build.py
+++ b/man/build.py
@@ -109,16 +109,15 @@ def write_header(f, title, ismain=False, body_width="99%", template="html"):
 
 
 def write_cmd_overview(f, template="html"):
+    from build_html import overview_tmpl
+
     if template == "html":
-        from build_html import overview_tmpl
-    else:
-        from build_md import overview_tmpl
-    f.write(
-        overview_tmpl.substitute(
-            grass_version_major=grass_version_major,
-            grass_version_minor=grass_version_minor,
+        f.write(
+            overview_tmpl.substitute(
+                grass_version_major=grass_version_major,
+                grass_version_minor=grass_version_minor,
+            )
         )
-    )
 
 
 def write_footer(f, index_url, year=None, template="html"):
diff --git a/man/build_index.py b/man/build_index.py
index b51c0807275..48015bfec9d 100644
--- a/man/build_index.py
+++ b/man/build_index.py
@@ -45,5 +45,3 @@ def build_index(ext):
 
 if __name__ == "__main__":
     build_index("html")
-
-    build_index("md")
diff --git a/man/build_md.py b/man/build_md.py
index 81ed2ca677f..6e069b38645 100644
--- a/man/build_md.py
+++ b/man/build_md.py
@@ -39,128 +39,6 @@
 """
 )
 
-# TODO: avoid HTML tags
-overview_tmpl = string.Template(
-    r"""<!-- the files grass${grass_version_major}.html & helptext.html file live in lib/init/ -->
-
-<table align="center" border="0" cellspacing="8">
-  <tbody>
-    <tr>
-      <td width="33%" valign="top" class="box"><h3>&nbsp;Quick Introduction</h3>
-      <ul>
-       <li class="box"><a href="helptext.html">How to start with GRASS GIS</a></li>
-       <li class="box"><span>Index of <a href="topics.html">topics</a> and <a href="keywords.html">keywords</a></span></li>
-      </ul>
-      <p>
-      <ul>
-       <li class="box"><a href="projectionintro.html">Intro: projections and spatial transformations</a></li>
-      </ul>
-      <p>
-      <ul>
-       <li class="box"><span><a href="https://grasswiki.osgeo.org/wiki/Faq">FAQ - Frequently Asked Questions</a> (Wiki)</span></li>
-      </ul>
-      <p>
-      <ul>
-       <li class="box"><span><a href="graphical_index.html">Graphical index of functionality</a></span></li>
-      </ul>
-      </td>
-      <td width="33%" valign="top" class="box"><h3>&nbsp;Graphical User Interface</h3>
-       <ul>
-        <li class="box"><a href="wxguiintro.html">Intro: Graphical User Interface</a></li>
-        <li class="box"><span><a href="wxGUI.html">wxGUI</a></span></li>
-        <li class="box"><a href="wxGUI.components.html">wxGUI components</a></li>
-        <li class="box"><a href="wxGUI.toolboxes.html">wxGUI toolboxes</a></li>
-       </ul>
-
-       <ul>
-        <li class="box"><a href="topic_GUI.html">GUI commands</a></li>
-       </ul>
-       <h3>&nbsp;Display</h3>
-       <ul>
-        <li class="box"><a href="display.html">Display commands manual</a></li>
-        <li class="box"><a href="displaydrivers.html">Display drivers</a></li>
-       </ul>
-      </td>
-      <td width="33%" valign="top" class="box"><h3>&nbsp;General</h3>
-       <ul>
-        <li class="box"><a href="grass.html">GRASS GIS startup manual</a></li>
-        <li class="box"><a href="general.html">General commands manual</a></li>
-       </ul>
-        <h3>&nbsp;Addons</h3>
-        <ul>
-        <li class="box"><a href="https://grass.osgeo.org/grass8/manuals/addons/">Addons manual pages</a></li>
-       </ul>
-        <h3>&nbsp;Programmer's Manual</h3>
-        <ul>
-        <li class="box"><a href="https://grass.osgeo.org/programming8/">Programmer's Manual</a></li>
-       </ul>
-      </td>
-    </tr>
-    <tr>
-      <td width="33%" valign="top" class="box"><h3>&nbsp;Raster processing</h3>
-       <ul>
-        <li class="box"><a href="rasterintro.html">Intro: 2D raster map processing</a></li>
-        <li class="box"><a href="raster.html">Raster commands manual</a></li>
-       </ul>
-      </td>
-      <td width="33%" valign="top" class="box"><h3>&nbsp;3D raster processing</h3>
-       <ul>
-        <li class="box"><a href="raster3dintro.html">Intro: 3D raster map (voxel) processing</a></li>
-        <li class="box"><a href="raster3d.html">3D raster (voxel) commands manual</a></li>
-      </ul></td>
-      <td width="33%" valign="top" class="box"><h3>&nbsp;Image processing</h3>
-       <ul>
-        <li class="box"><a href="imageryintro.html">Intro: image processing</a></li>
-        <li class="box"><a href="imagery.html">Imagery commands manual</a></li>
-      </ul></td>
-    </tr>
-    <tr>
-      <td width="33%" valign="top" class="box"><h3>&nbsp;Vector processing</h3>
-       <ul>
-        <li class="box"><a href="vectorintro.html">Intro: vector map processing and network analysis</a></li>
-        <li class="box"><a href="vector.html">Vector commands manual</a></li>
-        <li class="box"><a href="vectorascii.html">GRASS ASCII vector format specification</a></li>
-      </ul></td>
-      <td width="33%" valign="top" class="box"><h3>&nbsp;Database</h3>
-       <ul>
-        <li class="box"><a href="databaseintro.html">Intro: database management</a></li>
-        <li class="box"><a href="sql.html">SQL support in GRASS GIS</a></li>
-        <li class="box"><a href="database.html">Database commands manual</a></li>
-       </ul>
-      </td>
-      <td width="33%" valign="top" class="box"><h3>&nbsp;Temporal processing</h3>
-       <ul>
-        <li class="box"><a href="temporalintro.html">Intro: temporal data processing</a></li>
-        <li class="box"><a href="temporal.html">Temporal commands manual</a></li>
-       </ul>
-      </td>
-    </tr>
-    <tr>
-      <td width="33%" valign="top" class="box"><h3>&nbsp;Cartography</h3>
-       <ul>
-        <li class="box"><a href="postscript.html">PostScript commands manual</a></li>
-        <li class="box"><a href="g.gui.psmap.html">wxGUI Cartographic Composer</a></li>
-       </ul>
-      </td>
-      <td width="33%" valign="top" class="box"><h3>&nbsp;Miscellaneous&nbsp;&amp;&nbsp;Variables</h3>
-       <ul>
-        <li class="box"><a href="miscellaneous.html">Miscellaneous commands manual</a></li>
-        <li class="box"><a href="variables.html">GRASS variables and environment variables</a></li>
-       </ul>
-      </td>
-      <td width="33%" valign="top" class="box"><h3>&nbsp;Python</h3>
-       <ul>
-        <li class="box"><a href="https://grass.osgeo.org/grass${grass_version_major}${grass_version_minor}/manuals/libpython/index.html">GRASS GIS Python library documentation</a></li>
-        <li class="box"><a href="https://grass.osgeo.org/grass${grass_version_major}${grass_version_minor}/manuals/libpython/pygrass_index.html">PyGRASS documentation</a></li>
-        <li class="box"><a href="https://grass.osgeo.org/grass${grass_version_major}${grass_version_minor}/manuals/libpython/grass.jupyter.html">GRASS GIS in Jupyter Notebooks</a></li>
-       </ul>
-      </td>
-    </tr>
-  </tbody>
-</table>
-"""
-)
-
 # footer_tmpl = string.Template(
 #     r"""
 # ____
diff --git a/man/mkdocs/docs/command_line_intro.md b/man/mkdocs/docs/command_line_intro.md
new file mode 100644
index 00000000000..b2b10724d36
--- /dev/null
+++ b/man/mkdocs/docs/command_line_intro.md
@@ -0,0 +1,131 @@
+---
+authors:
+    - Corey T. White
+    - GRASS Development Team
+---
+
+# Command Line Introduction
+
+## Interactive Shell
+
+```text
+Starting GRASS...
+          __________  ___   __________
+         / ____/ __ \/   | / ___/ ___/
+        / / __/ /_/ / /| | \__ \\_  \
+       / /_/ / _, _/ ___ |___/ /__/ /
+       \____/_/ |_/_/  |_/____/____/
+
+```
+
+The GRASS command line interface allows you to start a GRASS session to
+run GRASS commands, execute scripts, or open the GUI.
+
+Here we create a new project for the NAD83(HARN)/North Carolina coordinate
+reference system (EPSG:3358) and start a GRASS session:
+
+```sh
+grass -c EPSG:3358 {project directory} --text
+```
+
+We can now execute GRASS tools as commands in a new shell. For example, we can
+import an elevation raster and calculate its
+[univariate statistics](r.univar.md).
+
+```sh
+r.import input=elevation.tif output=elevation resample=bilinear
+```
+
+Let's make sure the region is set to the elevation raster.
+
+```sh
+g.region raster=elevation -p
+
+projection: 99 (Lambert Conformal Conic)
+zone:       0
+datum:      nad83
+ellipsoid:  a=6378137 es=0.006694380022900787
+north:      228500
+south:      215000
+west:       630000
+east:       645000
+nsres:      10
+ewres:      10
+rows:       1350
+cols:       1500
+cells:      2025000
+
+```
+
+Now we can calculate the univariate statistics of the elevation raster.
+
+```sh
+r.univar elevation
+
+total null and non-null cells: 2025000
+total null cells: 0
+
+Of the non-null cells:
+----------------------
+n: 2025000
+minimum: 55.5788
+maximum: 156.33
+range: 100.751
+mean: 110.375
+mean of absolute values: 110.375
+standard deviation: 20.3153
+variance: 412.712
+variation coefficient: 18.4057 %
+sum: 223510266.558102
+
+```
+
+## Command Execution
+
+GRASS commands can be executed directly in the terminal. Here we execute the
+[r.slope.aspect](r.slope.aspect.md) tool on an elevation raster from our
+project.
+
+```sh
+grass {project directory} --exec \
+    r.slope.aspect elevation=elevation slope=slope aspect=aspect
+```
+
+## Scripting
+
+The *grass* command can also execute scripts. Here we create a Bash script,
+`export_slope.sh`,  to export the slope map as a PNG.
+
+```bash
+#!/bin/bash
+g.region raster=elevation
+r.slope.aspect elevation=elevation slope=slope aspect=aspect
+r.colors map=slope color=sepia
+r.out.png input=slope output=slope -w
+```
+
+```sh
+grass {project directory} --exec bash export_slope.sh
+```
+
+Python scripts can also be executed by the *grass* command when a Python
+interpreter is provided. Here we create a Python script, `export_aspect.py`,
+to export the aspect map as a PNG.
+
+```python
+import grass.script as gs
+
+gs.run_command('g.region', raster='elevation')
+gs.run_command('r.slope.aspect', elevation='elevation', slope='slope', aspect='aspect')
+gs.run_command('r.colors', map='aspect', color='aspect')
+gs.run_command('r.out.png', input='aspect', output='aspect', overwrite=True)
+```
+
+Now execute the Python script.
+
+```sh
+grass {project directory} --exec python export_aspect.py
+```
+
+Scripts can also run from the interactive shell providing adding to
+the flexibility of the command line interface.
diff --git a/man/mkdocs/docs/development_intro.md b/man/mkdocs/docs/development_intro.md
new file mode 100644
index 00000000000..569bc27a29a
--- /dev/null
+++ b/man/mkdocs/docs/development_intro.md
@@ -0,0 +1,28 @@
+---
+authors:
+    - Corey T. White
+    - GRASS Development Team
+title: Development Introduction
+---
+
+## C
+
+- C: [Developers Manual](https://grass.osgeo.org/programming8/)
+
+## Python
+
+- Python: [Python Library](https://grass.osgeo.org/grass-stable/manuals/libpython/index.html)
+
+## Testing
+
+- Testing: [Testing](https://grass.osgeo.org/grass-stable/manuals/libpython/gunittest_testing.html)
+
+## Addons
+
+In addition to the core tools, GRASS also provides a number of addons that
+extend the functionality of GRASS. Addons are part of the [OSGeo/grass-addons](https://github.com/OSGeo/grass-addons)
+repository and are a great place to plubish and share custom tools, models, and reserach.
+The addons are maintained by the GRASS community and are a great way to extend the
+functionality of GRASS.
+
+- Addons: [Addons](https://grass.osgeo.org/grass-stable/manuals/addons/)
diff --git a/man/mkdocs/docs/interfaces_overview.md b/man/mkdocs/docs/interfaces_overview.md
new file mode 100644
index 00000000000..783ce12f697
--- /dev/null
+++ b/man/mkdocs/docs/interfaces_overview.md
@@ -0,0 +1,110 @@
+---
+authors:
+    - Corey T. White
+    - GRASS Development Team
+---
+
+# Interfaces
+
+GRASS provides a number of interfaces for interacting with the software.
+The most common interfaces are command line, Python, Jupyter Notebooks,
+and graphical user interface.
+
+## Command Line
+
+The command line, also know as terminal or shell, interface allows you to start
+a GRASS session to run GRASS commands, execute scripts, or open the graphical
+user interface.
+
+Here we create a new project for the NAD83(HARN)/North Carolina coordinate
+reference system (EPSG:3358) and start a GRASS session as a new shell in
+your terminal:
+
+```sh
+grass -c EPSG:3358 {project directory} --text
+```
+
+The shell can now execute GRASS commands.
+
+```sh
+g.region raster=elevation
+r.slope.aspect elevation=elevation slope=slope aspect=aspect
+```
+
+To learn more about the command line interface, see the
+[Command Line Interface](command_line_intro.md) page.
+
+## Python
+
+The `grass.script` module provides a Python interface to GRASS. This allows
+users to write Python scripts to interact with GRASS. The `grass.script` module
+contains the `gs.script.core` module which provides the core functionality for the
+GRASS Python interface, the `grass.script.raster` module which provides
+functionality for working with raster data, and the `grass.script.vector` module
+which provides functionality for working with vector data.
+
+To get started Python, create a new project with `gs.create_project` and start a
+GRASS session with the `grass.script.setup.init` function to initialize the
+GRASS environment.
+
+```python
+import sys
+import subprocess
+from pathlib import Path
+
+# Append GRASS to the python system path
+sys.path.append(
+    subprocess.check_output(["grass", "--config", "python_path"], text=True).strip()
+)
+
+import grass.script as gs
+
+# Create a new project
+gs.create_project(path=grassdata, name=project_name, epsg="3358", overwrite=False)
+
+# Initialize the GRASS session
+with gs.setup.init(Path("grassdata/project_name")) as session:
+
+    # Run GRASS commands
+    gs.run_command('g.region', raster='elevation')
+    gs.run_command('r.slope.aspect', elevation='elevation', slope='slope', aspect='aspect')
+```
+
+To learn more about the GRASS Python Scripting library, see the
+[grass.script package](python_intro.md) page.
+
+## Jupyter Notebooks
+
+Jupyter Notebooks are a great way to interact with GRASS. The `grass.jupyter`
+module provides a Jupyter interface to GRASS. This allows users to write Jupyter
+Notebooks to interact with GRASS. The `grass.jupyter` module contains the `Map`,
+`InteractiveMap`, `Map3D`, `TimeSeriesMap`, and `SeriesMap` classes which
+provide functionality for working with maps in Jupyter Notebooks.
+
+```python
+from pathlib import Path
+import grass.jupyter as gj
+
+session = gj.init(Path(grassdata, project_name))
+
+slope_map = gj.Map()  # Create a new map
+slope_map.d_rast(map='slope')  # Add the slope raster to the map
+slope_map.d_barscale(at=(80, 10))  # Add a bar scale to the map
+slope_map.d_legend(raster='slope', at=(80, 90))  # Add a legend to the map
+slope_map.show()  # Display the map
+```
+
+![Slope Map](r_slope_aspect_slope.png)
+
+Learn more about the GRASS Jupyter interface on the
+[Jupyter Notebooks](jupyter_intro.md) page.
+
+## Desktop Graphical User Interface
+
+The GRASS Desktop GUI is a graphical user interface for GRASS. The GUI provides
+a visual interface for interacting with GRASS. The GUI provides a number of tools
+for interactive data processing, analysis, and visualization. The GUI is
+avaliable on Windows, macOS, and Linux.
+
+Learn more about the GRASS Desktop GUI on the
+[Desktop GUI](wxguiintro.md) page.
diff --git a/man/mkdocs/docs/jupyter_intro.md b/man/mkdocs/docs/jupyter_intro.md
new file mode 100644
index 00000000000..64b807e79c0
--- /dev/null
+++ b/man/mkdocs/docs/jupyter_intro.md
@@ -0,0 +1,268 @@
+---
+authors:
+    - Corey T. White
+    - GRASS Development Team
+---
+
+# Jupyter Notebooks
+
+The `grass.jupyter` Python package provides a [Jupyter](https://jupyter.org/)
+notebook interface to GRASS. The package contains modules for creating map figures,
+interactive web maps, visualize series and time series datasets, and 3D visualizations.
+
+To get started with `grass.jupyter`, import the package:
+
+```python
+import grass.jupyter as gj
+```
+
+This will give you access to all of the modules and classes in the `grass.jupyter`.
+From here, you can create a GRASS session with the `gj.init` function:
+
+```python
+# Start a GRASS session
+session = gj.init("project_directory")
+```
+
+The `gj.init` function will create a new GRASS session for the specified project
+and mapset. If you need to switch to a different mapset, you can use the `gj.switch_mapset`
+function:
+
+```python
+session.switch_mapset("mapset_name")
+```
+
+## Map
+
+The `gj.Map` class in `grass.jupyter` provides a way to create static maps in Jupyter.
+Here we create a map of the elevation raster and save it to a file:
+
+```python
+# Create a new map, set the dimensions, and save the map to a file
+m = gj.Map()
+
+# Add a raster map to the map object
+m.d_rast(map="elevation")
+
+# Add a vector map to the map object
+m.d_vect(map="roadsmajor", color="black")
+
+# Display the map
+m.show()
+```
+
+!!! grass-tip "Reserved Keywords"
+    Avoid using the reserved keyword `map` as a variable name in Python.  
+    :x: `map = gj.Map()`  
+    :white_check_mark: `m = gj.Map()`
+
+In addition to displaying raster and vector maps, the `gj.Map` can access many
+of the [display tool](display.md) in GRASS. For a complete list of cartographic features
+you can refer to the [Cartography](topic_cartography.md) topic page.
+
+For example, let's add a legend, barscale, and shaded relief to the map:
+
+```python
+# Create a map object
+m = gj.Map()
+
+# Add a shaded relief map
+m.d_shade(color="elevation", shade="aspect")
+
+# Add the vector map to the map object
+m.d_vect(map="roadsmajor", color="black")
+
+# Add a raster legend
+m.d_legend(
+    raster="elevation",
+    at=(5,40,11,14),
+    title="Elevation (m)",
+    font="sans",
+    flags="b"
+)
+
+# Add a scale bar to the map
+m.d_barscale(at=(50,7), flags="n")
+
+# Display the map
+m.show()
+```
+
+!!! grass-tip "Order Matters"
+    <!-- markdownlint-disable-next-line MD046 -->
+    Map features are added to the map in the order they are called. For example,
+    if you add a raster map and then a vector map, the vector map will be drawn
+    on top of the raster map.
+
+In fact the `gj.Map` object doesn't even need to be a map! You can use other
+display tools like [d.histogram](d.histogram.md) or
+[d.polar](d.polar.md), to create plots in Jupyter:
+
+```python
+hist_plot = gj.Map()
+hist_plot.d_histogram(map="elevation")
+hist_plot.show()
+```
+
+```python
+polar_plot = gj.Map()
+polar_plot.d_polar(map="aspect", undef=0)
+polar_plot.show()
+```
+
+## Interactive Maps
+
+The `gj.InteractiveMap` class in `grass.jupyter` provides a way to create interactive
+web maps in Jupyter. Interactive maps are created using the
+[ipyleaflet](https://ipyleaflet.readthedocs.io/en/latest/)
+or [folium](https://python-visualization.github.io/folium/) libraries.
+The default is [ipyleaflet](https://ipyleaflet.readthedocs.io/en/latest/),
+which gives you more interactivity and control over the map. Here we create
+an interactive map of the aspect and elevation rasters and the roadsmajor
+vector map:
+
+```python
+# Create an interactive map
+m = gj.InteractiveMap()
+m.add_raster("aspect", opacity=0.5)
+m.add_raster("aspect", opacity=0.7)
+m.add_raster("elevation", opacity=0.7)
+m.add_vector("roadsmajor")
+m.show()
+```
+
+The map gives you the ability to query the map, zoom in and out, and pan around,
+set the computational region, and add vector data to the map.
+
+## 3D Visualization
+
+```python
+elevation_3dmap = gj.Map3D()
+elevation_3dmap.render(
+    elevation_map="elevation",
+    color_map="landuse",
+    perspective=35,
+    height=5000,
+    resolution_fine=1,
+    zexag=5,
+    fringe=['ne','nw','sw','se'],
+    fringe_elevation=10,
+    arrow_position=[100,50],
+)
+elevation_3dmap.overlay.d_barscale(at=(60,10), flags="")
+elevation_3dmap.overlay.d_legend(raster="landuse", at=(5,35,5,9), flags="b")
+elevation_3dmap.show()
+```
+
+The parameters are the same as parameters of
+the [m.nviz.image](m.nviz.image.md) tool.
+
+## Series Maps
+
+```python
+m = gj.SeriesMap()
+m.add_rasters(["elevation", "slope", "aspect"])
+m.add_vectors(["roads", "buildings"])
+m.d_barscale(at=(80, 10))
+m.show()
+m.save("series_map.gif")
+```
+
+!!! grass-tip "Use Regions"
+    <!-- markdownlint-disable-next-line MD046 -->
+    Set the zoom level based on the computational region of the map by setting
+    `use_region=True` in the `grass.jupyter` class.
+
+## Time Series
+
+The `gj.TimeSeriesMap` class in `grass.jupyter` provides a way visualize
+GRASS' [space time datasets](temporalintro.md) in Jupyter. Here we create a time
+series map of flood inundation extent at different depths:
+
+```python
+flood_map = gj.TimeSeriesMap()
+
+# Add the base map
+flood_map.d_rast(map="naip_2022_rgb")
+flood_map.d_vect(map="ncssm", fill_color="none", color="white", width=2)
+flood_map.d_vect(map="roads")
+
+# Add the time series data
+flood_map.add_raster_series("flooding")
+
+# Add map features
+flood_map.d_legend()
+
+#Display the map
+flood_map.show()
+```
+
+!!! grass-tip "Render Large Time Series"
+    <!-- markdownlint-disable-next-line MD046 -->
+    Large time series can take a long time to render. To speed things up
+    you can use the `m.render()` function to render the PNG files to a
+    temporary directory and then use the `m.save()` or `m.show()` to display
+    the time series.
+
+## Integration with Other Python Libraries
+
+The `grass.jupyter` package can be used in conjunction with other Python libraries
+like [pandas](https://pandas.pydata.org/), [numpy](https://scipy.org/),
+[matplotlib](https://matplotlib.org/), [seaborn](https://seaborn.pydata.org/),
+and many more.
+
+Here we will use the [r.profile](r.profile.md) tool to extract elevation values
+across a transect of the elevation raster as JSON data. We will then load the
+JSON data into a pandas DataFrame and create a scatter plot of
+distance vs. elevation with color coding:
+
+```python
+import grass.script as gs
+import pandas as pd
+import matplotlib.pyplot as plt
+
+# Run r.profile command
+elevation = gs.parse_command(
+    "r.profile",
+    input="elevation",
+    coordinates="641712,226095,641546,224138,641546,222048,641049,221186",
+    format="json",
+    flags="gc"
+)
+
+# Load the JSON data into a DataFrame
+df = pd.DataFrame(elevation)
+
+# Convert the RGB color values to hex format for Matplotlib
+df["color"] = df.apply(
+        lambda x: "#{:02x}{:02x}{:02x}".format(
+            int(x["red"]),
+            int(x["green"]),
+            int(x["blue"])
+        ),
+        axis=1
+    )
+
+# Create the scatter plot
+plt.figure(figsize=(10, 6))
+plt.scatter(df['distance'], df['elevation'], c=df['color'], marker='o')
+plt.title('Profile of Distance vs. Elevation with Color Coding')
+plt.xlabel('Distance (meters)')
+plt.ylabel('Elevation')
+plt.grid(True)
+plt.show()
+```
+
+*Example from [r.profile](r.profile.md) tool*
+
+## Python Library Documentation
+
+For complete documentation on the `grass.jupyter` package, see the
+[grass.jupyter](https://grass.osgeo.org/grass-stable/manuals/libpython/grass.jupyter.html)
+library documentation page.
+
+## Tutorials
+
+- [Get started with GRASS in Jupyter Notebooks on Windows](https://grass-tutorials.osgeo.org/content/tutorials/get_started/JupyterOnWindows_OSGeo4W_Tutorial.html)
+- [Get started with GRASS & Python in Jupyter Notebooks (Unix/Linux)](https://grass-tutorials.osgeo.org/content/tutorials/get_started/fast_track_grass_and_python.html)
+- [Get started with GRASS GIS in Google Colab](https://grass-tutorials.osgeo.org/content/tutorials/get_started/grass_gis_in_google_colab.html)
diff --git a/man/mkdocs/docs/python_intro.md b/man/mkdocs/docs/python_intro.md
new file mode 100644
index 00000000000..2a5fef6553e
--- /dev/null
+++ b/man/mkdocs/docs/python_intro.md
@@ -0,0 +1,814 @@
+---
+authors:
+    - Corey T. White
+    - GRASS Development Team
+---
+
+# Python Introduction
+
+GRASSs' Python interface provides libraries to create GRASS scripts and access
+the internal data structures of GRASS. The Python interface is broken down into
+three main libraries:
+[grass.script](https://grass.osgeo.org/grass-stable/manuals/libpython/script.html#module-script.core),
+[grass.pygrass](https://grass.osgeo.org/grass-stable/manuals/libpython/pygrass_index.html),
+and [grass.temporal](https://grass.osgeo.org/grass-stable/manuals/libpython/temporal_framework.html).
+The `grass.script` library provides a Python interface to GRASS, the `grass.pygrass`
+library provides access to the internal data structures of GRASS, and the
+`grass.temporal` library provides a Python interface to the temporal framework
+in GRASS.
+
+This introduction will cover the basics of the GRASS Python interface and provide
+examples of how to use the libraries to create scripts and access the internal
+data structures of GRASS. However, it is important to note that this is not comprehensive
+documentation. For a complete reference of the GRASS Python interface, see the
+
+<!-- markdownlint-disable-next-line line-length -->
+[Full Documentation :material-arrow-right-bold:](https://grass.osgeo.org/grass-stable/manuals/libpython/index.html){ .md-button }
+
+## GRASS Script
+
+### Setup
+
+To get started with the GRASS Python interface, you must first append the GRASS
+Python path to the system path and then import the `grass.script` library. From
+here, you can create a new project with `gs.create_project` and start a GRASS
+session with the `grass.script.setup.init` function to initialize the GRASS
+environment.
+
+```python
+import sys
+import subprocess
+from pathlib import Path
+
+# Append GRASS to the python system path
+sys.path.append(
+    subprocess.check_output(["grass", "--config", "python_path"], text=True).strip()
+)
+
+import grass.script as gs
+
+# Create a new project
+gs.create_project(path=grassdata, name=project_name, epsg="3358", overwrite=False)
+
+# Initialize the GRASS session
+with gs.setup.init(Path("grassdata/project_name")) as session:
+
+    # Run GRASS commands
+    gs.run_command('g.region', raster='elevation')
+    gs.run_command(
+        'r.slope.aspect',
+        elevation='elevation',
+        slope='slope',
+        aspect='aspect'
+    )
+```
+
+!!! grass-tip "Use `if __name__ == '__main__':`"
+    When writing GRASS scripts, it is a good idea to include the GRASS session
+    setup in a `if __name__ == '__main__':` block. This will allow the script to
+    be imported into other scripts without running the GRASS session setup or executed
+    as a standalone script.
+
+### Tool Execution
+
+The `gs.run_command`, `gs.read_command`, `gs.write_command`, and
+`gs.parse_command` functions are the four main `grass.scripts`
+functions used to execute GRASS tools with Python.
+
+| Function            | Description                                      |
+|---------------------|--------------------------------------------------|
+| `gs.run_command`    | Run a GRASS command with no return value         |
+| `gs.read_command`   | Run a GRASS command and return the `stdout`      |
+| `gs.write_command`  | Run a GRASS command and write to `stdin`         |
+| `gs.parse_command`  | Run a GRASS command and parse the `stdout`       |
+
+!!! grass-tip "Command Syntax"
+    The syntax for the `gs.run_command`, `gs.read_command`, `gs.write_command`,
+    and `gs.parse_command` function follows the pattern:
+    `function_name(module.name, option1=value1, option2=..., flags='flagletters')`
+
+The `gs.run_command` function is used to run a GRASS command when you require
+no return value from the command. For example, when setting the computational region
+with `g.region`:
+
+```python
+gs.run_command('g.region', raster='elevation')
+```
+
+The `gs.read_command` function is used to run a GRASS command when you require
+the results sent to the `stdout`. For example, when reading the output of `r.univar`:
+
+```python
+stats = gs.read_command('r.univar', map='elevation', flags='g')
+```
+
+The `gs.write_command` function is used to run send data to a GRASS command
+through the `stdin`. For example, when writing a custom color scheme to
+a raster map with `r.colors`:
+
+```python
+color_scheme = """
+20% #ffffd4
+40% #fed98e
+60% #fe9929
+80% #d95f0e
+100% #993404
+"""
+gs.write_command('r.colors',
+    map='elevation',
+    rules='-',  # Read from stdin
+    stdin=color_scheme
+)
+```
+
+The `gs.parse_command` function is used to run a GRASS command when you require
+the results sent to the `stdout` and parsed as a key-value pair. For example,
+to parse the output of `r.univar` as JSON data:
+
+```python
+univar_json = gs.parse_command(
+    'r.univar',
+    map='elevation',
+    format="json",
+    flags='g'
+)
+```
+
+!!! grass-tip "Use JSON Format"
+    It is a good idea to use the `JSON` format when parsing the output of a GRASS
+    command with `gs.parse_command`. The `JSON` format provides a consistent
+    structure for the output and is easy to work with in Python.
+
+<!-- markdownlint-disable-next-line line-length -->
+[Full Documentation :material-arrow-right-bold:](https://grass.osgeo.org/grass-stable/manuals/libpython/script_intro.html){ .md-button }
+
+### Rasters
+
+The [grass.script.raster](https://grass.osgeo.org/grass-stable/manuals/libpython/script.html#module-script.raster)
+library provides provides functional access to raster metadata
+and processing tools. Some of the core functions include:
+
+| Function | Description |
+|----------|-------------|
+| [raster_info](https://grass.osgeo.org/grass-stable/manuals/libpython/script.html#script.raster.raster_info) | Get information about a raster map |
+| [raster_what](https://grass.osgeo.org/grass-stable/manuals/libpython/script.html#script.raster.raster_what) | Get information about a raster map |
+| [history](https://grass.osgeo.org/grass-stable/manuals/libpython/script.html#script.raster.history) | Get the history of a raster map |
+| [mapcalc](https://grass.osgeo.org/grass-stable/manuals/libpython/script.html#script.raster.mapcalc) | Execute a raster algebra expression |
+
+Here is an example of how to use the [grass.script.raster](https://grass.osgeo.org/grass-stable/manuals/libpython/script.html#module-script.raster)
+module:
+
+```python
+# Get metadata about the elevation raster
+gs.raster_info('elevation')
+
+# Create a new raster map with the mapcalc expression
+gs.mapcalc(expression="elevation_2x = elevation * 2")
+```
+
+!!! grass-tip "Why not use the tool directly?"
+    The `raster` module provides a more functional approach to working with raster
+    maps in GRASS.
+
+<!-- markdownlint-disable-next-line line-length -->
+[Full Documentation :material-arrow-right-bold:](https://grass.osgeo.org/grass-stable/manuals/libpython/script.html#module-script.raster){ .md-button }
+
+### Vectors
+
+The [grass.script.vector](https://grass.osgeo.org/grass-stable/manuals/libpython/script.html#module-script.vector)
+library provides functional access to vector metadata
+and processing tools. Some of the core functions include:
+
+| Function            | Description                                      |
+|---------------------|--------------------------------------------------|
+| [vector_columns](https://grass.osgeo.org/grass-stable/manuals/libpython/script.html#script.vector.vector_columnsr)    | Get the columns of a vector map                  |
+| [vector_info](https://grass.osgeo.org/grass-stable/manuals/libpython/script.html#script.vector.vector_info)       | Get information about a vector map               |
+| [vector_db](https://grass.osgeo.org/grass-stable/manuals/libpython/script.html#script.vector.vector_db)         | Get the database connection of a vector map      |
+| [vector_db_select](https://grass.osgeo.org/grass-stable/manuals/libpython/script.html#script.vector.vector_db_select)  | Select data from a vector map                    |
+| [vector_info_topo](https://grass.osgeo.org/grass-stable/manuals/libpython/script.html#script.vector.vector_info_topo)  | Get topology information about a vector map      |
+
+Here we will use the [grass.script.vector](https://grass.osgeo.org/grass-stable/manuals/libpython/script.html#module-script.vector)
+module to get the topological information about the `geology` vector map:
+
+```python
+# Get the topology information about the geology vector map
+geology_topo = gs.vector_info_topo("geology")
+
+# Get the number nodes
+nodes = geology_topo.nodes
+```
+
+<!-- markdownlint-disable-next-line line-length -->
+[Full Documentation :material-arrow-right-bold:](https://grass.osgeo.org/grass-stable/manuals/libpython/script.html#module-script.vector){ .md-button }
+
+### 3D Rasters
+
+Incomplete Section
+
+```python
+r3grass.raster3d_info('elevation3d')
+
+r3grass.mapcalc3d('volume = row() + col() + depth()')
+```
+
+<!-- markdownlint-disable-next-line line-length -->
+[Full Documentation :material-arrow-right-bold:](https://grass.osgeo.org/grass-stable/manuals/libpython/script.html#module-script.raster3d){ .md-button }
+
+### Database Management
+
+Incomplete Section
+
+```python
+from grass.script import db as dbgrass
+```
+
+<!-- markdownlint-disable-next-line line-length -->
+[Full Documentation :material-arrow-right-bold:](https://grass.osgeo.org/grass-stable/manuals/libpython/script.html#module-script.db){ .md-button }
+
+## Object-Oriented GRASS
+
+PyGRASS is an object-oriented Python library that provides access to the internal
+data structures of GRASS for more advanced scripting and modeling. PyGRASS works
+directly with the C libraries of GRASS and providing a Pythonic interface. The
+core packages of `grass.pygrass` include:
+
+| Topic                         | Documentation Link                                                                                   |
+|-------------------------------|------------------------------------------------------------------------------------------------------|
+| Project and Region Management | [grass.pygrass.gis](https://grass.osgeo.org/grass-stable/manuals/libpython/pygrass_gis.html)         |
+| Raster Data Access            | [grass.pygrass.raster](https://grass.osgeo.org/grass-stable/manuals/libpython/pygrass_raster.html)   |
+| Vector Data Access            | [grass.pygrass.vector](https://grass.osgeo.org/grass-stable/manuals/libpython/pygrass_vector.html)   |
+| GRASS Tool Access             | [grass.pygrass.modules](https://grass.osgeo.org/grass-stable/manuals/libpython/pygrass_modules.html) |
+
+For a complete reference of the PyGRASS library, see the Full Documentation:
+
+<!-- markdownlint-disable-next-line line-length -->
+[Full Documentation :material-arrow-right-bold:](https://grass.osgeo.org/grass-stable/manuals/libpython/pygrass_index.html){ .md-button }
+
+### Project Management
+
+The [grass.pygrass.gis](https://grass.osgeo.org/grass-stable/manuals/libpython/pygrass_gis.html)
+module provides access to the project and region management
+of GRASS. The [grass.pygrass.gis](https://grass.osgeo.org/grass-stable/manuals/libpython/pygrass_gis.html)
+module provides functions to create, manage, and delete GRASS projects and
+mapsets. The core classes include [Gisdbase](https://grass.osgeo.org/grass-stable/manuals/libpython/pygrass.gis.html#pygrass.gis.Gisdbase),
+[Location](https://grass.osgeo.org/grass-stable/manuals/libpython/pygrass.gis.html#pygrass.gis.Location),
+and [Mapset](https://grass.osgeo.org/grass85/manuals/libpython/pygrass.gis.html#pygrass.gis.Mapset).
+
+#### Gisdbase
+
+The [Gisdbase](https://grass.osgeo.org/grass-stable/manuals/libpython/pygrass.gis.html#pygrass.gis.Gisdbase)
+class provides access to the GRASS database
+and where you can manage GRASS projects and mapsets.
+
+For example, to list all projects in your GRASS database directory you can use:
+
+```python
+from grass.pygrass import gis
+
+grassdata = gis.Gisdbase()
+projects = grassdata.locations()
+print(projects)
+```
+
+This will return a list of all projects in the GRASS database directory as
+[Location](https://grass.osgeo.org/grass-stable/manuals/libpython/pygrass.gis.html#pygrass.gis.Location)
+objects.
+
+```text
+['nc_spm_08_grass7', 'my_project']
+```
+
+#### Location
+
+The [Location](https://grass.osgeo.org/grass-stable/manuals/libpython/pygrass.gis.html#pygrass.gis.Location)
+object provides access to the specific project
+and its mapsets.
+
+```python
+from grass.pygrass.gis import Location
+
+location = Location()
+
+# Get the name of the location
+print(location.name)
+
+# Get list of mapsets in the location
+mapsets = location.mapsets()
+```
+
+#### Mapset
+
+The [Mapset](https://grass.osgeo.org/grass85/manuals/libpython/pygrass.gis.html#pygrass.gis.Mapset)
+object provides access to the specific mapset and its layers.
+
+```python
+from grass.pygrass.gis import Mapset
+
+# Get the current mapset
+mapset = Mapset()
+
+# List all rasters in the mapset
+rasters = mapset.glist(type='raster')
+```
+
+For more details about the `gis` module, see the Full Documentation:
+[GIS Module](https://grass.osgeo.org/grass-stable/manuals/libpython/pygrass_gis.html)
+
+#### Region
+
+The [grass.pygrass.gis.region](https://grass.osgeo.org/grass-stable/manuals/libpython/pygrass.gis.html#pygrass.gis.region.Region)
+module gives access to read and modify computational regions. For example, to
+get the current extent and resolution of the active mapset:
+
+```python
+from grass.pygrass.gis.region import Region
+
+region = Region()
+
+extent = region.get_bbox()
+resolution = [region.nsres, region.ewres]
+
+print(f"""
+Extent: {extent}
+Resolution: {resolution}
+""")
+```
+
+```text
+Extent: Bbox(228500.0, 215000.0, 645000.0, 630000.0)
+Resolution: [10.0, 10.0]
+```
+
+To set the computational region you can adjust the current `Region` with the
+`adjust` method or set it to a specific map to a specific map with `from_rast`
+or `from_vect` methods.:
+
+```python
+from grass.pygrass.gis.region import Region
+
+region = Region()
+
+# Set the region from the elevation raster
+region.from_rast('elevation')
+
+# Adjust the region by adding 100 map units
+# to the east and north
+region.east += 100
+region.north += 100
+
+# Apply the changes
+region.adjust()
+
+# Lets compare the new region
+extent = region.get_bbox()
+resolution = [region.nsres, region.ewres]
+
+print(f"""
+Extent: {extent}
+Resolution: {resolution}
+""")
+```
+
+Here we can see that the region has been adjusted by 100 map units to the east
+and north while the spatial resolution remains the same.
+
+```text
+Extent: Bbox(228600.0, 215000.0, 645100.0, 630000.0)
+Resolution: [10.0, 10.0]
+```
+
+For more details about the `region` module, see the Full Documentation:
+
+<!-- markdownlint-disable-next-line line-length -->
+[Full Documentation :material-arrow-right-bold:](https://grass.osgeo.org/grass-stable/manuals/libpython/pygrass.gis.html#module-pygrass.gis){ .md-button }
+
+### Data Management
+
+#### Raster
+
+Do you have an idea that requires more advanced raster processing? PyGRASS provides
+direct read and write access to raster data with the
+[grass.pygrass.raster](https://grass.osgeo.org/grass-stable/manuals/libpython/pygrass_raster.html)
+module. The core classes include [RasterRow](https://grass.osgeo.org/grass-stable/manuals/libpython/pygrass_raster.html#rasterrow),
+[RasterRowIO](https://grass.osgeo.org/grass-stable/manuals/libpython/pygrass_raster.html#rasterrowio),
+and [RasterSegment](https://grass.osgeo.org/grass-stable/manuals/libpython/pygrass_raster.html#rastersegment).
+Each class provides a different level of access to the raster data with its own set
+of read and write capabilities, as shown in the table below.
+
+| Class          | Description                                             | Read | Write |
+|----------------|-------------------------------------------------------- |-------|------|
+| [RasterRow](https://grass.osgeo.org/grass-stable/manuals/libpython/pygrass_raster.html#rasterrow)    | Read write access to raster row data.                       | :rabbit2: Random  | :rabbit2: Sequential |
+| [RasterRowIO](https://grass.osgeo.org/grass-stable/manuals/libpython/pygrass_raster.html#rasterrowio)  | Fast read only access to raster row data.                   | :rabbit2: Cached | :x: No |
+| [RasterSegment](https://grass.osgeo.org/grass-stable/manuals/libpython/pygrass_raster.html#rastersegment) | Simultaneous read write access to tiled raster segments stored on disk.       | :turtle: Cached | :turtle: Random |
+
+The [RasterRow](https://grass.osgeo.org/grass-stable/manuals/libpython/pygrass_raster.html#rasterrow)
+class allows for either read or write access to raster row data
+and provides methods to access raster state and metadata. To read all rows of the
+`elevation` raster:
+
+```python
+from grass.pygrass import raster
+
+with raster.RasterRow('elevation') as elev:
+
+    # Get the total number of rows
+    nrows = elev.info.rows
+    print(f"Total Rows: {nrows}")
+
+    for row in elev:
+        print(row)
+```
+
+For practice, let's read a value from a row and column in the `elevation`
+raster, double it, and write the value back to a new raster `elevation_new`.
+
+```python
+from grass.pygrass import raster
+
+# Open the elevation raster in read mode
+with raster.RasterRow('elevation') as elev:
+
+    # Read a random row and column
+    value = elev[5][10]
+
+    # Open the new elevation raster in write mode
+    with raster.RasterRow('elevation_new', mode='w', mtype="FCELL") as new_elev:
+        # Sequentially iterate over the rows and columns
+        for row_id, row in enumerate(elev, start=0):
+            # When we reach the row and column we want to change
+            if row_id == 5:
+                # Set the value
+                row[10] = value * 2
+
+            # Write the rows to the new raster
+            new_elev.put_row(row)
+```
+
+!!! grass-tip "RasterSegment"
+    The [RasterSegment](https://grass.osgeo.org/grass-stable/manuals/libpython/pygrass_raster.html#rastersegment)
+    class provides simultaneous read and write access to tiled
+    raster segments stored on disk. This class is useful for working with large
+    raster datasets that do not fit into memory.
+
+For more details about the `raster` module, see the Full Documentation:
+
+<!-- markdownlint-disable-next-line line-length -->
+[Full Documentation :material-arrow-right-bold:](https://grass.osgeo.org/grass-stable/manuals/libpython/pygrass_raster.html){ .md-button }
+
+#### Vector
+
+The [grass.pygrass.vector](https://grass.osgeo.org/grass-stable/manuals/libpython/pygrass_vector.html#vector)
+module provides direct read and write access to vector data in GRASS.
+The core classes include [Vector](https://grass.osgeo.org/grass-stable/manuals/libpython/pygrass.vector.html#pygrass.vector.Vector)
+and [VectorTopo](https://grass.osgeo.org/grass-stable/manuals/libpython/pygrass_vector.html#vectortopo-label).
+
+| Class          | Description  |
+|----------------|--------------|
+| [Vector](https://grass.osgeo.org/grass-stable/manuals/libpython/pygrass.vector.html#pygrass.vector.Vector) | Provides basic information about vector data. |
+| [VectorTopo](https://grass.osgeo.org/grass-stable/manuals/libpython/pygrass_vector.html#vectortopo-label) | Read and write access to vector data. |
+
+Here is a simple example with [Vector](https://grass.osgeo.org/grass-stable/manuals/libpython/pygrass.vector.html#pygrass.vector.Vector)
+to check if a vector map exists and print the mapset it is in.
+
+```python
+from grass.pygrass.vector import Vector
+
+# Check if the roads vector map exists
+geology = Vector('roadsmajor')
+
+if roads.exists():
+    mapset = roads.mapset
+    print(f"The roads vector map exists in the {mapset} mapset")
+
+```
+
+With the [VectorTopo](https://grass.osgeo.org/grass-stable/manuals/libpython/pygrass_vector.html#vectortopo-label)
+class you can get the same basic information about the
+vector map returned by the [Vector](https://grass.osgeo.org/grass-stable/manuals/libpython/pygrass.vector.html#pygrass.vector.Vector)
+class in addition to read and write access.
+
+```python
+from grass.pygrass.vector import Vector
+
+# Open the roads vector map as a VectorTopo object
+with VectorTopo('roadsmajor') as roads:
+
+    # Get the first feature
+    first_feature = roads.next()
+    print(first_feature)
+
+    # Get the number of nodes
+    roads.number_of('nodes')
+```
+
+#### Geometry and Attributes
+
+In GRASS vector [geometry](https://grass.osgeo.org/grass-stable/manuals/libpython/pygrass_vector.html#geometry-classes)
+and attributes are treated separately. This means that the attributes of a
+vector are not automatically read when the geometry is read.
+
+To build a geometry object, you can use the geometry class in the
+[grass.pygrass.vector.geometry](https://grass.osgeo.org/grass-stable/manuals/libpython/pygrass.vector.html#module-pygrass.vector.geometry)
+module.
+
+| Geometry Class | Description |
+|----------------|-------------|
+| [Area](https://grass.osgeo.org/grass-stable/manuals/libpython/pygrass.vector.html#pygrass.vector.geometry.Area) | Represents the topological composition of a closed ring of boundaries and a centroid. |
+| [Boundary](https://grass.osgeo.org/grass-stable/manuals/libpython/pygrass.vector.html#pygrass.vector.geometry.Boundary) | Represents the border line to describe an area. |
+| [Centroid](https://grass.osgeo.org/grass-stable/manuals/libpython/pygrass.vector.html#pygrass.vector.geometry.Centroid) | Represents a centroid feature in a vector map. |
+| [Isle](https://grass.osgeo.org/grass-stable/manuals/libpython/pygrass.vector.html#pygrass.vector.geometry.Isle) | Represents an isle feature in a vector map. |
+| [Line](https://grass.osgeo.org/grass-stable/manuals/libpython/pygrass.vector.html#pygrass.vector.geometry.Line) | Represents a line feature in a vector map. |
+| [Point](https://grass.osgeo.org/grass-stable/manuals/libpython/pygrass.vector.html#pygrass.vector.geometry.Point) | Represents a point feature in a vector map. |
+
+Each geometry class has its own set of methods to help extract useful
+information. For example, let's built a `Boundary` object from a list of points
+and calculate the area of the boundary.
+
+```python
+from grass.pygrass.vector.geometry import Boundary
+
+# Create a new boundary object
+border = Boundary(points=[(0, 0), (0, 2), (2, 2), (2, 0), (0, 0)])
+
+# Get the area of the boundary
+area = border.area
+```
+
+To access the attributes of a vector map, you can use the `attrs` attribute
+of the [VectorTopo](https://grass.osgeo.org/grass-stable/manuals/libpython/pygrass_vector.html#vectortopo-label)
+object. The `attrs` attribute is a dictionary that contains
+the attributes of the current feature.
+
+```python
+from grass.pygrass.vector import VectorTopo
+
+# Open the roads vector map in read mode
+with VectorTopo('roadsmajor') as roads:
+    # Read attribute the first feature
+    read_feature = roads.read(1)
+    # Prints the LINESTRING geometry
+    print(read_feature)
+    # Prints a dictionary of the attributes
+    print(dict(read_feature.attrs))
+```
+
+To write a new feature to the `roads` vector map with attributes
+we need to access the database of the vector map with the [VectorTopo](https://grass.osgeo.org/grass-stable/manuals/libpython/pygrass_vector.html#vectortopo-label).
+
+Here is an example of how to write a new feature to the `roads` vector map.
+
+```python
+from grass.pygrass.vector import VectorTopo
+from grass.pygrass.vector.geometry import Line
+
+with VectorTopo('roadsmajor', mode='rw') as roads:
+
+    # Create a new feature
+    # The tuple is shorthand for a list of Point(x, y)
+    new_geom = Line([(636981.33, 256517.60), (636983.10, 256526.59)])
+    
+    # Get the last cat value (primary key)
+    last_record = roads.read(-1)
+    last_cat = last_record.cat
+
+    # Create an empty feature from the last record
+    new_dict = {key: None for key in last_record.attrs}
+    new_dict['cat'] = last_cat + 1
+    new_dict['MAJORRDS_'] = 2.0
+    new_dict['ROAD_NAME'] = 'New Road'
+    new_dict['MULTILINE'] = 'No'
+    new_dict['PROPYEAR'] = 2025
+
+    # Write the new feature to the vector map
+    roads.write(new_geom, new_dict)
+
+    # Write the attributes to the database
+    roads.table.conn.commit()
+
+    # Build the topology
+    roads.build()
+```
+
+Featurs can also be updated by using the [rewrite](https://grass.osgeo.org/grass-stable/manuals/libpython/pygrass.vector.html#pygrass.vector.VectorTopo.rewrite)
+method instead of the `write`. If the geometry of the feature has not changed,
+you can save the attributes to the database table without rebuilding the
+topology using `table.conn.commit`.
+
+#### Querying Vector Data
+
+You can also query the vector map for specific features using the `where` method.
+For example, to get all features where the `ROAD_NAME` attribute is `NC-50` and
+the line segment length is greater than 1000.
+
+```python
+from grass.pygrass.vector import VectorTopo
+
+# Open the roads vector map as a VectorTopo object
+with VectorTopo('roadsmajor') as roads:
+    # Iterate over each feature in the vector map
+    for feature in roads.viter('line'):
+        # Check if the feature is a line and the length is greater than 1000
+        # And the ROAD_NAME attribute is 'NC-50'
+        if feature.lenght() < 100 and feature['ROAD_NAME'] == 'NC-50':
+            print(feature)
+```
+
+You can also use many of `Geometry` and `Attribute` methods to filter
+features in a more concise way.
+
+For example, to test if a random point is within 5000 meters of a road segment
+you can use the [distance](https://grass.osgeo.org/grass-stable/manuals/libpython/pygrass.vector.html#pygrass.vector.geometry.Line.distance)
+method of the [Line](https://grass.osgeo.org/grass-stable/manuals/libpython/pygrass.vector.html#pygrass.vector.geometry.Line)
+geometry object. The [distance](https://grass.osgeo.org/grass-stable/manuals/libpython/pygrass.vector.html#pygrass.vector.geometry.Line.distance)
+method returns a [LineDist](https://grass.osgeo.org/grass-stable/manuals/libpython/pygrass.vector.html#pygrass.vector.geometry.LineDist)
+object that contains the distance and the closest point on the line.
+
+```python
+from grass.pygrass.vector import VectorTopo
+from grass.pygrass.vector.geometry import Point
+
+with VectorTopo('roadsmajor') as roads:
+    # Get the extent of the roads vector map
+    extent = roads.bbox()
+
+    # Create a random point within the extent
+    x = random.uniform(extent.east, extent.west)
+    y = random.uniform(extent.north, extent.south) 
+    random_point = Point(x, y)
+
+    # Iterate over each feature in the vector map
+    for feature in roads.viter('lines'):
+        # Check if the random point is within a 5000 meters of the line
+        line_distance = feature.distance(random_point)
+        if line_distance.dist < 5000:
+            print(f"""
+                The random point {random_point} is within 5000 m 
+                of the road segment: {feature.cat}
+            """)
+```
+
+Or to simple filter a table using `SQL` you can use the `where` method with
+[table_to_dict](https://grass.osgeo.org/grass-stable/manuals/libpython/pygrass.vector.html#pygrass.vector.VectorTopo.table_to_dict)
+to get a dictionary of the features that match the query, the [table.Filter](https://grass.osgeo.org/grass-stable/manuals/libpython/pygrass.vector.html#pygrass.vector.table.Filters)
+class for more advanced operations.
+
+```python
+from grass.pygrass.vector import VectorTopo
+
+# Open the roads vector map as a VectorTopo object
+roads = VectorTopo('roadsmajor')
+roads.open("r")
+
+# Query the vector map for all features where the
+# ROAD_NAME attribute is 'NC-50'
+roads.table_to_dict(where="ROAD_NAME = 'NC-50'")
+sql_1 = roads.table.filters.get_sql()
+
+# Query the vector map for the first 5 features where the 
+# ROAD_NAME attribute is 'NC-70'
+roads.table.filters.where("ROAD_NAME = 'NC-70'").limit(5)
+sql_2 = roads.table.filters.get_sql()
+
+# Close the vector map
+roads.close()
+```
+
+The values of the `sql_1` and `sql_2` variable will be the SQL query that was
+used to filter the features.
+
+```sql
+-- Value of sql_1
+SELECT * FROM roadsmajor WHERE ROAD_NAME = 'NC-50' ORDER BY cat;
+
+-- Value of sql_2
+SELECT * FROM roadsmajor WHERE ROAD_NAME = 'NC-50' ORDER BY cat LIMIT 5;
+```
+
+!!! grass-tip "Used Different SQL Database"
+    The default database for GRASS is SQLite, but you can use other SQL databases
+    like PostgreSQL with the `driver` option in the [VectorTopo](https://grass.osgeo.org/grass-stable/manuals/libpython/pygrass_vector.html#vectortopo-label)
+    object.
+
+For more details about the `vector` module, see the Full Documentation:
+
+<!-- markdownlint-disable-next-line line-length -->
+[Full Documentation :material-arrow-right-bold:](https://grass.osgeo.org/grass-stable/manuals/libpython/pygrass_vector.html){ .md-button }
+
+### GRASS Tool Access
+
+The [grass.pygrass.modules](https://grass.osgeo.org/grass-stable/manuals/libpython/pygrass_modules.html)
+module provides access to the GRASS tools and modules. The `Module` class
+provides a Pythonic interface to the GRASS modules and tools.
+
+Here we use the `Module` class to create an Module object of the [r.slope.aspect](r.slope.aspect.md)
+tool.
+
+```python
+from grass.pygrass.modules import Module
+
+slope_aspect_tool = Module(
+    "r.slope.aspect", 
+    elevation='elevation',
+    slope='slope',
+    aspect='aspect'
+)
+```
+
+The `Module` object provides a `run` method to execute the GRASS tool.
+
+```python
+slope_aspect_tool.run()
+```
+
+but you can also execute the tool with the `()` operator.
+
+```python
+slope_aspect_tool()
+```
+
+The `Module` object also provides a the access to the tool attributes
+such as the name, description, keywords, and inputs.
+
+```python
+slope_aspect_tool.name
+slope_aspect_tool.description
+slope_aspect_tool.keywords
+slope_aspect_tool.inputs
+```
+
+The [grass.pygrass.modules](https://grass.osgeo.org/grass-stable/manuals/libpython/pygrass_modules.html)
+module provides an alterative approach to running GRASS tools.
+
+To learn more about the `Module` class, see the Full Documentation:
+
+<!-- markdownlint-disable-next-line line-length -->
+[Full Documentation :material-arrow-right-bold:](https://grass.osgeo.org/grass-stable/manuals/libpython/pygrass_modules.html#module-class){ .md-button }
+
+## Message and Error Handling
+
+The `grass.script` library provides functions to display messages and errors.
+
+| Function | Description |
+|----------|-------------|
+| `message` | Display a message to the user |
+| `warning` | Display a warning to the user |
+| `error` | Display an error message to the user (but not fail the script) |
+| `fatal` | Display an error message to the user and stop the script |
+
+Here is an example of how to use the `message` and `warning` functions:
+
+```python
+import grass.script as gs
+# Not localized
+gs.message("Hello World")
+```
+
+```python
+# With translation function
+gs.warning(_("This is a warning"))
+```
+
+Here we can use the GRASS `fatal` function to display an error message to the user
+when the `g.region` command fails with a `CalledModuleError`.
+
+```python
+try:
+    gs.run_command('g.region', raster='elevation')
+except gs.CalledModuleError as e:
+    gs.fatal(_("Failed to set region: {e}"))
+```
+
+!!! grass-tip "Use Formatted Strings"
+    When using the `gs.message` and `gs.fatal` functions, it is a good idea to
+    use formatted strings to provide more information about the message or error.
+    However, f-strings are not suitable when calling the translation function
+    as they don't allow formatting to happen on the translated string.
+    Instead, use the `str.format` method.  
+    <!-- markdownlint-disable-next-line line-length -->
+    :x: `gs.fatal(_(f"Error calculating height above nearest drainage: {e.stderr}"))`  
+    <!-- markdownlint-disable-next-line line-length -->
+    :white_check_mark: `gs.fatal(_("Error calculating height above nearest drainage: %s") % e.stderr)`
+
+## Python FAQ
+
+To help you decide which library to use try answering the following questions:
+
+```mermaid
+graph TD
+    A[What type of data you are working with?];
+    A -- Raster data --> D;
+    A -- Vector data --> H;
+
+    D[Will you use existing tool?];
+    D -- Yes --> F[Use *grass.script* with raster tools such as *r.series*, *r.mapcalc*, *r.neighbors*];
+    D -- No --> G[Use *grass.pygrass.raster* API];
+
+    H[Will you use existing tool?];
+    H -- Yes --> J[Use *grass.script* with vector tools such as *v.overlay*, *v.to.db*, *v.extract*];
+    H -- No --> K[Use *grass.pygrass.vector* API];
+
+    G -- Do you need more control? --> N[Use *ctypes* to directly access C raster API];
+    K -- Do you need more control? --> O[Use *ctypes* to directly access C vector API];
+```
+
+Full Documentation: [GRASS Python Library](https://grass.osgeo.org/grass-stable/manuals/libpython/index.html)
diff --git a/man/mkdocs/grassdocs.css b/man/mkdocs/grassdocs.css
index 852b63d2ff9..f53bb81de87 100644
--- a/man/mkdocs/grassdocs.css
+++ b/man/mkdocs/grassdocs.css
@@ -5,6 +5,8 @@
   ----------------------------------------------------------------------------- */
   --gs-osgeo-blue: rgb(0, 58, 64); /* OSGeo Blue */
   --gs-support-color: rgb(243, 57, 138); /* Pink */
+  --gs-support-color--dark: rgba(243, 57, 138, 0.541);
+  --gs-support-color--light: rgba(243, 57, 138, 0.322);
   --gs-white-color: rgb(255, 255, 255); /* White */
   --gs-white-color--light: rgba(255, 255, 255, 0.541);
   --gs-white-color--lighter: rgba(255, 255, 255, 0.322);
@@ -27,6 +29,7 @@
   --gs-primary-bg-color: var(--gs-white-color); /* White */
   --gs-primary-bg-color-dark: rgba(135, 135, 135, 0.1);
 
+  --md-admonition-icon--grass-icon: url('grass_logo.svg');
 
 
   /* Material MkDocs Variables
@@ -75,8 +78,8 @@
   /* ----------------------------------------------------------------------------- */
   --md-mermaid-font-family: var(--md-text-font-family), sans-serif;
   --md-mermaid-edge-color: var(--md-code-fg-color);
-  --md-mermaid-node-bg-color: var(--md-accent-fg-color--transparent);
-  --md-mermaid-node-fg-color: var(--md-accent-fg-color);
+  --md-mermaid-node-bg-color: var(--md-primary-fg-color--light);
+  --md-mermaid-node-fg-color: var(--md-primary-fg-color);
   --md-mermaid-label-bg-color: var(--md-default-bg-color);
   --md-mermaid-label-fg-color: var(--md-code-fg-color);
   --md-mermaid-sequence-actor-bg-color: var(--md-mermaid-label-bg-color);
@@ -170,3 +173,38 @@
 .md-typeset table:not([class]) tbody tr:hover {
   background-color: transparent;
 }
+
+.gs-icon-primary {
+  color: var(--gs-primary-color);
+}
+
+.gs-icon-accent {
+  color: var(--gs-secondary-color);
+}
+
+/* Custom GRASS support button style: */
+.md-button.gs-support-button {
+  color: var(--gs-support-color);
+}
+
+.md-button.gs-support-button:focus, .md-button.gs-support-button:hover {
+  background-color: var(--gs-support-color);
+  border-color: var(--gs-support-color);
+  color: var(--gs-white-color);
+}
+
+/* Custom GRASS admonition (callout) style: */
+.md-typeset .admonition.grass-tip,
+.md-typeset details.grass-tip {
+  border-color: var(--gs-primary-color-light);
+}
+.md-typeset .grass-tip > .admonition-title,
+.md-typeset .grass-tip > summary {
+  background-color: var(--gs-primary-color--lightest);
+}
+.md-typeset .grass-tip > .admonition-title::before,
+.md-typeset .grass-tip > summary::before {
+  background-color: var(--gs-primary-color);
+  -webkit-mask-image: var(--md-admonition-icon--grass-icon);
+          mask-image: var(--md-admonition-icon--grass-icon);
+}
diff --git a/man/mkdocs/index.md b/man/mkdocs/index.md
new file mode 100644
index 00000000000..461d9e47c0b
--- /dev/null
+++ b/man/mkdocs/index.md
@@ -0,0 +1,60 @@
+---
+authors:
+    - Corey T. White
+    - GRASS Development Team
+title: Getting Started
+---
+
+## What is GRASS?
+
+[GRASS](https://grass.osgeo.org/) is a geospatial processing engine for
+advance analysis and visualization of geospatial data. GRASS is a free and open source
+software, released under the [GNU GPL](https://www.gnu.org/licenses/gpl.html).
+
+<!-- markdownlint-disable-next-line MD013 -->
+[:material-download: Download GRASS](https://grass.osgeo.org/download/){ .md-button }[Grow GRASS :octicons-heart-fill-24:](https://opencollective.com/grass/contribute){ .md-button .gs-support-button}
+
+## Interfaces
+
+GRASS provides a number of [interfaces](interfaces_overview.md) for interacting
+with the software. The most common interfaces are:
+
+- [Command line](command_line_intro.md), also know as terminal or shell
+- [Python](python_intro.md)
+- [Jupyter Notebooks](jupyter_intro.md)
+- [Graphical user interface](helptext.md)
+
+## Processing Tools
+
+GRASS provides a wide range of tools for geospatial processing, modeling,
+analysis, and visualization. The tools are organized into categories based
+on the type of data they process. The tools are prefixed with a letter or combination
+of letters and numbers to indicate the type of data they process.
+
+The following table provides a list of the prefixes and the categories they represent.
+Follow the links to see a complete list of tools in each category. Or try
+using the search feature to find a specific tool or topic by subject
+matter (e.g. hydrology, landscape).
+
+| Prefix | Category                          | Description                        |
+|--------|-----------------------------------|------------------------------------|
+| `g.`   | [General](general.md)             | General GIS management tools       |
+| `r.`   | [Raster](raster.md)               | Raster data processing tools       |
+| `r3.`  | [3D Raster](raster3d.md)          | 3D Raster data processing tools    |
+| `v.`   | [Vector](vector.md)               | Vector data processing tools       |
+| `i.`   | [Imagery](imagery.md)             | Imagery processing tools           |
+| `t.`   | [Temporal](temporal.md)           | Temporal data processing tools     |
+| `db.`  | [Database](database.md)           | Database management tools          |
+| `d.`   | [Display](display.md)             | Display and visualization tools    |
+| `m.`   | [Miscellaneous](miscellaneous.md) | Miscellaneous tools                |
+| `ps.`  | [Postscript](postscript.md)       | Postscript tools                   |
+
+## Development
+
+GRASS is an open source project and welcomes contributions from the community.
+The GRASS Development documentation provides information on how to get started
+developing for GRASS, how to contribute to the project, and how to get involved
+with the GRASS community.
+
+For more information on developing for GRASS, see the
+[Development Introduction](development_intro.md) page.
diff --git a/man/mkdocs/mkdocs.yml b/man/mkdocs/mkdocs.yml
index 90acd3df55d..dd428420b5c 100644
--- a/man/mkdocs/mkdocs.yml
+++ b/man/mkdocs/mkdocs.yml
@@ -28,6 +28,7 @@ theme:
     - content.action.view
     - content.code.copy
     - content.tabs.link
+    - content.tooltips
     - search.suggest
     - search.highlight
     - navigation.footer
@@ -40,14 +41,16 @@ theme:
 
   palette:
     primary: custom
+
   icon:
     repo: fontawesome/brands/github
     edit: material/pencil
     view: material/eye
+    logo: material/library
 
 # Customization
 extra:
-  homepage: ./index.html
+  homepage: index.html
   social:
     - icon: simple/opencollective
       link: https://opencollective.com/grass
@@ -87,22 +90,45 @@ markdown_extensions:
   - admonition
   - pymdownx.details
   - pymdownx.superfences
+  - pymdownx.tasklist
+  - pymdownx.snippets
+  - pymdownx.tabbed
+  - pymdownx.magiclink
   - attr_list
   - md_in_html
+  - pymdownx.emoji:
+      emoji_index: !!python/name:material.extensions.emoji.twemoji
+      emoji_generator: !!python/name:material.extensions.emoji.to_svg
+  - pymdownx.superfences:
+      custom_fences:
+        - name: mermaid
+          class: mermaid
+          format: !!python/name:pymdownx.superfences.fence_code_format
   - pymdownx.tabbed:
       alternate_style: true
 
 # Navigation
 nav:
+  - Getting Started:
+      - Getting Started: index.md
+      # These are linking to interfaces, but they would eventually be new pages
+      # which would provide more context, but less detail.
+      - Command Line: command_line_intro.md
+      - Python: python_intro.md
+      - Jupyter Notebook: jupyter_intro.md
+      - Graphical User Interface: helptext.md
+      - Tutorials: https://grass-tutorials.osgeo.org/
   - Interfaces:
-      - Shell:
-          - Overview: grass.md
-          # - Getting Started: grassintro.md # Does not exist yet
+      - Interfaces: interfaces_overview.md
+      - Command Line:
+          - Command Line Introduction: command_line_intro.md
+          - The grass Command: grass.md
           - Environmental Variables: variables.md
-      - GUI:
-          - Overview: wxguiintro.md
+      - Python Overview: python_intro.md
+      - Jupyter Notebooks: jupyter_intro.md
+      - Desktop GUI:
+          - GUI Overview: wxguiintro.md
           - Features: wxGUI.md
-          - Project Management: grass_database.md
           - Tool Dialogs: wxGUI.modules.md
           - Attribute Table Management: wxGUI.dbmgr.md
           - Cartographic Composer: wxGUI.psmap.md
@@ -112,53 +138,38 @@ nav:
           - Graphical Modeler: wxGUI.gmodeler.md
           - Ground Control Points Manager: wxGUI.gcp.md
           - Network Analysis: wxGUI.vnet.md
-          - Help: helptext.md
+          - Visualization:
+              - Animation: wxGUI.animation.md
+              - 3D Visualization: wxGUI.nviz.md
+              - Interactive Scatter Plot: wxGUI.iscatt.md
+              - Map Swipe: wxGUI.mapswipe.md
+              - Timeline: wxGUI.timeline.md
+              - Temporal Plot: wxGUI.tplot.md
           - List of Components: wxGUI.components.md
 
-      # - Scripting:
-      #     - Overview: scriptingintro.md
-      #     - Python: python.md
-      #     - Shell Scripting: shell.md
-      #     - Batch Processing: batch.md
-      #     - R: r.md
-      # - Jupyter Notebook: jupyter.md
-
-  - Project Management:
-      - General Tools: general.md
+  - Key Concepts:
+      - Raster Overview: rasterintro.md
+      - Raster 3D Overview: raster3dintro.md
+      - Vector Overview: vectorintro.md
+      - Databases Overview: databaseintro.md
+      - Database Drivers: sql.md
+      - Imagery Overview: imageryintro.md
+      - Temporal Overview: temporalintro.md
+      - Display Drivers: displaydrivers.md
+      - GRASS Projects: grass_database.md
       - Projection and Transformations: projectionintro.md
 
   - Processing Tools:
-      - Raster:
-          - Overview: rasterintro.md
-          - Raster Tools: raster.md
-      - Raster 3D:
-          - Overview: raster3dintro.md
-          - Raster 3D Tools: raster3d.md
-      - Vectors:
-          - Overview: vectorintro.md
-          - Vector Tools: vector.md
-          - Databases Overview: databaseintro.md
-          - Database Tools: database.md
-          - Supported Database Drivers: sql.md
-      - Imagery:
-          - Overview: imageryintro.md
-          - Imagery Tools: imagery.md
-          - GUI Tools:
-              - Image Classification: wxGUI.iclass.md
-      - Temporal:
-          - Overview: temporalintro.md
-          - Temporal: temporal.md
-
-  - Visualization:
+      - Processing Tools: full_index.md
+      - General Tools: general.md
+      - Raster Tools: raster.md
+      - Raster 3D Tools: raster3d.md
+      - Vector Tools: vector.md
+      - Database Tools: database.md
+      - Imagery Tools: imagery.md
+      - Temporal Tools: temporal.md
       - Display Tools: display.md
-      - GUI Tools:
-          - Animation: wxGUI.animation.md
-          - "3D Visualization": wxGUI.nviz.md
-          - Interactive Scatter Plot: wxGUI.iscatt.md
-          - Map Swipe: wxGUI.mapswipe.md
-          - Timeline: wxGUI.timeline.md
-          - Temporal Plot: wxGUI.tplot.md
+      - Postscript Tools: postscript.md
+      - Miscellaneous Tools: miscellaneous.md
 
-  # - Other:
-  #     - Misc: miscellaneous.md
-  #     - Postscript: postscript.md
+  - Development: development_intro.md


Reviews:
user: login: wenzeslaus
state: CHANGES_REQUESTED
author_association: MEMBER
submitted_at: 2025-02-28T04:17:21Z
user: login: wenzeslaus
body: I like the approach!
state: COMMENTED
author_association: MEMBER
submitted_at: 2025-03-01T06:43:58Z
user: login: echoix
state: COMMENTED
author_association: MEMBER
submitted_at: 2025-03-01T10:30:43Z
user: login: cwhite911
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-04T00:37:25Z
user: login: cwhite911
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-04T00:52:16Z
user: login: cwhite911
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-04T01:05:03Z
user: login: petrasovaa
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-05T17:39:52Z
user: login: petrasovaa
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-05T17:41:54Z
user: login: petrasovaa
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-05T17:43:47Z
user: login: petrasovaa
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-05T17:45:53Z
user: login: petrasovaa
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-05T17:46:10Z
user: login: wenzeslaus
body: I improved things like command line and the main intro, but only fixed issues in the large Python documents. Given this is a first draft, I removed the images (2MB after further compression) to save repo space because the images may or may not be used depending on the rewrite. The Python document is little too long (800+ lines of Markdown), so that's one of the things we may want to address as a next step. The Mermaid blocks work on GitHub as well, so the experience is smooth and it's not a big commitment to specific dependency.
state: COMMENTED
author_association: MEMBER
submitted_at: 2025-03-07T19:35:20Z
user: login: petrasovaa
state: APPROVED
author_association: CONTRIBUTOR
submitted_at: 2025-03-07T19:48:09Z
user: login: wenzeslaus
state: APPROVED
author_association: MEMBER
submitted_at: 2025-03-07T20:01:08Z

Review comments:
diff_hunk: @@ -0,0 +1,55 @@
+---
+title: GRASS GIS 8.5.0dev Reference Manual
path: man/mkdocs/index.md
user: login: wenzeslaus
body: Limit hardcoded versions as much as possible.
created_at: 2025-02-28T04:06:49Z
author_association: MEMBER
diff_hunk: @@ -0,0 +1,55 @@
+---
+title: GRASS GIS 8.5.0dev Reference Manual
+author: GRASS Development Team
+---
+
+
+## **What is GRASS?**
path: man/mkdocs/index.md
user: login: wenzeslaus
body: I'm surprised this passes linting, but anyway, is `**` needed?
created_at: 2025-02-28T04:08:19Z
author_association: MEMBER
diff_hunk: @@ -26,6 +26,8 @@ theme:
     - search.suggest
     - search.highlight
     - content.code.copy
+    - content.tabs.link
path: man/mkdocs/mkdocs.yml
user: login: wenzeslaus
body: Can you please separate the tabs into a new PR to get it merged quickly, including the linked tabs option here? I was able to enable the tabs (locally), but the doc (mis)lead me to include some custom JS to keep the tabs in sync and that was not working for me.
created_at: 2025-02-28T04:11:58Z
author_association: MEMBER
diff_hunk: @@ -0,0 +1,9 @@
+MODULE_TOPDIR = ..
+
+include $(MODULE_TOPDIR)/include/Make/Other.make
+
+# So far, we disntinguished user and contributor documentation here by
+# extension. This is no longer possible with Markdown.
path: doc/development/Makefile
user: login: wenzeslaus
body: This is really relevant only for the parent dir, not here.
created_at: 2025-03-01T06:21:28Z
author_association: MEMBER
diff_hunk: @@ -0,0 +1,9 @@
+MODULE_TOPDIR = ..
+
+include $(MODULE_TOPDIR)/include/Make/Other.make
+
+# So far, we disntinguished user and contributor documentation here by
+# extension. This is no longer possible with Markdown.
+MDFILES := github_guide.md style_guide.md
path: doc/development/Makefile
user: login: wenzeslaus
body: Let's move this whole Makefile and the task of publishing development-related Markdown files to another PR or issue.
created_at: 2025-03-01T06:23:43Z
author_association: MEMBER
path: doc/quickstart.md
user: login: wenzeslaus
body: Needs to be removed more. (?)
created_at: 2025-03-01T06:24:47Z
author_association: MEMBER
diff_hunk: @@ -0,0 +1,121 @@
+## What is GRASS?
+
+[GRASS](https://grass.osgeo.org/) is a geosptial processing engine for
+advance analysis and visualization of geospatial data. It is a powerful tool for
+processing and analyzing geospatial data sets. GRASS is a free and open source
+software, released under an open source [GNU GPLed](https://www.gnu.org/licenses/gpl.html).
+
+Downloaded and installed GRASS here.
+
+<!-- markdownlint-disable-next-line MD013 -->
+[:material-download: Download and Install](https://grass.osgeo.org/download/){ .md-button }
+
+## Tutorials
+
+Get started with GRASS by following the
+[tutorials](https://grass-tutorials.osgeo.org/) below.
+
+## Interfaces
+
+GRASS provides a number of interfaces for interacting with the software. The
+most common interfaces are:
+
+### [Terminal](grass.md)
+
+The terminal interface is...
+
+```bash
+
+grass -c EPSG:3385 {project directory} --gtext
+
+Starting GRASS GIS...
+
+          __________  ___   __________    _______________
+         / ____/ __ \/   | / ___/ ___/   / ____/  _/ ___/
+        / / __/ /_/ / /| | \__ \\_  \   / / __ / / \__ \
+       / /_/ / _, _/ ___ |___/ /__/ /  / /_/ // / ___/ /
+       \____/_/ |_/_/  |_/____/____/   \____/___//____/
+
+Welcome to GRASS GIS 8.5.0dev (5ffc9ea669)
+GRASS GIS homepage:                      https://grass.osgeo.org
+This version running through:            Bash Shell (/bin/bash)
+Help is available with the command:      g.manual -i
+See the licence terms with:              g.version -c
+See citation options with:               g.version -x
+If required, restart the GUI with:       g.gui wxpython
+When ready to quit enter:                exit
path: man/mkdocs/index.md
user: login: wenzeslaus
body: Maybe little too many lines? (That output should be shorter, but even a shorter one would still be little too long for here.)
created_at: 2025-03-01T06:27:53Z
author_association: MEMBER
diff_hunk: @@ -0,0 +1,121 @@
+## What is GRASS?
+
+[GRASS](https://grass.osgeo.org/) is a geosptial processing engine for
+advance analysis and visualization of geospatial data. It is a powerful tool for
+processing and analyzing geospatial data sets. GRASS is a free and open source
+software, released under an open source [GNU GPLed](https://www.gnu.org/licenses/gpl.html).
+
+Downloaded and installed GRASS here.
+
+<!-- markdownlint-disable-next-line MD013 -->
+[:material-download: Download and Install](https://grass.osgeo.org/download/){ .md-button }
+
+## Tutorials
+
+Get started with GRASS by following the
+[tutorials](https://grass-tutorials.osgeo.org/) below.
+
+## Interfaces
+
+GRASS provides a number of interfaces for interacting with the software. The
+most common interfaces are:
+
+### [Terminal](grass.md)
+
+The terminal interface is...
+
+```bash
+
+grass -c EPSG:3385 {project directory} --gtext
path: man/mkdocs/index.md
user: login: wenzeslaus
body: ```suggestion
grass -c EPSG:3385 {project directory} --text
```

For true no-GUI experience.
created_at: 2025-03-01T06:28:28Z
author_association: MEMBER
diff_hunk: @@ -0,0 +1,121 @@
+## What is GRASS?
+
+[GRASS](https://grass.osgeo.org/) is a geosptial processing engine for
+advance analysis and visualization of geospatial data. It is a powerful tool for
+processing and analyzing geospatial data sets. GRASS is a free and open source
+software, released under an open source [GNU GPLed](https://www.gnu.org/licenses/gpl.html).
+
+Downloaded and installed GRASS here.
+
+<!-- markdownlint-disable-next-line MD013 -->
+[:material-download: Download and Install](https://grass.osgeo.org/download/){ .md-button }
+
+## Tutorials
+
+Get started with GRASS by following the
+[tutorials](https://grass-tutorials.osgeo.org/) below.
+
+## Interfaces
+
+GRASS provides a number of interfaces for interacting with the software. The
+most common interfaces are:
+
+### [Terminal](grass.md)
+
+The terminal interface is...
+
+```bash
+
+grass -c EPSG:3385 {project directory} --gtext
+
+Starting GRASS GIS...
+
+          __________  ___   __________    _______________
+         / ____/ __ \/   | / ___/ ___/   / ____/  _/ ___/
+        / / __/ /_/ / /| | \__ \\_  \   / / __ / / \__ \
+       / /_/ / _, _/ ___ |___/ /__/ /  / /_/ // / ___/ /
+       \____/_/ |_/_/  |_/____/____/   \____/___//____/
+
+Welcome to GRASS GIS 8.5.0dev (5ffc9ea669)
+GRASS GIS homepage:                      https://grass.osgeo.org
+This version running through:            Bash Shell (/bin/bash)
+Help is available with the command:      g.manual -i
+See the licence terms with:              g.version -c
+See citation options with:               g.version -x
+If required, restart the GUI with:       g.gui wxpython
+When ready to quit enter:                exit
+
+
+GRASS {project directory}/PERMANENT:{Working directory} > 
+
+```
+
+Now you can run GRASS commands in the terminal.
+
+```sh
+g.region raster=elevation
+r.slope.aspect elevation=elevation slope=slope aspect=aspect
+```
+
+### Python Scripts
+
+The `grass.script` module provides a Python interface to GRASS. This allows
+users to write Python scripts to interact with GRASS. The `grass.script` module
path: man/mkdocs/index.md
user: login: wenzeslaus
body: We need to start describing the in-session version grass.script.setup.init.
created_at: 2025-03-01T06:31:19Z
author_association: MEMBER
diff_hunk: @@ -0,0 +1,121 @@
+## What is GRASS?
+
+[GRASS](https://grass.osgeo.org/) is a geosptial processing engine for
+advance analysis and visualization of geospatial data. It is a powerful tool for
+processing and analyzing geospatial data sets. GRASS is a free and open source
+software, released under an open source [GNU GPLed](https://www.gnu.org/licenses/gpl.html).
+
+Downloaded and installed GRASS here.
+
+<!-- markdownlint-disable-next-line MD013 -->
+[:material-download: Download and Install](https://grass.osgeo.org/download/){ .md-button }
+
+## Tutorials
+
+Get started with GRASS by following the
+[tutorials](https://grass-tutorials.osgeo.org/) below.
+
+## Interfaces
+
+GRASS provides a number of interfaces for interacting with the software. The
+most common interfaces are:
+
+### [Terminal](grass.md)
+
+The terminal interface is...
+
+```bash
+
+grass -c EPSG:3385 {project directory} --gtext
+
+Starting GRASS GIS...
+
+          __________  ___   __________    _______________
+         / ____/ __ \/   | / ___/ ___/   / ____/  _/ ___/
+        / / __/ /_/ / /| | \__ \\_  \   / / __ / / \__ \
+       / /_/ / _, _/ ___ |___/ /__/ /  / /_/ // / ___/ /
+       \____/_/ |_/_/  |_/____/____/   \____/___//____/
+
+Welcome to GRASS GIS 8.5.0dev (5ffc9ea669)
+GRASS GIS homepage:                      https://grass.osgeo.org
+This version running through:            Bash Shell (/bin/bash)
+Help is available with the command:      g.manual -i
+See the licence terms with:              g.version -c
+See citation options with:               g.version -x
+If required, restart the GUI with:       g.gui wxpython
+When ready to quit enter:                exit
+
+
+GRASS {project directory}/PERMANENT:{Working directory} > 
+
+```
+
+Now you can run GRASS commands in the terminal.
+
+```sh
+g.region raster=elevation
+r.slope.aspect elevation=elevation slope=slope aspect=aspect
+```
path: man/mkdocs/index.md
user: login: wenzeslaus
body: There is an alternative to this and that's `--exec` which I would say is popular for certain use cases.
created_at: 2025-03-01T06:32:19Z
author_association: MEMBER
diff_hunk: @@ -0,0 +1,121 @@
+## What is GRASS?
+
+[GRASS](https://grass.osgeo.org/) is a geosptial processing engine for
+advance analysis and visualization of geospatial data. It is a powerful tool for
+processing and analyzing geospatial data sets. GRASS is a free and open source
+software, released under an open source [GNU GPLed](https://www.gnu.org/licenses/gpl.html).
+
+Downloaded and installed GRASS here.
+
+<!-- markdownlint-disable-next-line MD013 -->
+[:material-download: Download and Install](https://grass.osgeo.org/download/){ .md-button }
+
+## Tutorials
+
+Get started with GRASS by following the
+[tutorials](https://grass-tutorials.osgeo.org/) below.
+
+## Interfaces
+
+GRASS provides a number of interfaces for interacting with the software. The
+most common interfaces are:
+
+### [Terminal](grass.md)
+
+The terminal interface is...
+
+```bash
+
+grass -c EPSG:3385 {project directory} --gtext
+
+Starting GRASS GIS...
+
+          __________  ___   __________    _______________
+         / ____/ __ \/   | / ___/ ___/   / ____/  _/ ___/
+        / / __/ /_/ / /| | \__ \\_  \   / / __ / / \__ \
+       / /_/ / _, _/ ___ |___/ /__/ /  / /_/ // / ___/ /
+       \____/_/ |_/_/  |_/____/____/   \____/___//____/
+
+Welcome to GRASS GIS 8.5.0dev (5ffc9ea669)
+GRASS GIS homepage:                      https://grass.osgeo.org
+This version running through:            Bash Shell (/bin/bash)
+Help is available with the command:      g.manual -i
+See the licence terms with:              g.version -c
+See citation options with:               g.version -x
+If required, restart the GUI with:       g.gui wxpython
+When ready to quit enter:                exit
+
+
+GRASS {project directory}/PERMANENT:{Working directory} > 
+
+```
+
+Now you can run GRASS commands in the terminal.
+
+```sh
+g.region raster=elevation
+r.slope.aspect elevation=elevation slope=slope aspect=aspect
+```
+
+### Python Scripts
+
+The `grass.script` module provides a Python interface to GRASS. This allows
+users to write Python scripts to interact with GRASS. The `grass.script` module
+contains the gs.script.core module which provides the core functionality for the
+GRASS Python interface, the `grass.script.raster` module which provides
+functionality for working with raster data, and the `grass.script.vector` module
+which provides functionality for working with vector data.
+
+```python
+import grass.script as gs
+
+gs.run_command('g.region', raster='elevation')
+gs.run_command('r.slope.aspect', elevation='elevation', slope='slope', aspect='aspect')
+```
+
+### Jupyter Notebooks
+
+Jupyter Notebooks are a great way to interact with GRASS. The `grass.jupyter`
+module provides a Jupyter interface to GRASS. This allows users to write Jupyter
+Notebooks to interact with GRASS. The `grass.jupyter` module contains the `Map`,
+`InteractiveMap`, `Map3D`, `TimeSeriesMap`, and `SeriesMap` classes which
+provide functionality for working with maps in Jupyter Notebooks.
+
+```python
+import grass.jupyter as gj
+
+slope_map = gj.Map()  # Create a new map
+slope_map.d_rast(map='slope')  # Add the slope raster to the map
+slope_map.d_barscale(at=(80, 10))  # Add a bar scale to the map
+slope_map.d_legend(raster='slope', at=(80, 90))  # Add a legend to the map
+slope_map.show()  # Display the map
+```
+
+![Slope Map](r_slope_aspect_slope.png)
+
+### [GRASS Desktop GUI](wxguiintro.md)
+
+Add content here.
+
+## [Project Management](grass_database.md)
+
+Add Content here.
+
+## Processing Tools
+
+### GRASS Tool Prefixes
+
+| Prefix | Category                         | Description                        | Link                                      |
+|--------|----------------------------------|------------------------------------|-------------------------------------------|
+| `g.`   | General                          | General GIS management tools       | [General Tools](general.md)               |
path: man/mkdocs/index.md
user: login: wenzeslaus
body: Just make this presentation of tool, rather than prefixes.
created_at: 2025-03-01T06:33:30Z
author_association: MEMBER
diff_hunk: @@ -0,0 +1,121 @@
+## What is GRASS?
+
+[GRASS](https://grass.osgeo.org/) is a geosptial processing engine for
+advance analysis and visualization of geospatial data. It is a powerful tool for
+processing and analyzing geospatial data sets. GRASS is a free and open source
+software, released under an open source [GNU GPLed](https://www.gnu.org/licenses/gpl.html).
+
+Downloaded and installed GRASS here.
+
+<!-- markdownlint-disable-next-line MD013 -->
+[:material-download: Download and Install](https://grass.osgeo.org/download/){ .md-button }
+
+## Tutorials
+
+Get started with GRASS by following the
+[tutorials](https://grass-tutorials.osgeo.org/) below.
+
+## Interfaces
+
+GRASS provides a number of interfaces for interacting with the software. The
+most common interfaces are:
+
+### [Terminal](grass.md)
+
+The terminal interface is...
+
+```bash
+
+grass -c EPSG:3385 {project directory} --gtext
+
+Starting GRASS GIS...
+
+          __________  ___   __________    _______________
+         / ____/ __ \/   | / ___/ ___/   / ____/  _/ ___/
+        / / __/ /_/ / /| | \__ \\_  \   / / __ / / \__ \
+       / /_/ / _, _/ ___ |___/ /__/ /  / /_/ // / ___/ /
+       \____/_/ |_/_/  |_/____/____/   \____/___//____/
+
+Welcome to GRASS GIS 8.5.0dev (5ffc9ea669)
+GRASS GIS homepage:                      https://grass.osgeo.org
+This version running through:            Bash Shell (/bin/bash)
+Help is available with the command:      g.manual -i
+See the licence terms with:              g.version -c
+See citation options with:               g.version -x
+If required, restart the GUI with:       g.gui wxpython
+When ready to quit enter:                exit
+
+
+GRASS {project directory}/PERMANENT:{Working directory} > 
+
+```
+
+Now you can run GRASS commands in the terminal.
+
+```sh
+g.region raster=elevation
+r.slope.aspect elevation=elevation slope=slope aspect=aspect
+```
+
+### Python Scripts
+
+The `grass.script` module provides a Python interface to GRASS. This allows
+users to write Python scripts to interact with GRASS. The `grass.script` module
+contains the gs.script.core module which provides the core functionality for the
+GRASS Python interface, the `grass.script.raster` module which provides
+functionality for working with raster data, and the `grass.script.vector` module
+which provides functionality for working with vector data.
+
+```python
+import grass.script as gs
+
+gs.run_command('g.region', raster='elevation')
+gs.run_command('r.slope.aspect', elevation='elevation', slope='slope', aspect='aspect')
+```
+
+### Jupyter Notebooks
+
+Jupyter Notebooks are a great way to interact with GRASS. The `grass.jupyter`
+module provides a Jupyter interface to GRASS. This allows users to write Jupyter
+Notebooks to interact with GRASS. The `grass.jupyter` module contains the `Map`,
+`InteractiveMap`, `Map3D`, `TimeSeriesMap`, and `SeriesMap` classes which
+provide functionality for working with maps in Jupyter Notebooks.
+
+```python
+import grass.jupyter as gj
+
+slope_map = gj.Map()  # Create a new map
+slope_map.d_rast(map='slope')  # Add the slope raster to the map
+slope_map.d_barscale(at=(80, 10))  # Add a bar scale to the map
+slope_map.d_legend(raster='slope', at=(80, 90))  # Add a legend to the map
+slope_map.show()  # Display the map
+```
+
+![Slope Map](r_slope_aspect_slope.png)
+
+### [GRASS Desktop GUI](wxguiintro.md)
+
+Add content here.
+
+## [Project Management](grass_database.md)
+
+Add Content here.
+
+## Processing Tools
path: man/mkdocs/index.md
user: login: wenzeslaus
body: Add link to addons to the end of the section.
created_at: 2025-03-01T06:37:23Z
author_association: MEMBER
diff_hunk: @@ -0,0 +1,121 @@
+## What is GRASS?
+
+[GRASS](https://grass.osgeo.org/) is a geosptial processing engine for
+advance analysis and visualization of geospatial data. It is a powerful tool for
+processing and analyzing geospatial data sets. GRASS is a free and open source
+software, released under an open source [GNU GPLed](https://www.gnu.org/licenses/gpl.html).
+
+Downloaded and installed GRASS here.
+
+<!-- markdownlint-disable-next-line MD013 -->
+[:material-download: Download and Install](https://grass.osgeo.org/download/){ .md-button }
+
+## Tutorials
+
+Get started with GRASS by following the
+[tutorials](https://grass-tutorials.osgeo.org/) below.
+
+## Interfaces
+
+GRASS provides a number of interfaces for interacting with the software. The
+most common interfaces are:
+
+### [Terminal](grass.md)
+
+The terminal interface is...
+
+```bash
+
+grass -c EPSG:3385 {project directory} --gtext
+
+Starting GRASS GIS...
+
+          __________  ___   __________    _______________
+         / ____/ __ \/   | / ___/ ___/   / ____/  _/ ___/
+        / / __/ /_/ / /| | \__ \\_  \   / / __ / / \__ \
+       / /_/ / _, _/ ___ |___/ /__/ /  / /_/ // / ___/ /
+       \____/_/ |_/_/  |_/____/____/   \____/___//____/
+
+Welcome to GRASS GIS 8.5.0dev (5ffc9ea669)
+GRASS GIS homepage:                      https://grass.osgeo.org
+This version running through:            Bash Shell (/bin/bash)
+Help is available with the command:      g.manual -i
+See the licence terms with:              g.version -c
+See citation options with:               g.version -x
+If required, restart the GUI with:       g.gui wxpython
+When ready to quit enter:                exit
+
+
+GRASS {project directory}/PERMANENT:{Working directory} > 
+
+```
+
+Now you can run GRASS commands in the terminal.
+
+```sh
+g.region raster=elevation
+r.slope.aspect elevation=elevation slope=slope aspect=aspect
+```
+
+### Python Scripts
path: man/mkdocs/index.md
user: login: wenzeslaus
body: C doc and possibly general tool writing stuff (standard parser options): I wonder if to put it here as sort of next steps ("is this not enough?") or at the end to a separate section. This would be the usage as a modeling platform.
created_at: 2025-03-01T06:41:26Z
author_association: MEMBER
diff_hunk: @@ -0,0 +1,9 @@
+MODULE_TOPDIR = ..
+
+include $(MODULE_TOPDIR)/include/Make/Other.make
+
+# So far, we disntinguished user and contributor documentation here by
+# extension. This is no longer possible with Markdown.
path: doc/development/Makefile
user: login: echoix
body: ```suggestion
# So far, we distinguished user and contributor documentation here by
# extension. This is no longer possible with Markdown.
```


created_at: 2025-03-01T10:29:19Z
author_association: MEMBER
diff_hunk: @@ -0,0 +1,121 @@
+## What is GRASS?
+
+[GRASS](https://grass.osgeo.org/) is a geosptial processing engine for
+advance analysis and visualization of geospatial data. It is a powerful tool for
+processing and analyzing geospatial data sets. GRASS is a free and open source
+software, released under an open source [GNU GPLed](https://www.gnu.org/licenses/gpl.html).
+
+Downloaded and installed GRASS here.
+
+<!-- markdownlint-disable-next-line MD013 -->
+[:material-download: Download and Install](https://grass.osgeo.org/download/){ .md-button }
+
+## Tutorials
+
+Get started with GRASS by following the
+[tutorials](https://grass-tutorials.osgeo.org/) below.
+
+## Interfaces
+
+GRASS provides a number of interfaces for interacting with the software. The
+most common interfaces are:
+
+### [Terminal](grass.md)
+
+The terminal interface is...
+
+```bash
+
+grass -c EPSG:3385 {project directory} --gtext
+
+Starting GRASS GIS...
+
+          __________  ___   __________    _______________
+         / ____/ __ \/   | / ___/ ___/   / ____/  _/ ___/
+        / / __/ /_/ / /| | \__ \\_  \   / / __ / / \__ \
+       / /_/ / _, _/ ___ |___/ /__/ /  / /_/ // / ___/ /
+       \____/_/ |_/_/  |_/____/____/   \____/___//____/
+
+Welcome to GRASS GIS 8.5.0dev (5ffc9ea669)
+GRASS GIS homepage:                      https://grass.osgeo.org
+This version running through:            Bash Shell (/bin/bash)
+Help is available with the command:      g.manual -i
+See the licence terms with:              g.version -c
+See citation options with:               g.version -x
+If required, restart the GUI with:       g.gui wxpython
+When ready to quit enter:                exit
path: man/mkdocs/index.md
user: login: cwhite911
body: I've change the section.
created_at: 2025-03-04T00:37:25Z
author_association: CONTRIBUTOR
diff_hunk: @@ -26,6 +26,8 @@ theme:
     - search.suggest
     - search.highlight
     - content.code.copy
+    - content.tabs.link
path: man/mkdocs/mkdocs.yml
user: login: cwhite911
body: Yes. Sorry it took me a minute to get back to this.
created_at: 2025-03-04T00:52:15Z
author_association: CONTRIBUTOR
diff_hunk: @@ -26,6 +26,8 @@ theme:
     - search.suggest
     - search.highlight
     - content.code.copy
+    - content.tabs.link
path: man/mkdocs/mkdocs.yml
user: login: cwhite911
body: Here is the PR: https://github.com/OSGeo/grass/pull/5277
created_at: 2025-03-04T01:05:02Z
author_association: CONTRIBUTOR
diff_hunk: @@ -0,0 +1,155 @@
+---
+authors: 
+    - Corey T. White
+    - GRASS Development Team
+title: Getting Started
+---
+
+## What is GRASS?
+
+[GRASS](https://grass.osgeo.org/) is a geosptial processing engine for
+advance analysis and visualization of geospatial data. It is a powerful tool for
+processing and analyzing geospatial data sets. GRASS is a free and open source
+software, released under an open source [GNU GPLed](https://www.gnu.org/licenses/gpl.html).
path: man/mkdocs/index.md
user: login: petrasovaa
body: ```suggestion
[GRASS](https://grass.osgeo.org/) is a geospatial processing engine for
advance analysis and visualization of geospatial data. GRASS is a free and open source
software, released under the [GNU GPL](https://www.gnu.org/licenses/gpl.html).
```
created_at: 2025-03-05T17:39:52Z
author_association: CONTRIBUTOR
diff_hunk: @@ -0,0 +1,155 @@
+---
+authors: 
+    - Corey T. White
+    - GRASS Development Team
+title: Getting Started
+---
+
+## What is GRASS?
+
+[GRASS](https://grass.osgeo.org/) is a geosptial processing engine for
+advance analysis and visualization of geospatial data. It is a powerful tool for
+processing and analyzing geospatial data sets. GRASS is a free and open source
+software, released under an open source [GNU GPLed](https://www.gnu.org/licenses/gpl.html).
+
+Downloaded and installed GRASS here.
+
+<!-- markdownlint-disable-next-line MD013 -->
+[:material-download: Download and Install](https://grass.osgeo.org/download/){ .md-button }
+
+## Interfaces
+
+GRASS provides a number of interfaces for interacting with the software. The
+most common interfaces are:
+
+### Terminal
+
+The terminal interface allows you to start a GRASS session to run GRASS
+commands, execute scripts, or open the GUI.
+
+Here we creating a new project for the NAD83(HARN)/North Carolina coordinate
path: man/mkdocs/index.md
user: login: petrasovaa
body: ```suggestion
Here we create a new project for the NAD83(HARN)/North Carolina coordinate
```
created_at: 2025-03-05T17:41:54Z
author_association: CONTRIBUTOR
diff_hunk: @@ -0,0 +1,155 @@
+---
+authors: 
+    - Corey T. White
+    - GRASS Development Team
+title: Getting Started
+---
+
+## What is GRASS?
+
+[GRASS](https://grass.osgeo.org/) is a geosptial processing engine for
+advance analysis and visualization of geospatial data. It is a powerful tool for
+processing and analyzing geospatial data sets. GRASS is a free and open source
+software, released under an open source [GNU GPLed](https://www.gnu.org/licenses/gpl.html).
+
+Downloaded and installed GRASS here.
+
+<!-- markdownlint-disable-next-line MD013 -->
+[:material-download: Download and Install](https://grass.osgeo.org/download/){ .md-button }
path: man/mkdocs/index.md
user: login: petrasovaa
body: ```suggestion
<!-- markdownlint-disable-next-line MD013 -->
[:material-download: Download GRASS](https://grass.osgeo.org/download/){ .md-button }
```
created_at: 2025-03-05T17:43:47Z
author_association: CONTRIBUTOR
diff_hunk: @@ -0,0 +1,155 @@
+---
+authors: 
+    - Corey T. White
+    - GRASS Development Team
+title: Getting Started
+---
+
+## What is GRASS?
+
+[GRASS](https://grass.osgeo.org/) is a geosptial processing engine for
+advance analysis and visualization of geospatial data. It is a powerful tool for
+processing and analyzing geospatial data sets. GRASS is a free and open source
+software, released under an open source [GNU GPLed](https://www.gnu.org/licenses/gpl.html).
+
+Downloaded and installed GRASS here.
+
+<!-- markdownlint-disable-next-line MD013 -->
+[:material-download: Download and Install](https://grass.osgeo.org/download/){ .md-button }
+
+## Interfaces
+
+GRASS provides a number of interfaces for interacting with the software. The
+most common interfaces are:
+
+### Terminal
path: man/mkdocs/index.md
user: login: petrasovaa
body: ```suggestion
### Command Line
```
created_at: 2025-03-05T17:45:53Z
author_association: CONTRIBUTOR
diff_hunk: @@ -0,0 +1,155 @@
+---
+authors: 
+    - Corey T. White
+    - GRASS Development Team
+title: Getting Started
+---
+
+## What is GRASS?
+
+[GRASS](https://grass.osgeo.org/) is a geosptial processing engine for
+advance analysis and visualization of geospatial data. It is a powerful tool for
+processing and analyzing geospatial data sets. GRASS is a free and open source
+software, released under an open source [GNU GPLed](https://www.gnu.org/licenses/gpl.html).
+
+Downloaded and installed GRASS here.
+
+<!-- markdownlint-disable-next-line MD013 -->
+[:material-download: Download and Install](https://grass.osgeo.org/download/){ .md-button }
+
+## Interfaces
+
+GRASS provides a number of interfaces for interacting with the software. The
+most common interfaces are:
+
+### Terminal
+
+The terminal interface allows you to start a GRASS session to run GRASS
path: man/mkdocs/index.md
user: login: petrasovaa
body: ```suggestion
The command line interface allows you to start a GRASS session to run GRASS
```
created_at: 2025-03-05T17:46:10Z
author_association: CONTRIBUTOR

PR comments:
user: login: cwhite911
created_at: 2025-03-05T02:53:22Z
body: Everything here is still a WIP, but here is a snapshot of the current status.

## Getting Started
![image](https://github.com/user-attachments/assets/b1b6bade-e63a-424a-a390-ace5537d72dd)

## Terminal Overview
![image](https://github.com/user-attachments/assets/f60c6cf7-19f6-4677-820b-1eb7ca9bbcc5)

## Python Overview
![image](https://github.com/user-attachments/assets/6aec3d52-40fc-45bc-b5e1-a0ab51ac55ad)

## Jupyter Overview
![image](https://github.com/user-attachments/assets/b040d7fe-a409-4f7b-9e99-6757511c4462)

## Development
![image](https://github.com/user-attachments/assets/6db8e04c-1f7a-48b7-92ff-f389f95ad3b5)


author_association: CONTRIBUTOR
user: login: cwhite911
created_at: 2025-03-05T18:13:06Z
body: Some more updated screenshots.

## Getting Started

- New Support GRASS button

![image](https://github.com/user-attachments/assets/58d14e94-87a2-4bc3-bc19-c1345c35736d)

## Python Overview

- Added grass.scripts section

![image](https://github.com/user-attachments/assets/32efeeb6-7461-4069-a634-c679e0047a5c)


## Jupyter Notebooks

- Added more text and images

![image](https://github.com/user-attachments/assets/8c2a2c9e-0c77-4de7-b2c7-5558caf59c0e)


author_association: CONTRIBUTOR
user: login: wenzeslaus
created_at: 2025-03-05T20:08:21Z
body: I have nav updates I want to discuss and push to the branch, let's meet.
author_association: MEMBER
user: login: wenzeslaus
created_at: 2025-03-05T20:46:05Z
body: ![image](https://github.com/user-attachments/assets/2aab22e8-af6d-4e48-b0e6-3df8fc86945f)
![image](https://github.com/user-attachments/assets/b22bb425-f9f1-4bd4-bedb-d33e86bd164e)
![image](https://github.com/user-attachments/assets/0a1abeca-5d31-411d-93ef-83c2d4c2c5ef)
![image](https://github.com/user-attachments/assets/46c1e0cf-ae25-48ed-9143-45c0b0cb841d)

author_association: MEMBER
user: login: cwhite911
created_at: 2025-03-06T04:49:29Z
body: Here is a snapshot from the Python section. 

TODOs
- grass.scripts Raster3d, Database
- grass.pygrass: vector and modules are still in progress.
- General clean up: typos, grammer, links
- Design: Finalize layout
- Optional: Improve or remove flow chart at the begin

## Python

![image](https://github.com/user-attachments/assets/ad874611-4134-40b1-bb47-cd9fabdb876f)

author_association: CONTRIBUTOR