diff --git a/docs/architecture/glances-v5-architecture-decisions.md b/docs/architecture/glances-v5-architecture-decisions.md
index 5d8f388b..3204e161 100644
--- a/docs/architecture/glances-v5-architecture-decisions.md
+++ b/docs/architecture/glances-v5-architecture-decisions.md
@@ -1236,8 +1236,42 @@ curses surface — as its own owned group. No implementation in parity wave 1
   cannot avoid** — the TUI shows the path prefix only when
   `os.path.isdir(path)` holds (`render_curses_v5.py:329`), and a browser has
   no filesystem, so it shows the prefix whenever `cmdline[0]` carried one.
-- **The 9 remaining data-type toggles** (`b`/`B` byte/bit, `%`, `S`, …), plus
-  `F` (fs free space), moved here from the show/hide line above.
+- **The data-type toggles** (2.X-c, 2026-09-22). **Six of the nine shipped**,
+  on both surfaces, plus `F` (fs free space) which moved here from the
+  show/hide line above. Three are blocked, and NONE of the three is a hotkey
+  problem — the key is one table entry either way; what is missing is the
+  second render mode's DATA.
+
+  Shipped because v5 already rendered both modes, so the key was the whole
+  feature: `b` (network bit/s ↔ byte/s), `6` (GPU per-card ↔ mean), `F`
+  (filesystem used ↔ free).
+
+  Shipped after writing the second mode, the data being already collected:
+  `B` (disk I/O byte/s ↔ IOPS — `read_count`/`write_count` were collected and
+  `internal`, and now carry the `IOR/s`/`IOW/s` short names v4 uses), `0`
+  (load average ↔ Irix percentage — `cpucore` was collected and `internal`),
+  `T` (network Rx/Tx apart ↔ combined).
+
+  `T` carries a deliberate divergence in route, not in value: v4 renders a
+  `bytes_all` field its model computes; v5's schema has no such field, so both
+  renderers sum the two rates they already have. The sum of two rates over one
+  interval is the combined rate.
+
+  **Blocked, each needing model or infrastructure work first:**
+  - `U` (network live ↔ cumulative) — `_transform_gauge`
+    (`plugins/plugin/base_v5.py`) REPLACES a counter with its rate and keeps
+    the raw value only in `_raw_previous`. Exposing it is a field-contract
+    change to the REST payload, not a renderer change.
+  - `L` (disk I/O byte/s ↔ latency) — `read_time`/`write_time` are not
+    collected at all, explicitly deferred (`diskio/model_v5.py`).
+  - `S` (quicklook bar ↔ sparkline) — no v5 history store
+    (`quicklook/model_v5.py`).
+
+  `F` needed a shape neither group had used: `[fs] free_space` is plugin
+  CONFIG and reaches the renderer as payload metadata, so the TUI's ViewState
+  field is tri-state (`None` = follow the payload) and the browser seeds it
+  from the fs payload rather than from `serverArgs`, which carries only the
+  CLI flag and reads `false` for a config-set `true`.
 - **`F5` / `Ctrl-R`** forced refresh and the sort-navigation arrow keys.
 
 The `ViewState` mechanism this group builds on already exists
diff --git a/glances/outputs/glances_curses_v5.py b/glances/outputs/glances_curses_v5.py
index 59bb8ef7..4ff1cb7d 100644
--- a/glances/outputs/glances_curses_v5.py
+++ b/glances/outputs/glances_curses_v5.py
@@ -142,6 +142,9 @@ class ViewState:
     # flipped by their keys.
     byte: bool = False
     meangpu: bool = False
+    diskio_iops: bool = False
+    load_irix: bool = False
+    network_sum: bool = False
     # Tri-state, unlike the two above: `[fs] free_space` lives in the fs
     # plugin's CONFIG and reaches the renderer as payload metadata, not as a
     # constructor argument the TUI could seed from. `None` therefore means
@@ -236,6 +239,9 @@ class TuiV5(threading.Thread):
         # through the per-cycle `view` dict.
         "b": {"switch": "byte", "group": "TOGGLE VIEW", "desc": "Network I/O in bit/s or byte/s"},
         "6": {"switch": "meangpu", "group": "TOGGLE VIEW", "desc": "GPU: per-card or mean"},
+        "B": {"switch": "diskio_iops", "group": "TOGGLE VIEW", "desc": "Disk I/O in byte/s or IOPS"},
+        "0": {"switch": "load_irix", "group": "TOGGLE VIEW", "desc": "Load average or Irix percentage"},
+        "T": {"switch": "network_sum", "group": "TOGGLE VIEW", "desc": "Network Rx/Tx apart or combined"},
         # Tri-state, so it cannot be a plain `switch`: `None` means "follow
         # `[fs] free_space`", which is why it has its own verb.
         "F": {"action": "fs_free_space", "group": "TOGGLE VIEW", "desc": "Filesystem: used or free space"},
@@ -939,6 +945,9 @@ class TuiV5(threading.Thread):
         view["fahrenheit"] = self._fahrenheit
         view["hide_public_info"] = self._hide_public_info
         view["byte"] = self._view.byte
+        view["diskio_iops"] = self._view.diskio_iops
+        view["load_irix"] = self._view.load_irix
+        view["network_sum"] = self._view.network_sum
         # Only published when the viewer has pressed `F`; absent means the fs
         # renderer keeps reading its payload metadata.
         if self._view.fs_free_space is not None:
diff --git a/glances/outputs/static/js/v5/PluginDiskio.vue b/glances/outputs/static/js/v5/PluginDiskio.vue
index 4236d17e..cf919bd1 100644
--- a/glances/outputs/static/js/v5/PluginDiskio.vue
+++ b/glances/outputs/static/js/v5/PluginDiskio.vue
@@ -4,7 +4,7 @@
 			<!-- The TUI's header row: block title, then the schema's labels. -->
 			<tr>
 				<th class="gl-header">{{ TITLE }}</th>
-				<th v-for="field in RATE_FIELDS" :key="field" class="gl-header gl-num">
+				<th v-for="field in rateFields" :key="field" class="gl-header gl-num">
 					{{ labelFor(labels, field) }}
 				</th>
 			</tr>
@@ -16,8 +16,8 @@
 					<td>
 						<span class="gl-name gl-truncate gl-truncate-start" :title="nameOf(item)"><bdi>{{ nameOf(item) }}</bdi></span>
 					</td>
-					<td v-for="field in RATE_FIELDS" :key="field" class="gl-num">
-						<span :class="cellClassFor(payload, item, field)">{{ formatBytes(item[field]) }}</span>
+					<td v-for="field in rateFields" :key="field" class="gl-num">
+						<span :class="cellClassFor(payload, item, field)">{{ formatCell(item[field]) }}</span>
 					</td>
 				</tr>
 			</tbody>
@@ -26,7 +26,7 @@
 </template>
 
 <script>
-import { formatBytes } from "./format.js";
+import { formatBytes, formatIops } from "./format.js";
 import { labelFor } from "./labels.js";
 import { cellClassFor } from "./columns.js";
 import { byText, displayName } from "./rows.js";
@@ -34,6 +34,10 @@ import CollectionBlock from "./CollectionBlock.vue";
 import { PLUGIN_PROPS } from "./plugin_props.js";
 
 const RATE_FIELDS = ["read_bytes", "write_bytes"];
+// The `B` key (v4 `_handle_diskio_iops`): operations per second instead of
+// byte rates. Same two columns, a different pair of fields -- and the labels
+// come from the schema, so swapping the pair swaps the header too.
+const IOPS_FIELDS = ["read_count", "write_count"];
 
 const TITLE = "DISK I/O";
 
@@ -46,18 +50,35 @@ export default {
 		// A computed, not data(): data() would hand the template a deeply
 		// reactive Proxy of the array.
 		RATE_FIELDS: () => RATE_FIELDS,
+		// The `B` key, through AppShell's `effectiveArgs`.
+		iops() {
+			return !!this.serverArgs.diskio_iops;
+		},
+		rateFields() {
+			return this.iops ? IOPS_FIELDS : RATE_FIELDS;
+		},
 		// Mirrors diskio/render_curses_v5.py:109-122: sorted by raw disk_name;
 		// skip a row hide_zero still hides, a disk with no rate yet (cycle 1),
 		// and a nameless one. Byte rates without "/s", the header carries it.
 		rows() {
 			return (this.payload?.data || [])
-				.filter((item) => item.hidden !== true && item.read_bytes != null && item.write_bytes != null && item.disk_name)
+				.filter(
+					(item) =>
+						item.hidden !== true &&
+						this.rateFields.every((field) => item[field] != null) &&
+						item.disk_name
+				)
 				.sort(byText("disk_name"));
 		},
 	},
 	methods: {
 		labelFor,
 		cellClassFor,
+		// Byte rates and operation counts scale differently (1024 vs 1000) and
+		// only one carries a unit -- see formatIops in format.js.
+		formatCell(value) {
+			return this.iops ? formatIops(value) : formatBytes(value);
+		},
 		formatBytes,
 		nameOf(item) {
 			return displayName(item, "disk_name");
diff --git a/glances/outputs/static/js/v5/PluginLoad.vue b/glances/outputs/static/js/v5/PluginLoad.vue
index 9002557d..5b9f3dee 100644
--- a/glances/outputs/static/js/v5/PluginLoad.vue
+++ b/glances/outputs/static/js/v5/PluginLoad.vue
@@ -45,9 +45,17 @@ export default {
 			return typeof cores === "number" && cores > 0 ? `${Math.trunc(cores)}core` : "";
 		},
 		rows() {
+			// The `0` key (v4 `args.disable_irix`, issue #1554): each average
+			// divided by the core count and shown as a percentage. Mirrors
+			// load/render_curses_v5.py::_load_value_cell, including its guard --
+			// an absent or zero `cpucore` falls back to the plain float rather
+			// than dividing by zero.
+			const cores = this.payload?.cpucore;
+			const irix = !!this.serverArgs.load_irix && typeof cores === "number" && cores > 0;
 			return FIELDS.map((field) => {
 				const value = this.payload?.[field];
-				return { field, value: typeof value === "number" ? value.toFixed(2) : "-" };
+				if (typeof value !== "number") return { field, value: "-" };
+				return { field, value: irix ? `${((value / cores) * 100).toFixed(1)}%` : value.toFixed(2) };
 			});
 		},
 	},
diff --git a/glances/outputs/static/js/v5/PluginNetwork.vue b/glances/outputs/static/js/v5/PluginNetwork.vue
index e8893be3..8fb7a499 100644
--- a/glances/outputs/static/js/v5/PluginNetwork.vue
+++ b/glances/outputs/static/js/v5/PluginNetwork.vue
@@ -6,7 +6,8 @@
 			shows no line, as the TUI paints its header. -->
 			<tr>
 				<th class="gl-header">{{ TITLE }}</th>
-				<th v-for="field in RATE_FIELDS" :key="field" class="gl-header gl-num">
+				<th v-if="combined" class="gl-header gl-num" colspan="2">{{ combinedLabel }}</th>
+				<th v-for="field in combined ? [] : RATE_FIELDS" :key="field" class="gl-header gl-num">
 					{{ labelFor(labels, field) }}
 				</th>
 			</tr>
@@ -22,7 +23,14 @@
 					</td>
 					<!-- The tier goes on the <span>, not the <td>: a prominent badge's
 					background would otherwise fill the whole cell. -->
-					<td v-for="field in RATE_FIELDS" :key="field" class="gl-num">
+					<!-- `T` (v4 `network_sum`): one combined column. No tier class --
+					the two fields carry their own levels and a sum belongs to
+					neither, which is why the TUI paints its combined cell plain
+					too. -->
+					<td v-if="combined" class="gl-num" colspan="2">
+						<span>{{ formatNetworkRate(rxPlusTx(item), !!serverArgs.byte) }}</span>
+					</td>
+					<td v-for="field in combined ? [] : RATE_FIELDS" :key="field" class="gl-num">
 						<span :class="cellClassFor(payload, item, field)">{{
 							formatNetworkRate(item[field], !!serverArgs.byte)
 						}}</span>
@@ -55,6 +63,15 @@ export default {
 		// A computed, not data(): data() would hand the template a deeply
 		// reactive Proxy of the array.
 		RATE_FIELDS: () => RATE_FIELDS,
+		// The `T` key, through AppShell's `effectiveArgs`.
+		combined() {
+			return !!this.serverArgs.network_sum;
+		},
+		// v4's own label for the mode (`network/__init__.py:246-254`): the
+		// "/s" is dropped under --byte there too.
+		combinedLabel() {
+			return this.serverArgs.byte ? "Rx+Tx" : "Rx+Tx/s";
+		},
 		// Mirrors network/render_curses_v5.py:129-142: skip a down interface
 		// (v4 #765), one hide_zero still hides, and one with no rate yet (cycle
 		// 1). Payload order -- the TUI does not sort this block.
@@ -66,6 +83,12 @@ export default {
 		},
 	},
 	methods: {
+		// v5 has no `bytes_all` field (v4's model computes one); summing the
+		// two rates the payload already carries gives the same number over the
+		// same interval. Mirrors network/render_curses_v5.py.
+		rxPlusTx(item) {
+			return Number(item.bytes_recv) + Number(item.bytes_sent);
+		},
 		labelFor,
 		cellClassFor,
 		formatNetworkRate,
diff --git a/glances/outputs/static/js/v5/format.js b/glances/outputs/static/js/v5/format.js
index 71401466..fe5a4a08 100644
--- a/glances/outputs/static/js/v5/format.js
+++ b/glances/outputs/static/js/v5/format.js
@@ -104,6 +104,23 @@ export function formatAutoUnit(value) {
 	return toFixedHalfEven(value, fallbackDecimals);
 }
 
+// Mirrors diskio/render_curses_v5.py::_format_count_rate(), the `B` key's
+// IOPS mode. Counts, not bytes: 1000 is the step (not 1024) and there is no
+// unit suffix. Deliberately NOT formatCount() below, which is 1024-based --
+// the two surfaces must print the same string for the same number.
+export function formatIops(value) {
+	if (!isNumber(value)) return MISSING;
+	const abs = Math.abs(value);
+	for (const [symbol, threshold] of [
+		["G", 1e9],
+		["M", 1e6],
+		["K", 1e3]
+	]) {
+		if (abs >= threshold) return `${(value / threshold).toFixed(1)}${symbol}`;
+	}
+	return String(Math.trunc(value));
+}
+
 // Mirrors network/render_curses_v5.py::_format_rate(). Bits by default --
 // bytes x 8, with a `b` on every magnitude ("800b", "8.0Mb") -- and the
 // plain byte count with no `b` suffix under --byte ("100", "1.0M").
diff --git a/glances/outputs/static/js/v5/hotkeys.js b/glances/outputs/static/js/v5/hotkeys.js
index b8e4f62a..4e9081b2 100644
--- a/glances/outputs/static/js/v5/hotkeys.js
+++ b/glances/outputs/static/js/v5/hotkeys.js
@@ -64,7 +64,10 @@ export const VIEW_KEYS = {
 	j: { desc: "Threads / programs view", flag: "programs" },
 	b: { desc: "Network I/O in bit/s or byte/s", flag: "byte" },
 	"6": { desc: "GPU: per-card or mean", flag: "meangpu" },
-	F: { desc: "Filesystem: used or free space", flag: "fs_free_space" }
+	F: { desc: "Filesystem: used or free space", flag: "fs_free_space" },
+	B: { desc: "Disk I/O in byte/s or IOPS", flag: "diskio_iops" },
+	"0": { desc: "Load average or Irix percentage", flag: "load_irix" },
+	T: { desc: "Network Rx/Tx apart or combined", flag: "network_sum" }
 };
 
 /** The view flag `key` flips, or null when `key` is not a TOGGLE VIEW key. */
diff --git a/glances/outputs/static/public/glances5.js b/glances/outputs/static/public/glances5.js
index 1de06d59..6be7ba18 100644
Binary files a/glances/outputs/static/public/glances5.js and b/glances/outputs/static/public/glances5.js differ
diff --git a/glances/plugins/diskio/model_v5.py b/glances/plugins/diskio/model_v5.py
index 53d09985..6d5ef30d 100644
--- a/glances/plugins/diskio/model_v5.py
+++ b/glances/plugins/diskio/model_v5.py
@@ -17,9 +17,9 @@ V5 scope (G4-diskio):
   but **no default thresholds** — sustained disk traffic is host-
   specific, alerts only fire when the user sets per-disk or per-field
   keys in ``[diskio]`` (e.g. ``read_bytes_warning=50_000_000``).
-- ``read_count`` / ``write_count`` are kept exportable for IOPS-style
-  consumers but flagged ``internal=True`` so the generic renderer
-  skips them.
+- ``read_count`` / ``write_count`` are flagged ``internal=True`` so the
+  generic renderer skips them; the ``B`` hotkey's IOPS mode renders them
+  explicitly, and exporters have always had them.
 - ``read_time``/``write_time`` and the derived ``read_latency`` /
   ``write_latency`` of v4 are not ported — deferred to a later phase
   with the ``--diskio-latency`` mode.
@@ -61,15 +61,21 @@ class PluginModel(GlancesPluginBase[list]):
             "description": "Read operations per second (rate of psutil read_count counter).",
             "unit": "number",
             "rate": True,
-            # Useful for IOPS-style export downstream but not rendered in
-            # the default TUI (which shows byte rates only — v4 parity).
+            # `internal` keeps it out of the GENERIC renderer's default
+            # columns (which show byte rates — v4 parity); the `B` hotkey's
+            # IOPS mode renders it explicitly, and exporters have always had
+            # it. `short_name` is v4's header for that mode
+            # (`diskio/__init__.py:242`).
             "internal": True,
+            "short_name": "IOR/s",
         },
         "write_count": {
             "description": "Write operations per second (rate of psutil write_count counter).",
             "unit": "number",
             "rate": True,
+            # See `read_count` above.
             "internal": True,
+            "short_name": "IOW/s",
         },
         "read_bytes": {
             "description": "Bytes read per second (rate of psutil read_bytes counter).",
diff --git a/glances/plugins/diskio/render_curses_v5.py b/glances/plugins/diskio/render_curses_v5.py
index 59204b91..976eb32a 100644
--- a/glances/plugins/diskio/render_curses_v5.py
+++ b/glances/plugins/diskio/render_curses_v5.py
@@ -63,8 +63,29 @@ def _format_byte_rate(bytes_per_sec: Any) -> str:
     return f"{int(bytes_value)}B"
 
 
-def _rate_cell(value: Any, level_entry: dict[str, Any]) -> Cell:
-    text = _format_byte_rate(value).rjust(_RATE_COL_WIDTH)
+def _format_count_rate(ops_per_sec: Any) -> str:
+    """Operations/s → human-readable, K/M/G scaled, no unit suffix.
+
+    The `B` hotkey's IOPS mode. Same shape as `_format_byte_rate` above but
+    decimal-scaled and unitless: these are counts, not bytes, so 1000 is the
+    step and there is no `B` to append (v4 `auto_unit`, no unit argument,
+    `diskio/__init__.py:272`).
+    """
+    try:
+        value = float(ops_per_sec)
+    except (TypeError, ValueError):
+        return "-"
+    for symbol, threshold in (("G", 1_000_000_000), ("M", 1_000_000), ("K", 1_000)):
+        if abs(value) >= threshold:
+            return f"{value / threshold:.1f}{symbol}"
+    return f"{int(value)}"
+
+
+def _rate_cell(value: Any, level_entry: dict[str, Any], iops: bool = False) -> Cell:
+    # IOPS are a plain count, so they take the generic auto-unit rather than
+    # the byte formatter -- v4 `auto_unit(read_count_rate_per_sec)` with no
+    # unit suffix (`diskio/__init__.py:272`).
+    text = (_format_count_rate(value) if iops else _format_byte_rate(value)).rjust(_RATE_COL_WIDTH)
     level = level_entry.get("level") if isinstance(level_entry, dict) else None
     role = _LEVEL_TO_ROLE.get(level, ColorRole.DEFAULT)
     prominent = bool(level_entry.get("prominent")) if isinstance(level_entry, dict) else False
@@ -77,8 +98,15 @@ def _format_disk_name(name: str) -> str:
     return name.ljust(_NAME_MAX_WIDTH)
 
 
-def render(payload: dict[str, Any], fields_desc: dict[str, dict[str, Any]]) -> list[Row]:
+def render(
+    payload: dict[str, Any], fields_desc: dict[str, dict[str, Any]], view: dict[str, Any] | None = None
+) -> list[Row]:
     """Render the diskio plugin's TUI block — mirrors v4 ``diskio.msg_curse``."""
+    # `B` (v4 `_handle_diskio_iops`): operations per second instead of byte
+    # rates. Same two columns, different pair of fields -- the labels come
+    # from the schema, so swapping the pair swaps the header too.
+    iops = bool((view or {}).get("diskio_iops"))
+    read_key, write_key = ("read_count", "write_count") if iops else ("read_bytes", "write_bytes")
     # The first header cell is the TUI block title, not a field label -- it
     # stays a literal. The rate columns read their labels from the schema
     # (single source of truth, shared with the WebUI), as network's do.
@@ -91,7 +119,7 @@ def render(payload: dict[str, Any], fields_desc: dict[str, dict[str, Any]]) -> l
                     color=ColorRole.HEADER,
                     bold=True,
                 )
-                for key in ("read_bytes", "write_bytes")
+                for key in (read_key, write_key)
             ),
         ]
     )
@@ -114,7 +142,7 @@ def render(payload: dict[str, Any], fields_desc: dict[str, dict[str, Any]]) -> l
         if item.get("hidden") is True:
             continue
         # Skip disks with no rate yet — cycle 1 sets read_bytes/write_bytes to None.
-        if item.get("read_bytes") is None or item.get("write_bytes") is None:
+        if item.get(read_key) is None or item.get(write_key) is None:
             continue
 
         name = str(item.get("disk_name") or "")
@@ -132,8 +160,8 @@ def render(payload: dict[str, Any], fields_desc: dict[str, dict[str, Any]]) -> l
             Row(
                 cells=[
                     Cell(text=_format_disk_name(display_name)),
-                    _rate_cell(item.get("read_bytes"), disk_levels.get("read_bytes", {})),
-                    _rate_cell(item.get("write_bytes"), disk_levels.get("write_bytes", {})),
+                    _rate_cell(item.get(read_key), disk_levels.get(read_key, {}), iops=iops),
+                    _rate_cell(item.get(write_key), disk_levels.get(write_key, {}), iops=iops),
                 ],
                 item_start=True,
             )
diff --git a/glances/plugins/load/render_curses_v5.py b/glances/plugins/load/render_curses_v5.py
index 6704eb09..0c64aa1e 100644
--- a/glances/plugins/load/render_curses_v5.py
+++ b/glances/plugins/load/render_curses_v5.py
@@ -27,12 +27,15 @@ Reference layout:
   - ``min15`` decoration from ``_levels.min15`` (v4 = primary alert path).
   - ``min5`` decoration from ``_levels.min5``.
   - ``min1`` plain (no alert in v4).
-- ``cpucore`` is declared ``internal: True`` in the schema: never
-  rendered as its own row — only used as the ``Ncore`` suffix on line 1.
+- ``cpucore`` is declared ``internal: True`` in the schema: never rendered
+  as its own row — it supplies the ``Ncore`` suffix on line 1, and the
+  divisor for Irix mode below.
 
-Irix mode (v4 ``args.disable_irix``) is not yet plumbed through v5 —
-load values are shown as plain floats; per-core normalisation is
-implicit in the threshold computation via ``normalize_by: cpucore``.
+Irix mode (v4 ``args.disable_irix``, the ``0`` hotkey, issue #1554) divides
+each average by ``cpucore`` and shows a percentage instead of a plain float.
+Off by default, as in v4. Note that per-core normalisation is ALREADY implicit
+in the threshold computation (``normalize_by: cpucore``) — this key changes
+only what the cell displays, never which level it is coloured with.
 """
 
 from __future__ import annotations
@@ -54,10 +57,32 @@ def _format_load(value: Any) -> str:
         return "     -"
 
 
-def _load_value_cell(payload: dict[str, Any], key: str) -> Cell:
-    """Return a Cell for a single load average, coloured per `_levels`."""
+def _load_value_cell(payload: dict[str, Any], key: str, irix: bool = False) -> Cell:
+    """Return a Cell for a single load average, coloured per `_levels`.
+
+    `irix` is the `0` key (v4 `args.disable_irix`, issue #1554): the raw load
+    average is divided by the core count and shown as a percentage. v4 reads
+    the count from the `core` plugin's `log_core()`
+    (`load/__init__.py:168-171`); v5 reads the `cpucore` field the load
+    payload already carries, which is the same number without the
+    cross-plugin reach.
+    """
     if key not in payload or payload.get(key) is None:
         return Cell(text="     -")
+    if irix:
+        cores = payload.get("cpucore")
+        # v4 guards on `log_core() != 0`; an absent or zero count falls back
+        # to the default mode rather than dividing by zero.
+        if isinstance(cores, (int, float)) and cores > 0:
+            text = f"{payload[key] / cores * 100:>5.1f}%"
+            levels = payload.get("_levels", {}) if isinstance(payload, dict) else {}
+            entry = levels.get(key, {}) if isinstance(levels, dict) else {}
+            level = entry.get("level") if isinstance(entry, dict) else None
+            return Cell(
+                text=text,
+                color=_LEVEL_TO_ROLE.get(level, ColorRole.DEFAULT),
+                prominent=bool(entry.get("prominent")) if isinstance(entry, dict) else False,
+            )
     text = _format_load(payload[key])
     levels = payload.get("_levels", {}) if isinstance(payload, dict) else {}
     entry = levels.get(key, {}) if isinstance(levels, dict) else {}
@@ -67,8 +92,11 @@ def _load_value_cell(payload: dict[str, Any], key: str) -> Cell:
     return Cell(text=text, color=role, prominent=prominent)
 
 
-def render(payload: dict[str, Any], fields_desc: dict[str, dict[str, Any]]) -> list[Row]:
+def render(
+    payload: dict[str, Any], fields_desc: dict[str, dict[str, Any]], view: dict[str, Any] | None = None
+) -> list[Row]:
     """Render the load plugin's TUI block — mirrors v4 ``load.msg_curse``."""
+    irix = bool((view or {}).get("load_irix"))
     if not payload:
         return [Row(cells=[Cell(text="LOAD", color=ColorRole.HEADER, bold=True)])]
 
@@ -95,7 +123,7 @@ def render(payload: dict[str, Any], fields_desc: dict[str, dict[str, Any]]) -> l
     for key in ("min1", "min5", "min15"):
         label = field_label(fields_desc.get(key, {}), key, prefer_short=True)
         label_cell = Cell(text=label.ljust(_LOAD_LABEL_WIDTH))
-        value_cell = _load_value_cell(payload, key)
+        value_cell = _load_value_cell(payload, key, irix=irix)
         rows.append(Row(cells=[label_cell, value_cell]))
 
     return rows
diff --git a/glances/plugins/network/render_curses_v5.py b/glances/plugins/network/render_curses_v5.py
index 856091f9..c6450149 100644
--- a/glances/plugins/network/render_curses_v5.py
+++ b/glances/plugins/network/render_curses_v5.py
@@ -102,6 +102,15 @@ def render(
 ) -> list[Row]:
     """Render the network plugin's TUI block — mirrors v4 ``network.msg_curse``."""
     byte = bool((view or {}).get("byte"))
+    # `T` (v4 `network_sum`): one combined column instead of two.
+    #
+    # DIVERGENCE, in the route not the number. v4 renders a dedicated
+    # `bytes_all` / `bytes_all_rate_per_sec` field its model computes
+    # (`network/__init__.py:276,294`); v5's schema has no such field, so the
+    # renderer sums the two rates it already has. Same value, one fewer field
+    # to keep in step -- and the sum of two rates over the same interval IS
+    # the combined rate.
+    combined = bool((view or {}).get("network_sum"))
     # The first header cell is the TUI block title, not a field label — it
     # stays a literal. The value columns read their labels from the schema
     # (single source of truth, shared with the WebUI).
@@ -118,6 +127,20 @@ def render(
             ),
         ]
     )
+    if combined:
+        # v4's label for the mode (`network/__init__.py:254`), widened to the
+        # two columns it replaces so the block keeps its width and the right
+        # edge stays where the other left-column blocks put theirs.
+        header_row = Row(
+            cells=[
+                Cell(text="NETWORK".ljust(_NAME_MAX_WIDTH), color=ColorRole.HEADER, bold=True),
+                Cell(
+                    text=("Rx+Tx" if byte else "Rx+Tx/s").rjust(_RATE_COL_WIDTH * 2 + 1),
+                    color=ColorRole.HEADER,
+                    bold=True,
+                ),
+            ]
+        )
     rows: list[Row] = [header_row]
 
     if not isinstance(payload, dict):
@@ -154,13 +177,21 @@ def render(
         # keyed by the raw `name`.
         display_name = str(item.get("alias") or name)
 
+        if combined:
+            total = float(item["bytes_recv"]) + float(item["bytes_sent"])
+            # No threshold decoration: the two fields carry their own levels
+            # and a sum belongs to neither. v4 paints its `ax` cell plain for
+            # the same reason (`network/__init__.py:294-295`).
+            value_cells = [Cell(text=_format_rate(total, byte).rjust(_RATE_COL_WIDTH * 2 + 1))]
+        else:
+            value_cells = [
+                _rate_cell(item.get("bytes_recv"), if_levels.get("bytes_recv", {}), byte),
+                _rate_cell(item.get("bytes_sent"), if_levels.get("bytes_sent", {}), byte),
+            ]
+
         rows.append(
             Row(
-                cells=[
-                    Cell(text=_format_if_name(display_name)),
-                    _rate_cell(item.get("bytes_recv"), if_levels.get("bytes_recv", {}), byte),
-                    _rate_cell(item.get("bytes_sent"), if_levels.get("bytes_sent", {}), byte),
-                ],
+                cells=[Cell(text=_format_if_name(display_name)), *value_cells],
                 item_start=True,
             )
         )
diff --git a/tests/fixtures/webui_render_fixtures.js b/tests/fixtures/webui_render_fixtures.js
index 93c22b07..bdcdb99e 100644
--- a/tests/fixtures/webui_render_fixtures.js
+++ b/tests/fixtures/webui_render_fixtures.js
@@ -196,7 +196,13 @@ const INFO_FIXTURES = {
 	cloud: { id: {}, platform: {}, name: {}, type: {}, region: {} },
 	// short_names copied from glances/plugins/diskio/model_v5.py and
 	// glances/plugins/fs/model_v5.py (G9-6 Task 3).
-	diskio: { disk_name: {}, read_bytes: { short_name: "R/s" }, write_bytes: { short_name: "W/s" } },
+	diskio: {
+		disk_name: {},
+		read_bytes: { short_name: "R/s" },
+		write_bytes: { short_name: "W/s" },
+		read_count: { short_name: "IOR/s" },
+		write_count: { short_name: "IOW/s" },
+	},
 	fs: { mnt_point: {}, size: { short_name: "Total" }, used: { short_name: "Used" }, free: { short_name: "Free" }, percent: {} },
 	// short_name copied from glances/plugins/wifi/model_v5.py (G9-6 Task 3);
 	// sensors declares none -- its value column has no header in the TUI.
@@ -333,11 +339,15 @@ const NETWORK_ROWS = {
 // exact 1.25K tie ("1.2K"). `sdb`'s read rate carries a warning.
 const DISKIO_FIXTURE = {
 	_key: "disk_name",
+	// `read_count` / `write_count` ride along on every row: the server has
+	// always published them (`internal: true` keeps them out of the DEFAULT
+	// columns, not out of the payload), and the `B` key renders them instead
+	// of the byte rates. A row missing them would be dropped in that mode.
 	data: [
-		{ disk_name: "sdb", alias: "Backup", read_bytes: 1536, write_bytes: 0, hidden: false },
-		{ disk_name: "loop0", read_bytes: 0, write_bytes: 0, hidden: true },
-		{ disk_name: "sda", read_bytes: null, write_bytes: null, hidden: false },
-		{ disk_name: "nvme0n1", read_bytes: 855.6, write_bytes: 1280, hidden: false },
+		{ disk_name: "sdb", alias: "Backup", read_bytes: 1536, write_bytes: 0, read_count: 12, write_count: 0, hidden: false },
+		{ disk_name: "loop0", read_bytes: 0, write_bytes: 0, read_count: 0, write_count: 0, hidden: true },
+		{ disk_name: "sda", read_bytes: null, write_bytes: null, read_count: null, write_count: null, hidden: false },
+		{ disk_name: "nvme0n1", read_bytes: 855.6, write_bytes: 1280, read_count: 2500, write_count: 7.4, hidden: false },
 	],
 	_levels: { sdb: { read_bytes: { level: "warning", prominent: false } } },
 };
diff --git a/tests/js/format.test.mjs b/tests/js/format.test.mjs
index 26716550..913a5804 100644
--- a/tests/js/format.test.mjs
+++ b/tests/js/format.test.mjs
@@ -1,6 +1,21 @@
 import { test } from "node:test";
 import assert from "node:assert/strict";
-import { formatBytes, formatRate, formatPercent, formatCount, toFahrenheit, formatSeconds, toFixedHalfEven, formatNetworkRate, formatFixed0, formatAutoUnit, formatAutoHz, formatProcessBytes, formatUsername } from "../../glances/outputs/static/js/v5/format.js";
+import {
+	formatAutoHz,
+	formatAutoUnit,
+	formatBytes,
+	formatCount,
+	formatFixed0,
+	formatIops,
+	formatNetworkRate,
+	formatPercent,
+	formatProcessBytes,
+	formatRate,
+	formatSeconds,
+	formatUsername,
+	toFahrenheit,
+	toFixedHalfEven
+} from "../../glances/outputs/static/js/v5/format.js";
 
 test("formatBytes uses binary units", () => {
 	assert.equal(formatBytes(0), "0B");
@@ -261,3 +276,17 @@ test('formatAutoHz returns "?" for whatever it cannot parse', () => {
 	assert.equal(formatAutoHz(""), "?");
 	assert.equal(formatAutoHz(NaN), "?");
 });
+
+test("formatIops mirrors the TUI's _format_count_rate: 1000-step, unitless", () => {
+	// Deliberately NOT formatCount's 1024 step -- the two surfaces must print
+	// the same string for the same number.
+	assert.equal(formatIops(0), "0");
+	assert.equal(formatIops(7.4), "7");
+	assert.equal(formatIops(999), "999");
+	assert.equal(formatIops(1000), "1.0K");
+	assert.equal(formatIops(2500), "2.5K");
+	assert.equal(formatIops(1e6), "1.0M");
+	assert.equal(formatIops(1e9), "1.0G");
+	assert.equal(formatIops(null), "-");
+	assert.equal(formatIops(undefined), "-");
+});
diff --git a/tests/test_curses_v5.py b/tests/test_curses_v5.py
index 7e0f5f7b..be490f98 100644
--- a/tests/test_curses_v5.py
+++ b/tests/test_curses_v5.py
@@ -3339,3 +3339,16 @@ def test_the_fs_renderer_prefers_the_view_override_over_the_payload():
 
     assert "used" in used_header and "free" not in used_header, used_header
     assert "free" in free_header and "used" not in free_header, free_header
+
+
+@pytest.mark.parametrize(("key", "attr"), [("B", "diskio_iops"), ("0", "load_irix"), ("T", "network_sum")])
+def test_a_render_mode_key_flips_its_view_flag(key, attr, fake_store, fake_alerts, fake_config):
+    """`B`, `0` and `T` do not remove a block either: they change which fields
+    a renderer draws. Unlike `b`/`6` the second mode had to be written — v5
+    rendered only one of each — but the data was already collected."""
+    from glances.outputs import glances_curses_v5 as tui_mod
+
+    tui = _make_tui(tui_mod, fake_store, fake_alerts, fake_config)
+    assert tui._build_view(120)[attr] is False
+    assert tui._handle_key(ord(key)) == "changed"
+    assert tui._build_view(120)[attr] is True
diff --git a/tests/test_plugin_diskio_render_curses_v5.py b/tests/test_plugin_diskio_render_curses_v5.py
index e16a0ecd..2459e5a3 100644
--- a/tests/test_plugin_diskio_render_curses_v5.py
+++ b/tests/test_plugin_diskio_render_curses_v5.py
@@ -233,3 +233,42 @@ def test_render_falls_back_to_disk_name_when_no_alias(diskio_fields):
     }
     rows = render(payload, diskio_fields)
     assert "sda" in rows[1].cells[0].text
+
+
+def test_iops_mode_swaps_both_the_columns_and_the_header():
+    """`B` (v4 `_handle_diskio_iops`). The labels come from the schema, so
+    swapping the field pair swaps the header with it."""
+    from glances.plugins.diskio.render_curses_v5 import render
+
+    payload = {
+        "data": [
+            {"disk_name": "sda", "read_bytes": 2048.0, "write_bytes": 0.0, "read_count": 2500.0, "write_count": 7.4}
+        ],
+        "_levels": {},
+    }
+    fields = {
+        "read_bytes": {"short_name": "R/s"},
+        "write_bytes": {"short_name": "W/s"},
+        "read_count": {"short_name": "IOR/s"},
+        "write_count": {"short_name": "IOW/s"},
+    }
+
+    default_rows = render(payload, fields)
+    iops_rows = render(payload, fields, view={"diskio_iops": True})
+
+    assert [c.text.strip() for c in default_rows[0].cells][1:] == ["R/s", "W/s"]
+    assert [c.text.strip() for c in iops_rows[0].cells][1:] == ["IOR/s", "IOW/s"]
+    # Byte rates take the 1024 scale and a `B`; counts take 1000 and no unit.
+    assert [c.text.strip() for c in default_rows[1].cells][1:] == ["2.0K", "0B"]
+    assert [c.text.strip() for c in iops_rows[1].cells][1:] == ["2.5K", "7"]
+
+
+def test_iops_mode_skips_a_disk_with_no_count_yet():
+    """Cycle 1 leaves every rate field None, counts included."""
+    from glances.plugins.diskio.render_curses_v5 import render
+
+    payload = {
+        "data": [{"disk_name": "sda", "read_bytes": 1.0, "write_bytes": 1.0, "read_count": None, "write_count": None}],
+        "_levels": {},
+    }
+    assert len(render(payload, {}, view={"diskio_iops": True})) == 1, "header only"
diff --git a/tests/test_plugin_load_render_curses_v5.py b/tests/test_plugin_load_render_curses_v5.py
index b0f19206..adbf8e5b 100644
--- a/tests/test_plugin_load_render_curses_v5.py
+++ b/tests/test_plugin_load_render_curses_v5.py
@@ -156,3 +156,48 @@ def test_render_total_line_width_matches_across_rows(load_payload, load_fields):
     rows = render(load_payload, load_fields)
     totals = {sum(len(c.text) for c in r.cells) + max(0, len(r.cells) - 1) for r in rows}
     assert len(totals) == 1, f"line widths differ: {totals}"
+
+
+def test_irix_mode_shows_percentages_of_the_core_count():
+    """`0` (v4 `args.disable_irix`, issue #1554): each average divided by
+    `cpucore`, as a percentage."""
+    from glances.plugins.load.render_curses_v5 import render
+
+    payload = {"min1": 2.0, "min5": 1.0, "min15": 0.5, "cpucore": 4, "_levels": {}}
+    fields = {"min1": {"short_name": "1 min"}, "min5": {"short_name": "5 min"}, "min15": {"short_name": "15 min"}}
+
+    plain = [r.cells[1].text.strip() for r in render(payload, fields)[1:]]
+    irix = [r.cells[1].text.strip() for r in render(payload, fields, view={"load_irix": True})[1:]]
+
+    assert plain == ["2.00", "1.00", "0.50"]
+    assert irix == ["50.0%", "25.0%", "12.5%"]
+
+
+def test_irix_mode_falls_back_when_the_core_count_is_unusable():
+    """v4 guards on `log_core() != 0`; an absent or zero count must not divide
+    by zero, and must not print a nonsense percentage either."""
+    from glances.plugins.load.render_curses_v5 import render
+
+    for cores in (0, None):
+        payload = {"min1": 2.0, "min5": 1.0, "min15": 0.5, "cpucore": cores, "_levels": {}}
+        values = [r.cells[1].text.strip() for r in render(payload, {}, view={"load_irix": True})[1:]]
+        assert values == ["2.00", "1.00", "0.50"], cores
+
+
+def test_irix_mode_keeps_the_threshold_colour():
+    """The key changes what the cell DISPLAYS, never which level it is
+    coloured with — per-core normalisation is already implicit in the
+    threshold computation (`normalize_by: cpucore`)."""
+    from glances.outputs.curses_renderer_v5 import ColorRole
+    from glances.plugins.load.render_curses_v5 import render
+
+    payload = {
+        "min1": 2.0,
+        "min5": 1.0,
+        "min15": 8.0,
+        "cpucore": 4,
+        "_levels": {"min15": {"level": "critical", "prominent": True}},
+    }
+    row = render(payload, {}, view={"load_irix": True})[3]
+    assert row.cells[1].color == ColorRole.CRITICAL
+    assert row.cells[1].prominent is True
diff --git a/tests/test_plugin_network_render_curses_v5.py b/tests/test_plugin_network_render_curses_v5.py
index a0f24f0c..217ef88e 100644
--- a/tests/test_plugin_network_render_curses_v5.py
+++ b/tests/test_plugin_network_render_curses_v5.py
@@ -396,3 +396,51 @@ def test_rate_between_1000_and_1024_units_fits_the_column(scaled, symbol, factor
     text = _format_rate(scaled * factor / 8)
     assert len(text) <= _RATE_COL_WIDTH, text
     assert text.endswith(f"{symbol}b"), text
+
+
+def test_combined_mode_replaces_the_two_columns_with_their_sum():
+    """`T` (v4 `network_sum`).
+
+    v4 renders a dedicated `bytes_all` field its model computes; v5's schema
+    has no such field, so the renderer sums the two rates. Same number, and
+    the sum of two rates over one interval IS the combined rate.
+    """
+    from glances.plugins.network.render_curses_v5 import render
+
+    payload = {
+        "data": [{"interface_name": "eth0", "bytes_recv": 100.0, "bytes_sent": 25.0, "is_up": True}],
+        "_levels": {},
+    }
+    fields = {"bytes_recv": {"short_name": "Rx/s"}, "bytes_sent": {"short_name": "Tx/s"}}
+
+    apart = render(payload, fields)
+    combined = render(payload, fields, view={"network_sum": True})
+
+    assert [c.text.strip() for c in apart[0].cells][1:] == ["Rx/s", "Tx/s"]
+    assert [c.text.strip() for c in combined[0].cells][1:] == ["Rx+Tx/s"]
+    # 125 B/s x 8 = 1000 bits/s.
+    assert [c.text.strip() for c in combined[1].cells][1:] == ["1000b"]
+
+
+def test_combined_mode_drops_the_per_second_suffix_under_byte():
+    """v4 labels it `Rx+Tx` under --byte (`network/__init__.py:246-254`)."""
+    from glances.plugins.network.render_curses_v5 import render
+
+    payload = {"data": [], "_levels": {}}
+    header = render(payload, {}, view={"network_sum": True, "byte": True})[0]
+    assert header.cells[1].text.strip() == "Rx+Tx"
+
+
+def test_the_combined_cell_carries_no_threshold_colour():
+    """The two fields have their own levels; a sum belongs to neither, and v4
+    paints its combined cell plain for the same reason."""
+    from glances.outputs.curses_renderer_v5 import ColorRole
+    from glances.plugins.network.render_curses_v5 import render
+
+    payload = {
+        "data": [{"interface_name": "eth0", "bytes_recv": 100.0, "bytes_sent": 25.0, "is_up": True}],
+        "_levels": {"eth0": {"bytes_recv": {"level": "critical", "prominent": True}}},
+    }
+    row = render(payload, {}, view={"network_sum": True})[1]
+    assert row.cells[1].color == ColorRole.DEFAULT
+    assert row.cells[1].prominent is False
diff --git a/tests/test_webui_v5_render.py b/tests/test_webui_v5_render.py
index 909cecd2..7a1f5013 100644
--- a/tests/test_webui_v5_render.py
+++ b/tests/test_webui_v5_render.py
@@ -4108,8 +4108,8 @@ def test_the_help_overlay_renders_every_bound_key():
         for key, spec in TuiV5._HOTKEYS.items()
         if "hide" in spec or spec.get("group") == "TOGGLE VIEW"
     }
-    # One row per bound key (24 SHOW/HIDE + 7 TOGGLE VIEW), plus `h` itself.
-    assert len(rendered) == len(bound) + 1 == 32
+    # One row per bound key (24 SHOW/HIDE + 10 TOGGLE VIEW), plus `h` itself.
+    assert len(rendered) == len(bound) + 1 == 35
 
     joined = " ".join(rendered)
     for key, desc in bound.items():
@@ -4243,7 +4243,17 @@ def test_the_footer_link_toggles_rather_than_only_opening():
 
 
 @pytest.mark.skipif(shutil.which("node") is None, reason="node not available")
-@pytest.mark.parametrize(("key", "flag"), [("b", "byte"), ("6", "meangpu"), ("F", "fs_free_space")])
+@pytest.mark.parametrize(
+    ("key", "flag"),
+    [
+        ("b", "byte"),
+        ("6", "meangpu"),
+        ("F", "fs_free_space"),
+        ("B", "diskio_iops"),
+        ("0", "load_irix"),
+        ("T", "network_sum"),
+    ],
+)
 def test_a_data_type_key_flips_its_flag(key, flag):
     """2.X-c: `b`, `6` and `F` change HOW a value is shown. They ride the same
     override mechanism as the other TOGGLE VIEW keys."""
@@ -4266,3 +4276,41 @@ def test_the_fs_free_space_key_starts_from_the_payload_not_from_serverargs():
     # The `default` fixture's fs payload carries no `free_space`, so the
     # effective value starts false and one press turns it on.
     assert seeded is True
+
+
+@pytest.mark.skipif(shutil.which("node") is None, reason="node not available")
+def test_key_B_switches_the_diskio_columns_to_iops():
+    """Not a visibility toggle: `B` swaps which pair of fields the two columns
+    render. The labels come from the schema, so the header follows."""
+    before = _run_render_probe("diskio")
+    after = _run_render_probe("diskio", "B")
+
+    assert before["pluginColumnHeaders"]["diskio"] == ["DISK I/O", "R/s", "W/s"]
+    assert after["pluginColumnHeaders"]["diskio"] == ["DISK I/O", "IOR/s", "IOW/s"]
+
+
+@pytest.mark.skipif(shutil.which("node") is None, reason="node not available")
+def test_key_T_combines_the_network_columns():
+    before = _run_render_probe("network")
+    after = _run_render_probe("network", "T")
+
+    assert before["pluginColumnHeaders"]["network"] == ["NETWORK", "Rx/s", "Tx/s"]
+    assert after["pluginColumnHeaders"]["network"] == ["NETWORK", "Rx+Tx/s"]
+
+
+@pytest.mark.skipif(shutil.which("node") is None, reason="node not available")
+def test_key_T_drops_the_per_second_suffix_under_byte_mode():
+    """v4 labels the combined column `Rx+Tx` under --byte and `Rx+Tx/s`
+    otherwise (`network/__init__.py:246-254`). The two keys compose."""
+    assert _run_render_probe("network", "T,b")["pluginColumnHeaders"]["network"] == ["NETWORK", "Rx+Tx"]
+
+
+@pytest.mark.skipif(shutil.which("node") is None, reason="node not available")
+def test_key_0_shows_the_load_averages_as_percentages():
+    """Irix mode divides each average by `cpucore`. The fixture's load payload
+    carries the core count, without which the key correctly does nothing."""
+    before = _run_render_probe("load")["pluginText"]["load"]
+    after = _run_render_probe("load", "0")["pluginText"]["load"]
+
+    assert "%" not in before, before
+    assert "%" in after, after