diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3cdd0359b9..5206cd95cd 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,6 +7,10 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
 
 ## [Development]
 
+### Docs
+
+* New tutorial on GPU memory management and capacity planning in the GPU section
+
 ## [0.34.17 - 2024-10-20]
 
 ### Added
diff --git a/README.md b/README.md
index d5dd94b921..bdb5422b4c 100644
--- a/README.md
+++ b/README.md
@@ -110,7 +110,7 @@ df = pd.DataFrame({
 g1 = graphistry.edges(df, 'src', 'dst')
 
 # Override styling defaults
-g1_styled = g1.encode_edge_color('friendship', as_continuous=True, ['blue', 'red'])
+g1_styled = g1.encode_edge_color('friendship', ['blue', 'red'], as_continuous=True)
 
 # Connect: Free GPU accounts and self-hosting @ graphistry.com/get-started
 graphistry.register(api=3, username='your_username', password='your_password')
diff --git a/demos/gfql/GPU_memory_consumption_tutorial.ipynb b/demos/gfql/GPU_memory_consumption_tutorial.ipynb
new file mode 100644
index 0000000000..c79fe460f6
--- /dev/null
+++ b/demos/gfql/GPU_memory_consumption_tutorial.ipynb
@@ -0,0 +1,908 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "AnX7LqWMBnpu"
+   },
+   "source": [
+    "# How much GPU RAM do you need and how much data fits into a GPU task?\n",
+    "\n",
+    "## GPU memory size planning & data ratios for Parquet, Arrow, RAPIDS/cuDF, and Graphistry/GFQL\n",
+    "\n",
+    "Put too much data into a GPU or use a GPU without enough memory and things fall apart. Whatever GPU you pick, you may then want to partition your data to make sure it fits, but make partitions too small and now you risk only getting a fraction of the available GPU speedups.\n",
+    "\n",
+    "Achieving high performance with your GPUs often starts with navigating these questions.\n",
+    "\n",
+    "It is surprisingly simple in practice to stay within your GPU memory budget once you understand some common data ratios that occur at basic data pipeline phases.\n",
+    "\n",
+    "Using a representative activity logs dataset, we will work through a typical GPU ETL & analytics pipeline that starts all the way from disk:\n",
+    "\n",
+    "* Parquet (disk, compressed): 0.1-0.5X\n",
+    "* Arrow (CPU, in-memory): 0.2-1X\n",
+    "* **Pandas (CPU, in-memory): 1X <-- baseline**\n",
+    "* cuDF (GPU, in-memory): 0.2-1X\n",
+    "* **GPU compute operations (GPU): 0.2-1X  <-- includes cuDF tabular queries and GFQL graph queries**\n",
+    "* Overall Peak Usage: 1-2X\n",
+    "* Variants: **Multi-GPU**, **multi-node**, and **AI+ML**\n",
+    "\n",
+    "Even before we begin, note that the above ratios already show GPU libraries typically consume a small fraction of the memory required by popular CPU-based libraries like Pandas: They're built with better performance in mind in general, not just because of GPU processing."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "LUbV0yN1Bs8C"
+   },
+   "source": [
+    "# Phase 1: Setup and Data Creation\n",
+    "\n",
+    "(Skip ahead to **The data** if you're just skimming)\n",
+    "\n",
+    "## Installs & imports\n",
+    "\n",
+    "Pandas (CPU), RAPIDS cuDF (GPU), PyGraphistry"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {
+    "id": "Y7BonUbuGg0i"
+   },
+   "outputs": [],
+   "source": [
+    "! pip install -q graphistry"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "J9MZnkKPayUa"
+   },
+   "outputs": [],
+   "source": [
+    "# For freely testing on colab.research.google.com:\n",
+    "\n",
+    "# RAPIDS for Google Colab\n",
+    "# This get the RAPIDS-Colab install files and test check your GPU.  Run this and the next cell only.\n",
+    "# Please read the output of this cell.  If your Colab Instance is not RAPIDS compatible, it will warn you and give you remediation steps.\n",
+    "! git clone -q https://github.com/rapidsai/rapidsai-csp-utils.git\n",
+    "! python rapidsai-csp-utils/colab/pip-install.py > /dev/null 2>&1\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 35
+    },
+    "id": "4nLrk46BllED",
+    "outputId": "9fbb67c3-e95d-43ab-9bfd-369d4cfd07e0"
+   },
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.google.colaboratory.intrinsic+json": {
+       "type": "string"
+      },
+      "text/plain": [
+       "'24.10.01'"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import cudf\n",
+    "cudf.__version__"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {
+    "id": "8JruAVXM9Z8N"
+   },
+   "outputs": [],
+   "source": [
+    "# Initialize RMM with a managed memory pool; this will automatically apply to cuDF allocations.\n",
+    "import cudf\n",
+    "import rmm\n",
+    "import rmm.statistics\n",
+    "rmm.reinitialize(pool_allocator=True, managed_memory=True)\n",
+    "rmm.statistics.enable_statistics()\n",
+    "\n",
+    "# Initialize NVML for direct GPU memory measurement\n",
+    "import pynvml\n",
+    "pynvml.nvmlInit()\n",
+    "handle = pynvml.nvmlDeviceGetHandleByIndex(0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {
+    "id": "ayDVAset9aRP"
+   },
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "import pyarrow as pa\n",
+    "import pyarrow.parquet as pq\n",
+    "import cudf\n",
+    "import graphistry\n",
+    "import matplotlib.pyplot as plt\n",
+    "import os\n",
+    "from graphistry import e, n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "uZBB6MPtB8nE"
+   },
+   "source": [
+    "### The data\n",
+    "One million simulated network traffic connection events with timestamped events (src_ip, dst_ip) representing graph edges\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 241
+    },
+    "id": "AjIecASF9fuh",
+    "outputId": "f2b2d1e6-4c68-4ec1-f944-306038cfa49a"
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "<ipython-input-14-4e913c230e95>:3: FutureWarning: 'S' is deprecated and will be removed in a future version, please use 's' instead.\n",
+      "  \"timestamp\": pd.date_range(start=\"2023-01-01\", periods=rows, freq=\"S\"),\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.google.colaboratory.intrinsic+json": {
+       "type": "dataframe",
+       "variable_name": "df"
+      },
+      "text/html": [
+       "\n",
+       "  <div id=\"df-efd185b4-36f7-47d9-ac81-0ccb4047ed5b\" class=\"colab-df-container\">\n",
+       "    <div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>timestamp</th>\n",
+       "      <th>src_ip</th>\n",
+       "      <th>dst_ip</th>\n",
+       "      <th>event_type</th>\n",
+       "      <th>bytes_transferred</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>2023-01-01 00:00:00</td>\n",
+       "      <td>192.168.1.6</td>\n",
+       "      <td>10.0.0.216</td>\n",
+       "      <td>disconnect</td>\n",
+       "      <td>595</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>2023-01-01 00:00:01</td>\n",
+       "      <td>192.168.1.247</td>\n",
+       "      <td>10.0.0.73</td>\n",
+       "      <td>connect</td>\n",
+       "      <td>754</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>2023-01-01 00:00:02</td>\n",
+       "      <td>192.168.1.244</td>\n",
+       "      <td>10.0.0.32</td>\n",
+       "      <td>connect</td>\n",
+       "      <td>630</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>2023-01-01 00:00:03</td>\n",
+       "      <td>192.168.1.204</td>\n",
+       "      <td>10.0.0.207</td>\n",
+       "      <td>disconnect</td>\n",
+       "      <td>348</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>2023-01-01 00:00:04</td>\n",
+       "      <td>192.168.1.121</td>\n",
+       "      <td>10.0.0.219</td>\n",
+       "      <td>connect</td>\n",
+       "      <td>710</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>\n",
+       "    <div class=\"colab-df-buttons\">\n",
+       "\n",
+       "  <div class=\"colab-df-container\">\n",
+       "    <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-efd185b4-36f7-47d9-ac81-0ccb4047ed5b')\"\n",
+       "            title=\"Convert this dataframe to an interactive table.\"\n",
+       "            style=\"display:none;\">\n",
+       "\n",
+       "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\" viewBox=\"0 -960 960 960\">\n",
+       "    <path d=\"M120-120v-720h720v720H120Zm60-500h600v-160H180v160Zm220 220h160v-160H400v160Zm0 220h160v-160H400v160ZM180-400h160v-160H180v160Zm440 0h160v-160H620v160ZM180-180h160v-160H180v160Zm440 0h160v-160H620v160Z\"/>\n",
+       "  </svg>\n",
+       "    </button>\n",
+       "\n",
+       "  <style>\n",
+       "    .colab-df-container {\n",
+       "      display:flex;\n",
+       "      gap: 12px;\n",
+       "    }\n",
+       "\n",
+       "    .colab-df-convert {\n",
+       "      background-color: #E8F0FE;\n",
+       "      border: none;\n",
+       "      border-radius: 50%;\n",
+       "      cursor: pointer;\n",
+       "      display: none;\n",
+       "      fill: #1967D2;\n",
+       "      height: 32px;\n",
+       "      padding: 0 0 0 0;\n",
+       "      width: 32px;\n",
+       "    }\n",
+       "\n",
+       "    .colab-df-convert:hover {\n",
+       "      background-color: #E2EBFA;\n",
+       "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
+       "      fill: #174EA6;\n",
+       "    }\n",
+       "\n",
+       "    .colab-df-buttons div {\n",
+       "      margin-bottom: 4px;\n",
+       "    }\n",
+       "\n",
+       "    [theme=dark] .colab-df-convert {\n",
+       "      background-color: #3B4455;\n",
+       "      fill: #D2E3FC;\n",
+       "    }\n",
+       "\n",
+       "    [theme=dark] .colab-df-convert:hover {\n",
+       "      background-color: #434B5C;\n",
+       "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
+       "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
+       "      fill: #FFFFFF;\n",
+       "    }\n",
+       "  </style>\n",
+       "\n",
+       "    <script>\n",
+       "      const buttonEl =\n",
+       "        document.querySelector('#df-efd185b4-36f7-47d9-ac81-0ccb4047ed5b button.colab-df-convert');\n",
+       "      buttonEl.style.display =\n",
+       "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
+       "\n",
+       "      async function convertToInteractive(key) {\n",
+       "        const element = document.querySelector('#df-efd185b4-36f7-47d9-ac81-0ccb4047ed5b');\n",
+       "        const dataTable =\n",
+       "          await google.colab.kernel.invokeFunction('convertToInteractive',\n",
+       "                                                    [key], {});\n",
+       "        if (!dataTable) return;\n",
+       "\n",
+       "        const docLinkHtml = 'Like what you see? Visit the ' +\n",
+       "          '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
+       "          + ' to learn more about interactive tables.';\n",
+       "        element.innerHTML = '';\n",
+       "        dataTable['output_type'] = 'display_data';\n",
+       "        await google.colab.output.renderOutput(dataTable, element);\n",
+       "        const docLink = document.createElement('div');\n",
+       "        docLink.innerHTML = docLinkHtml;\n",
+       "        element.appendChild(docLink);\n",
+       "      }\n",
+       "    </script>\n",
+       "  </div>\n",
+       "\n",
+       "\n",
+       "<div id=\"df-2b4121c4-23a3-40bb-9351-4a8b1eb0c364\">\n",
+       "  <button class=\"colab-df-quickchart\" onclick=\"quickchart('df-2b4121c4-23a3-40bb-9351-4a8b1eb0c364')\"\n",
+       "            title=\"Suggest charts\"\n",
+       "            style=\"display:none;\">\n",
+       "\n",
+       "<svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
+       "     width=\"24px\">\n",
+       "    <g>\n",
+       "        <path d=\"M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z\"/>\n",
+       "    </g>\n",
+       "</svg>\n",
+       "  </button>\n",
+       "\n",
+       "<style>\n",
+       "  .colab-df-quickchart {\n",
+       "      --bg-color: #E8F0FE;\n",
+       "      --fill-color: #1967D2;\n",
+       "      --hover-bg-color: #E2EBFA;\n",
+       "      --hover-fill-color: #174EA6;\n",
+       "      --disabled-fill-color: #AAA;\n",
+       "      --disabled-bg-color: #DDD;\n",
+       "  }\n",
+       "\n",
+       "  [theme=dark] .colab-df-quickchart {\n",
+       "      --bg-color: #3B4455;\n",
+       "      --fill-color: #D2E3FC;\n",
+       "      --hover-bg-color: #434B5C;\n",
+       "      --hover-fill-color: #FFFFFF;\n",
+       "      --disabled-bg-color: #3B4455;\n",
+       "      --disabled-fill-color: #666;\n",
+       "  }\n",
+       "\n",
+       "  .colab-df-quickchart {\n",
+       "    background-color: var(--bg-color);\n",
+       "    border: none;\n",
+       "    border-radius: 50%;\n",
+       "    cursor: pointer;\n",
+       "    display: none;\n",
+       "    fill: var(--fill-color);\n",
+       "    height: 32px;\n",
+       "    padding: 0;\n",
+       "    width: 32px;\n",
+       "  }\n",
+       "\n",
+       "  .colab-df-quickchart:hover {\n",
+       "    background-color: var(--hover-bg-color);\n",
+       "    box-shadow: 0 1px 2px rgba(60, 64, 67, 0.3), 0 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
+       "    fill: var(--button-hover-fill-color);\n",
+       "  }\n",
+       "\n",
+       "  .colab-df-quickchart-complete:disabled,\n",
+       "  .colab-df-quickchart-complete:disabled:hover {\n",
+       "    background-color: var(--disabled-bg-color);\n",
+       "    fill: var(--disabled-fill-color);\n",
+       "    box-shadow: none;\n",
+       "  }\n",
+       "\n",
+       "  .colab-df-spinner {\n",
+       "    border: 2px solid var(--fill-color);\n",
+       "    border-color: transparent;\n",
+       "    border-bottom-color: var(--fill-color);\n",
+       "    animation:\n",
+       "      spin 1s steps(1) infinite;\n",
+       "  }\n",
+       "\n",
+       "  @keyframes spin {\n",
+       "    0% {\n",
+       "      border-color: transparent;\n",
+       "      border-bottom-color: var(--fill-color);\n",
+       "      border-left-color: var(--fill-color);\n",
+       "    }\n",
+       "    20% {\n",
+       "      border-color: transparent;\n",
+       "      border-left-color: var(--fill-color);\n",
+       "      border-top-color: var(--fill-color);\n",
+       "    }\n",
+       "    30% {\n",
+       "      border-color: transparent;\n",
+       "      border-left-color: var(--fill-color);\n",
+       "      border-top-color: var(--fill-color);\n",
+       "      border-right-color: var(--fill-color);\n",
+       "    }\n",
+       "    40% {\n",
+       "      border-color: transparent;\n",
+       "      border-right-color: var(--fill-color);\n",
+       "      border-top-color: var(--fill-color);\n",
+       "    }\n",
+       "    60% {\n",
+       "      border-color: transparent;\n",
+       "      border-right-color: var(--fill-color);\n",
+       "    }\n",
+       "    80% {\n",
+       "      border-color: transparent;\n",
+       "      border-right-color: var(--fill-color);\n",
+       "      border-bottom-color: var(--fill-color);\n",
+       "    }\n",
+       "    90% {\n",
+       "      border-color: transparent;\n",
+       "      border-bottom-color: var(--fill-color);\n",
+       "    }\n",
+       "  }\n",
+       "</style>\n",
+       "\n",
+       "  <script>\n",
+       "    async function quickchart(key) {\n",
+       "      const quickchartButtonEl =\n",
+       "        document.querySelector('#' + key + ' button');\n",
+       "      quickchartButtonEl.disabled = true;  // To prevent multiple clicks.\n",
+       "      quickchartButtonEl.classList.add('colab-df-spinner');\n",
+       "      try {\n",
+       "        const charts = await google.colab.kernel.invokeFunction(\n",
+       "            'suggestCharts', [key], {});\n",
+       "      } catch (error) {\n",
+       "        console.error('Error during call to suggestCharts:', error);\n",
+       "      }\n",
+       "      quickchartButtonEl.classList.remove('colab-df-spinner');\n",
+       "      quickchartButtonEl.classList.add('colab-df-quickchart-complete');\n",
+       "    }\n",
+       "    (() => {\n",
+       "      let quickchartButtonEl =\n",
+       "        document.querySelector('#df-2b4121c4-23a3-40bb-9351-4a8b1eb0c364 button');\n",
+       "      quickchartButtonEl.style.display =\n",
+       "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
+       "    })();\n",
+       "  </script>\n",
+       "</div>\n",
+       "\n",
+       "    </div>\n",
+       "  </div>\n"
+      ],
+      "text/plain": [
+       "            timestamp         src_ip      dst_ip  event_type  \\\n",
+       "0 2023-01-01 00:00:00    192.168.1.6  10.0.0.216  disconnect   \n",
+       "1 2023-01-01 00:00:01  192.168.1.247   10.0.0.73     connect   \n",
+       "2 2023-01-01 00:00:02  192.168.1.244   10.0.0.32     connect   \n",
+       "3 2023-01-01 00:00:03  192.168.1.204  10.0.0.207  disconnect   \n",
+       "4 2023-01-01 00:00:04  192.168.1.121  10.0.0.219     connect   \n",
+       "\n",
+       "   bytes_transferred  \n",
+       "0                595  \n",
+       "1                754  \n",
+       "2                630  \n",
+       "3                348  \n",
+       "4                710  "
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "rows = 1_000_000\n",
+    "data = {\n",
+    "    \"timestamp\": pd.date_range(start=\"2023-01-01\", periods=rows, freq=\"S\"),\n",
+    "    \"src_ip\": np.random.choice([f\"192.168.1.{i}\" for i in range(1, 256)], rows),\n",
+    "    \"dst_ip\": np.random.choice([f\"10.0.0.{i}\" for i in range(1, 256)], rows),\n",
+    "    \"event_type\": np.random.choice([\"connect\", \"disconnect\", \"data_transfer\"], rows),\n",
+    "    \"bytes_transferred\": np.random.randint(0, 1000, rows),\n",
+    "}\n",
+    "df = pd.DataFrame(data)\n",
+    "df.head()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "FO2j6eCUB_e2"
+   },
+   "source": [
+    "## Phase 2: Measure space usage on-disk with Parquet and CPU in-memory with Pandas\n",
+    "\n",
+    "### 4X CPU in-memory compaction with Arrow\n",
+    "\n",
+    "The Apache Arrow in-memory computing table format makes analytics fast by **packing data into typed columns** (vs typical row-wise SQL, KV, graph, and log databases). A typical benefit is data also getting smaller\n",
+    "\n",
+    "### 20X disk compaction with Parquet\n",
+    "\n",
+    "Parquet adds **compression algorithms for each column**, giving another 5X multiple over Arrow\n",
+    "\n",
+    "Both Parquet and Arrow have their place. Arrow avoids compression for in-memory use to enable faster in-memory access. Parquet prioritizes compression for better disk storage."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "t9Tb3rlp9p0n",
+    "outputId": "6fe38e72-07e1-4f66-9516-84e53a649326"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Pandas in-memory size: 209.00 MB\n",
+      "Arrow in-memory size: 57.36 MB\n",
+      "Parquet compressed size on disk: 9.57 MB\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Pandas Dataframe size\n",
+    "pandas_memory = df.memory_usage(index=True, deep=True).sum() / (1024**2)\n",
+    "\n",
+    "# Arrow Table size\n",
+    "arrow_table = pa.Table.from_pandas(df)\n",
+    "arrow_size = arrow_table.nbytes / (1024**2)\n",
+    "\n",
+    "# Parquet compressed size\n",
+    "pq_file_path = \"compressed_data.parquet\"\n",
+    "pq.write_table(arrow_table, pq_file_path, compression=\"SNAPPY\")\n",
+    "parquet_size = os.path.getsize(pq_file_path) / (1024**2)\n",
+    "\n",
+    "print(f\"Pandas in-memory size: {pandas_memory:.2f} MB\")\n",
+    "print(f\"Arrow in-memory size: {arrow_size:.2f} MB\")\n",
+    "print(f\"Parquet compressed size on disk: {parquet_size:.2f} MB\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "9O2WNshICBt3"
+   },
+   "source": [
+    "## Phase 3: Load data into the GPU with cuDF and PyGraphistry\n",
+    "\n",
+    "### 4X GPU compaction with cuDF\n",
+    "\n",
+    "`cuDF` is an open source GPU-based dataframe library that matches the Pandas API. Note that cuDF is Arrow-native, so the estimated GPU memory consumption exactly matches Apache Arrow. It maintains the 4X improvement over Pandas even without doing any compute.\n",
+    "\n",
+    "### 4X GPU compaction with PyGraphistry\n",
+    "\n",
+    "Graph users can automate transfering a graph's tables to the GPU via [g2 = g1.to_cudf()](https://pygraphistry.readthedocs.io/en/latest/api/compute.html#graphistry.compute.ComputeMixin.ComputeMixin.to_cudf), reaping the same benefits over a Pandas-based approach."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "a2GZAzsP9tLJ",
+    "outputId": "ed8bf972-9a54-4c99-91e4-8bf01578bc53"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Total gdf size in memory: 57.36 MB\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Convert DataFrame to cuDF for operations\n",
+    "gdf = cudf.from_pandas(df)\n",
+    "\n",
+    "# Calculate the size of the gdf in memory\n",
+    "gdf_size_bytes = gdf.memory_usage(deep=True).sum()\n",
+    "gdf_size_mb = gdf_size_bytes / (1024**2)  # Convert bytes to MB\n",
+    "print(f\"Total gdf size in memory: {gdf_size_mb:.2f} MB\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "### Pack in 10X+ more data for real workloads with GPU projections and higher CPU RAM\n",
+    "\n",
+    "It is convenient to move the entire dataframe to the GPU when there is a lot of room, so we recommend doing that during prototyping.\n",
+    "\n",
+    "However, 10X+ bigger workloads can often be easily handled on the same GPU just by mindful of which columns to use at the beginning:\n",
+    "\n",
+    "```python\n",
+    "    # Only transfer 2 columns from df to the GPU\n",
+    "    df2 = cudf.from_pandas(df[['src_ip', 'dst_ip']])\n",
+    "```\n",
+    "\n",
+    "CPU RAM is often cheaper than GPU RAM, so you may want your CPU to have 1-4X more RAM than your GPUs\n",
+    "\n",
+    "### Off-GPU IO Speeds\n",
+    "\n",
+    "To handle bigger-than-memory datasets, it helps to keep in mind that data travels through different speed devices as it goes through disk to GPU:\n",
+    "\n",
+    "It helps to pair your GPU RAM with even more (cheaper) CPU RAM or disk:\n",
+    "* Individual SSDs can do 1-5 GB/s, and arrays of them can do 100GB+/s\n",
+    "* Consumer speeds for disk->CPU and CPU->GPU are around 32 GB/s per 1-2 GPUs via PCIe 4.0\n",
+    "* Server-grade are often PCIe 5.0 at 64 GB/s per 1-2 GPUs\n",
+    "\n",
+    "For advanced setups, such as for going at 100 GB/s on 1-2 GPUs, see our recorded Dask Summit talk on [100GB/s GPU Log Analytics at Graphistry](https://www.youtube.com/watch?v=8ZMzsTbfImU). It reviews broad concepts, architecture, and tricks like skipping the convoluted CPU path via [GPU Direct](https://developer.nvidia.com/gpudirect).\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "x_DJXrTFCELq"
+   },
+   "source": [
+    "## Phase 4: GPU Computation - Simple Task and GFQL Traversal\n",
+    "\n",
+    "CPU and GPU programs need extra memory on top of the input data structure memory in order to create intermediate data structures. This is often 1-5X the input data size.\n",
+    "\n",
+    "### Step A: Simple GPU computation for memory baseline\n",
+    "\n",
+    "We see simple `cuDF` dataframe methods like filtering and joining are optimized, so both take < 1X the original input size. Later, however, we will see peek is multiples higher."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "A-dqwB8fEFGM",
+    "outputId": "9937d466-7d0b-4a02-b34d-3a1e778f59a0"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Filter & Sum Operation Memory Peak:  31.16 MB\n",
+      "Join Operation on Subset Memory Peak:  47.92 MB\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Synchronize to ensure a clean memory state before starting\n",
+    "cudf.cuda.current_context().synchronize()\n",
+    "\n",
+    "with rmm.statistics.profiler(name=\"Filter and Sum Operation\"):\n",
+    "    filtered = gdf[gdf[\"event_type\"] == \"data_transfer\"]\n",
+    "    total_bytes = filtered[\"bytes_transferred\"].sum()\n",
+    "\n",
+    "subset_gdf = gdf.head(10000)  # Smaller subset to avoid large memory requirements\n",
+    "with rmm.statistics.profiler(name=\"Join Operation on Subset\"):\n",
+    "    joined = subset_gdf.merge(subset_gdf, on=\"src_ip\", how=\"inner\")\n",
+    "\n",
+    "\n",
+    "filter_sum_stats = rmm.statistics.default_profiler_records.records[\"Filter and Sum Operation\"]\n",
+    "filter_sum_peak_mb = filter_sum_stats.memory_peak / (1024**2)\n",
+    "print(f\"Filter & Sum Operation Memory Peak: {filter_sum_peak_mb: .2f} MB\")\n",
+    "\n",
+    "join_stats = rmm.statistics.default_profiler_records.records[\"Join Operation on Subset\"]\n",
+    "join_peak_mb = join_stats.memory_peak / (1024**2)\n",
+    "print(f\"Join Operation on Subset Memory Peak: {join_peak_mb: .2f} MB\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "S-fDu2YkCG8L"
+   },
+   "source": [
+    "### Step B: GPU Graph analytics with GFQL - 2-hop Traversal\n",
+    "\n",
+    "The example below is a 2-hop traversal in PyGraphistry's GFQL in `cuDF` GPU engine mode, including filtering for \"data_transfer\" events and >500 bytes\n",
+    "\n",
+    "Graph queries are more like a sequence of database operators, so unsurprisingly, so we see not only the speed benefits of `cuDF` but the memory benefits too. The memory is essentially the sum of the optimized operators used.\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "MbsM-G0r_NI3",
+    "outputId": "e169e94e-697b-4510-8537-718e1a4e4d51"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "GFQL 2-hop Traversal Memory Peak:  80.58 MB\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Step 4: Profile the GFQL 2-hop Traversal\n",
+    "g1 = graphistry.edges(gdf, 'src_ip', 'dst_ip')  # Example edge specification for Graphistry\n",
+    "with rmm.statistics.profiler(name=\"GFQL 2-hop Traversal\"):\n",
+    "    g2 = g1.chain([\n",
+    "        n(),\n",
+    "        e(edge_match={'event_type': 'data_transfer'},\n",
+    "          edge_query=\"bytes_transferred > 500\"),\n",
+    "        n()\n",
+    "    ])\n",
+    "\n",
+    "gfql_stats = rmm.statistics.default_profiler_records.records[\"GFQL 2-hop Traversal\"]\n",
+    "gfql_peak_mb = gfql_stats.memory_peak / (1024**2)\n",
+    "print(f\"GFQL 2-hop Traversal Memory Peak: {gfql_peak_mb: .2f} MB\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "vyiNm_i0CMR_"
+   },
+   "source": [
+    "## Comparison chart\n",
+    "\n",
+    "Let's put it all together to see each phase side by side: dataset sizes, and extra intermediate memory\n",
+    "\n",
+    "Fascinatingly, the GPU version was able to do both store the data and and compute on it while taking less memory than the Pandas needed to just make the initial data structure without yet doing anything on top\n",
+    "\n",
+    "In a large-scale production scenario, we would likely aim for another 10X+ by being targeted on which columns to put on the GPU and when to retire intermediate structures"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 807
+    },
+    "id": "CHRekjjdRDnK",
+    "outputId": "12d4ad7e-c585-4445-f253-190c9785badf"
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1400x800 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "\n",
+    "# Labels and sizes for the bar chart\n",
+    "labels = [\n",
+    "    'Parquet (disk)',\n",
+    "    'Arrow (in-mem)',\n",
+    "    'Pandas (in-mem)',\n",
+    "    'cuDF (GPU)',\n",
+    "    '+ Filter & Sum (GPU)',\n",
+    "    '+ Join (GPU)',\n",
+    "    '+ GFQL 2-hop (GPU)',\n",
+    "    'Overall Peak (GPU)'\n",
+    "]\n",
+    "sizes = [\n",
+    "    parquet_size,\n",
+    "    arrow_size,\n",
+    "    pandas_memory,\n",
+    "    gdf_size_mb,\n",
+    "    filter_sum_peak_mb,\n",
+    "    join_peak_mb,\n",
+    "    gfql_peak_mb,\n",
+    "    overall_peak_mb\n",
+    "]\n",
+    "\n",
+    "colors = ['#1f77b4', '#6baed6', '#9ecae1', '#2ca02c', '#ff7f0e', '#9467bd', '#8c564b', '#000000']\n",
+    "\n",
+    "plt.figure(figsize=(14, 8))\n",
+    "bars = plt.bar(labels, sizes, color=colors, edgecolor='black')\n",
+    "\n",
+    "# Add labels and title with a modern font size\n",
+    "plt.ylabel('Memory Usage (MB)', fontsize=14)\n",
+    "plt.title('Memory Usage Comparison', fontsize=16, fontweight='bold')\n",
+    "plt.xticks(rotation=45, ha=\"right\", fontsize=12)  # Rotate and size labels for readability\n",
+    "plt.yticks(fontsize=12)  # Increase y-axis label font size for consistency\n",
+    "plt.tight_layout()\n",
+    "\n",
+    "# Add value labels on top of each bar with a cleaner font style\n",
+    "for bar, size in zip(bars, sizes):\n",
+    "    plt.text(\n",
+    "        bar.get_x() + bar.get_width() / 2,\n",
+    "        bar.get_height(),\n",
+    "        f'{size:.2f} MB',\n",
+    "        ha='center',\n",
+    "        va='bottom',\n",
+    "        fontsize=11,\n",
+    "        fontweight='medium',\n",
+    "        color='darkblue'  # Softer label color for contrast\n",
+    "    )\n",
+    "\n",
+    "# Display the plot\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "NOIMAt0XMiWo"
+   },
+   "source": [
+    "## Takeaways, multi-GPU/multi-node, and ML+AI\n",
+    "\n",
+    "The chart reveals several key understandings:\n",
+    "\n",
+    "### Parquet is a great on-disk format\n",
+    "\n",
+    "It is great at compressing big tables, taking a fraction of the in-memory dataset representations\n",
+    "\n",
+    "### The RAPIDS (cuDF) is a great in-memory format\n",
+    "\n",
+    "Its initial GPU memory allocation sizes matches the Apache Arrow CPU in-memory size\n",
+    "\n",
+    "### Memory consumption is a multiple over the input data siz\n",
+    "\n",
+    "Computing takes extra space. 1X-5X additional GPU RAM was needed to compute on the dataframe than just storing it.\n",
+    "\n",
+    "### Single-GPU\n",
+    "\n",
+    "We recommend assuming 10X+ in-memory size needed than the size of compressed Parquet on disk\n",
+    "\n",
+    "### Multi-GPU, bigger-than-memory, & dask-cudf\n",
+    "\n",
+    "When manually chunking big datasets, such as for bigger-than-memory compute or spreading data across multiple GPUs, or automatically via Dask, we generally recommend 1GB+ chunks. This is~10X bigger than CPU Dask tasks because GPUs are more throughput-oriented in general.  You can see our Dask Distributed Summit talk on [100GB/s GPU Log Analytics at Graphistry](https://www.youtube.com/watch?v=8ZMzsTbfImU) for more methodology here\n",
+    "\n",
+    "### AI/ML Workloads\n",
+    "\n",
+    "Modern data science libraries like PyGraphistry's [g.umap()](https://pygraphistry.readthedocs.io/en/latest/gfql/combo.html#umap-fit-transform-for-scaling) use GPUs and learning to scale:\n",
+    "\n",
+    "#### Training\n",
+    "\n",
+    "Often called `fit()`, GPU systems can often make AI/ML training phases handle 10X more data within your time budgets. As you generally do not train on all your data, this means a 10X+ bigger sample set for a higher-fidelity and more representative model.\n",
+    "\n",
+    "#### Inferencing\n",
+    "\n",
+    "Often called `transform()`, inference applies a trained model to the rest of your data. This is more scalable than fitting your entire data, so a massive speedup. With GPUs, this goes faster too, essentially matching your GPU budget.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "a0c5WPXeSBa6"
+   },
+   "source": [
+    "\n",
+    "## Next steps\n",
+    "\n",
+    "We're preparing follow-on articles on more performance intuitions in general and deeper on the technologies discussed here, including how to more carefully measure your own workloads\n",
+    "\n",
+    "Meanwhile, you may find these useful as well:\n",
+    "\n",
+    "* [100GB/s GPU Log Analytics at Graphistry](https://www.youtube.com/watch?v=8ZMzsTbfImU) recorded talk at Dask Distributed Summit\n",
+    "* [PyGraphistry](https://pygraphistry.readthedocs.io/en/latest/10min.html) GPU-accelerated visual graph analytics\n",
+    "* [PyGraphistry GPU umap()](https://pygraphistry.readthedocs.io/en/latest/gfql/combo.html#umap-fit-transform-for-scaling) for visual graph AI\n",
+    "* The open source [GFQL dataframe-native graph query language](https://pygraphistry.readthedocs.io/en/latest/gfql/index.html) with optional GPU mode\n",
+    "* Try for yourself at [Graphistry Hub](https://www.graphistry.com/get-started)\n",
+    "\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "accelerator": "GPU",
+  "colab": {
+   "provenance": []
+  },
+  "kernelspec": {
+   "display_name": "Python 3",
+   "name": "python3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
diff --git a/docs/source/notebooks/gpu.rst b/docs/source/notebooks/gpu.rst
index a57ee7ec2f..52293d5575 100644
--- a/docs/source/notebooks/gpu.rst
+++ b/docs/source/notebooks/gpu.rst
@@ -10,3 +10,4 @@ GPU
    GPU II: cuDF <../demos/demos_databases_apis/gpu_rapids/part_ii_gpu_cudf.ipynb>
    GPU IV: cuML UMAP <../demos/demos_databases_apis/gpu_rapids/part_iv_gpu_cuml.ipynb>
    GPU V: cuGraph <../demos/demos_databases_apis/gpu_rapids/cugraph.ipynb>
+   GPU Memory Planning <../demos/gfql/GPU_memory_consumption_tutorial.ipynb>