diff --git a/src/context.ts b/src/context.ts
index 917e6fe7..6c29a418 100644
--- a/src/context.ts
+++ b/src/context.ts
@@ -83,11 +83,11 @@ export class GlobalContext {
   load(
     datagraph: DataGraph,
     layer: Layer = Layer.Link,
-    speedMultiplier: SpeedMultiplier = new SpeedMultiplier(1),
+    speedMultiplier?: SpeedMultiplier,
   ) {
     this.setNetwork(datagraph, layer);
     this.viewport.restorePosition();
-    this.setSpeedMultiplier(speedMultiplier);
+    if (speedMultiplier) this.setSpeedMultiplier(speedMultiplier);
     this.setupAutoSave();
     this.saveToLocalStorage();
     urManager.reset();
diff --git a/src/graphics/renderables/device_info.ts b/src/graphics/renderables/device_info.ts
index 1650b483..73811545 100644
--- a/src/graphics/renderables/device_info.ts
+++ b/src/graphics/renderables/device_info.ts
@@ -17,11 +17,11 @@ import { LabeledProgressBar } from "../components/labeled_progress_bar";
 import { ArpTable } from "./arp_table";
 import { Layer } from "../../types/layer";
 import { DataNetworkDevice, DataSwitch } from "../../types/data-devices";
-import { SwitchingTable } from "./switching_table";
+import { ForwardingTable } from "./forwarding_table";
 import { getRoutingTable } from "../../types/network-modules/tables/routing_table";
 import { ToggleInfo } from "../components/toggle_info";
 import { getArpTable } from "../../types/network-modules/tables/arp_table";
-import { getSwitchingTable } from "../../types/network-modules/tables/switching_table";
+import { getForwardingTable } from "../../types/network-modules/tables/forwarding_table";
 
 export class DeviceInfo extends BaseInfo {
   readonly device: ViewDevice;
@@ -218,28 +218,28 @@ export class DeviceInfo extends BaseInfo {
     }
   }
 
-  addSwitchingTable(viewgraph: ViewGraph, deviceId: number): void {
+  addForwardingTable(viewgraph: ViewGraph, deviceId: number): void {
     const dataGraph = viewgraph.getDataGraph();
-    const entries = getSwitchingTable(dataGraph, deviceId);
+    const entries = getForwardingTable(dataGraph, deviceId);
 
     const rows = entries.map((entry) => ({
       values: [entry.mac, entry.port.toString()],
       edited: entry.edited ?? false,
     }));
 
-    const switchingTable = new SwitchingTable({
+    const forwardingTable = new ForwardingTable({
       rows,
       viewgraph,
       deviceId,
     });
 
-    this.inputFields.push(switchingTable.toHTML());
+    this.inputFields.push(forwardingTable.toHTML());
 
     const dataDevice = viewgraph.getDataGraph().getDevice(deviceId);
 
     if (dataDevice instanceof DataSwitch) {
-      dataDevice.setSwitchingTableChangeListener(() => {
-        switchingTable.refreshTable();
+      dataDevice.setForwardingTableChangeListener(() => {
+        forwardingTable.refreshTable();
       });
     } else {
       console.warn(`Device with ID ${deviceId} is not a DataNetworkDevice.`);
diff --git a/src/graphics/renderables/switching_table.ts b/src/graphics/renderables/forwarding_table.ts
similarity index 78%
rename from src/graphics/renderables/switching_table.ts
rename to src/graphics/renderables/forwarding_table.ts
index 54d31468..d9ca3b87 100644
--- a/src/graphics/renderables/switching_table.ts
+++ b/src/graphics/renderables/forwarding_table.ts
@@ -1,17 +1,17 @@
 import { DeviceId } from "../../types/graphs/datagraph";
 import { ViewGraph } from "../../types/graphs/viewgraph";
 import {
-  clearSwitchingTable,
-  getSwitchingTable,
-  removeSwitchingTableEntry,
-  saveSwitchingTableManualChange,
-} from "../../types/network-modules/tables/switching_table";
+  clearForwardingTable,
+  getForwardingTable,
+  removeForwardingTableEntry,
+  saveForwardingTableManualChange,
+} from "../../types/network-modules/tables/forwarding_table";
 import { ALERT_MESSAGES } from "../../utils/constants/alert_constants";
 import { CSS_CLASSES } from "../../utils/constants/css_constants";
 import {
   InvalidMacError,
   InvalidPortError,
-  SWITCHING_TABLE_CONSTANTS,
+  FORWARDING_TABLE_CONSTANTS,
 } from "../../utils/constants/table_constants";
 import { TOOLTIP_KEYS } from "../../utils/constants/tooltips_constants";
 import { Button } from "../basic_components/button";
@@ -19,29 +19,29 @@ import { Table, TableRow } from "../basic_components/table";
 import { ToggleButton } from "../basic_components/toggle_button";
 import { showError, showSuccess } from "./alert_manager";
 
-export interface SwitchingTableProps {
+export interface ForwardingTableProps {
   rows: TableRow[]; // Rows for the table
   viewgraph: ViewGraph; // ViewGraph instance for callbacks
   deviceId: DeviceId; // Device ID for callbacks
 }
 
-export class SwitchingTable {
+export class ForwardingTable {
   private container: HTMLElement;
   private table: Table;
   private toggleButton: ToggleButton;
 
-  constructor(private props: SwitchingTableProps) {
+  constructor(private props: ForwardingTableProps) {
     this.container = document.createElement("div");
 
     const { onEdit, onRegenerate, onDelete, onAddRow } =
-      this.setSwitchingTableCallbacks();
+      this.setForwardingTableCallbacks();
 
     // Create the regenerate button
     const regenerateButton = this.createRegenerateButton(onRegenerate);
 
     const headers = {
       [TOOLTIP_KEYS.MAC_ADDRESS]: TOOLTIP_KEYS.MAC_ADDRESS,
-      [TOOLTIP_KEYS.PORT]: TOOLTIP_KEYS.PORT,
+      [TOOLTIP_KEYS.INTERFACE]: TOOLTIP_KEYS.INTERFACE,
       [TOOLTIP_KEYS.REGENERATE]: regenerateButton, // Add the regenerate button to the header
     };
 
@@ -57,13 +57,13 @@ export class SwitchingTable {
     });
 
     this.toggleButton = new ToggleButton({
-      text: TOOLTIP_KEYS.SWITCHING_TABLE,
+      text: TOOLTIP_KEYS.FORWARDING_TABLE,
       className: CSS_CLASSES.RIGHT_BAR_TOGGLE_BUTTON,
       onToggle: (isToggled) => {
         const tableElement = this.table.toHTML();
         tableElement.style.display = isToggled ? "block" : "none";
       },
-      tooltip: TOOLTIP_KEYS.SWITCHING_TABLE,
+      tooltip: TOOLTIP_KEYS.FORWARDING_TABLE,
     });
 
     // Initially hide the table
@@ -101,24 +101,24 @@ export class SwitchingTable {
   private OnRegenerate(): void {
     const dataGraph = this.props.viewgraph.getDataGraph();
 
-    // clear the current switching table
-    clearSwitchingTable(dataGraph, this.props.deviceId);
+    // clear the current forwarding table
+    clearForwardingTable(dataGraph, this.props.deviceId);
 
     this.updateRows([]);
 
-    showSuccess(ALERT_MESSAGES.SWITCHING_TABLE_REGENERATED);
+    showSuccess(ALERT_MESSAGES.FORWARDING_TABLE_REGENERATED);
   }
 
-  private setSwitchingTableCallbacks() {
+  private setForwardingTableCallbacks() {
     const dataGraph = this.props.viewgraph.getDataGraph();
     const onDelete = (mac: string) => {
-      removeSwitchingTableEntry(dataGraph, this.props.deviceId, mac);
-      showSuccess(ALERT_MESSAGES.SWITCHING_TABLE_ENTRY_DELETED);
+      removeForwardingTableEntry(dataGraph, this.props.deviceId, mac);
+      showSuccess(ALERT_MESSAGES.FORWARDING_TABLE_ENTRY_DELETED);
       return true;
     };
 
     const onRegenerate = () => {
-      console.log("Regenerating Switching Table...");
+      console.log("Regenerating Forwarding Table...");
       this.OnRegenerate();
     };
 
@@ -134,7 +134,7 @@ export class SwitchingTable {
       }
 
       try {
-        const changed = saveSwitchingTableManualChange(
+        const changed = saveForwardingTableManualChange(
           dataGraph,
           this.props.deviceId,
           mac,
@@ -145,7 +145,7 @@ export class SwitchingTable {
           return false;
         }
         this.refreshTable();
-        showSuccess(ALERT_MESSAGES.SWITCHING_TABLE_ENTRY_EDITED);
+        showSuccess(ALERT_MESSAGES.FORWARDING_TABLE_ENTRY_EDITED);
         return true;
       } catch (e) {
         if (e instanceof InvalidMacError) {
@@ -163,18 +163,18 @@ export class SwitchingTable {
       const [mac, portStr] = values;
 
       try {
-        const changed = saveSwitchingTableManualChange(
+        const changed = saveForwardingTableManualChange(
           this.props.viewgraph.getDataGraph(),
           this.props.deviceId,
           mac.trim(),
-          SWITCHING_TABLE_CONSTANTS.PORT_COL_INDEX,
+          FORWARDING_TABLE_CONSTANTS.PORT_COL_INDEX,
           portStr.trim(),
         );
         if (!changed) {
           return false;
         }
         this.refreshTable();
-        showSuccess(ALERT_MESSAGES.SWITCHING_TABLE_ENTRY_ADDED);
+        showSuccess(ALERT_MESSAGES.FORWARDING_TABLE_ENTRY_ADDED);
         return true;
       } catch (e) {
         if (e instanceof InvalidMacError) {
@@ -193,7 +193,7 @@ export class SwitchingTable {
 
   refreshTable(): void {
     const dataGraph = this.props.viewgraph.getDataGraph();
-    const updatedEntries = getSwitchingTable(dataGraph, this.props.deviceId);
+    const updatedEntries = getForwardingTable(dataGraph, this.props.deviceId);
 
     const updatedRows = updatedEntries.map((entry) => ({
       values: [entry.mac.toString(), entry.port.toString()],
diff --git a/src/types/data-devices/dSwitch.ts b/src/types/data-devices/dSwitch.ts
index b9502373..efc28647 100644
--- a/src/types/data-devices/dSwitch.ts
+++ b/src/types/data-devices/dSwitch.ts
@@ -4,20 +4,20 @@ import { EthernetFrame, MacAddress } from "../../packets/ethernet";
 import { DataGraph, DeviceId, SwitchDataNode } from "../graphs/datagraph";
 import { EntryData, Table } from "../network-modules/tables/table";
 
-export interface SwitchingEntry extends EntryData {
+export interface ForwardingEntry extends EntryData {
   mac: string;
   port: number;
 }
 
 export class DataSwitch extends DataDevice {
-  switchingTable: Table<SwitchingEntry>;
-  private switchingTableChangeListener: (() => void) | null = null;
+  forwardingTable: Table<ForwardingEntry>;
+  private forwardingTableChangeListener: (() => void) | null = null;
 
   constructor(graphData: SwitchDataNode, datagraph: DataGraph) {
     super(graphData, datagraph);
-    this.switchingTable = new Table<SwitchingEntry>(
+    this.forwardingTable = new Table<ForwardingEntry>(
       "mac",
-      graphData.switchingTable.map(([mac, port, edited, deleted]) => ({
+      graphData.forwardingTable.map(([mac, port, edited, deleted]) => ({
         mac,
         port,
         edited,
@@ -30,24 +30,24 @@ export class DataSwitch extends DataDevice {
     return DeviceType.Switch;
   }
 
-  updateSwitchingTable(mac: MacAddress, iface: number): void {
-    this.switchingTable.add({
+  updateForwardingTable(mac: MacAddress, iface: number): void {
+    this.forwardingTable.add({
       mac: mac.toString(),
       port: iface,
     });
-    if (this.switchingTableChangeListener) {
-      this.switchingTableChangeListener();
+    if (this.forwardingTableChangeListener) {
+      this.forwardingTableChangeListener();
     }
   }
 
-  setSwitchingTableChangeListener(listener: () => void): void {
-    this.switchingTableChangeListener = listener;
+  setForwardingTableChangeListener(listener: () => void): void {
+    this.forwardingTableChangeListener = listener;
   }
 
   getDataNode(): SwitchDataNode {
     return {
       ...super.getDataNode(),
-      switchingTable: this.switchingTable.serialize(
+      forwardingTable: this.forwardingTable.serialize(
         (entry) =>
           [
             entry.mac,
diff --git a/src/types/edge.ts b/src/types/edge.ts
index 85c6bb7c..63fefc9d 100644
--- a/src/types/edge.ts
+++ b/src/types/edge.ts
@@ -15,7 +15,7 @@ import {
   showTooltip,
 } from "../graphics/renderables/canvas_tooltip_manager";
 import { updateRoutingTableIface } from "./network-modules/tables/routing_table";
-import { updateSwitchingTablePort } from "./network-modules/tables/switching_table";
+import { updateForwardingTablePort } from "./network-modules/tables/forwarding_table";
 
 export class Edge extends Graphics {
   private _data: DataEdge;
@@ -268,7 +268,7 @@ export class Edge extends Graphics {
       newIface,
     );
 
-    updateSwitchingTablePort(
+    updateForwardingTablePort(
       this.viewgraph.getDataGraph(),
       deviceId,
       oldIface,
diff --git a/src/types/graphs/datagraph.ts b/src/types/graphs/datagraph.ts
index 46c17d57..0904f3f6 100644
--- a/src/types/graphs/datagraph.ts
+++ b/src/types/graphs/datagraph.ts
@@ -48,7 +48,7 @@ export interface NetworkInterfaceData {
 }
 
 export interface SwitchDataNode extends CommonDataNode {
-  switchingTable: [string, number, boolean, boolean][]; // [mac, port, edited, deleted]
+  forwardingTable: [string, number, boolean, boolean][]; // [mac, port, edited, deleted]
   type: DeviceType.Switch;
 }
 
diff --git a/src/types/network-modules/tables/switching_table.ts b/src/types/network-modules/tables/forwarding_table.ts
similarity index 69%
rename from src/types/network-modules/tables/switching_table.ts
rename to src/types/network-modules/tables/forwarding_table.ts
index fa36665e..0151aae6 100644
--- a/src/types/network-modules/tables/switching_table.ts
+++ b/src/types/network-modules/tables/forwarding_table.ts
@@ -2,34 +2,34 @@ import { MacAddress } from "../../../packets/ethernet";
 import {
   InvalidMacError,
   InvalidPortError,
-  SWITCHING_TABLE_CONSTANTS,
+  FORWARDING_TABLE_CONSTANTS,
 } from "../../../utils/constants/table_constants";
-import { DataSwitch, SwitchingEntry } from "../../data-devices/dSwitch";
+import { DataSwitch, ForwardingEntry } from "../../data-devices/dSwitch";
 import { DataGraph, DeviceId } from "../../graphs/datagraph";
 
 /**
- * Retrieves the switching table of a switch.
+ * Retrieves the forwarding table of a switch.
  * @param deviceId - ID of the device (switch).
- * @returns An array of objects with the entries of the switching table.
+ * @returns An array of objects with the entries of the forwarding table.
  */
-export function getSwitchingTable(
+export function getForwardingTable(
   datagraph: DataGraph,
   deviceId: DeviceId,
-): SwitchingEntry[] {
+): ForwardingEntry[] {
   const device = datagraph.getDevice(deviceId);
   if (!device || !(device instanceof DataSwitch)) {
     console.warn(`Device with ID ${deviceId} is not a switch.`);
     return [];
   }
 
-  return device.switchingTable.allActive();
+  return device.forwardingTable.allActive();
 }
 
 /**
- * Clears the switching table of a switch.
+ * Clears the forwarding table of a switch.
  * @param deviceId - ID of the device (switch).
  */
-export function clearSwitchingTable(
+export function clearForwardingTable(
   datagraph: DataGraph,
   deviceId: DeviceId,
 ): void {
@@ -39,20 +39,20 @@ export function clearSwitchingTable(
     return;
   }
 
-  // Clear the switching table
-  device.switchingTable.clear();
-  console.log(`Switching table cleared for device ID ${deviceId}.`);
+  // Clear the forwarding table
+  device.forwardingTable.clear();
+  console.log(`Forwarding table cleared for device ID ${deviceId}.`);
 
   // Notify changes
   datagraph.notifyChanges();
 }
 
 /**
- * Removes a specific entry from the switching table.
+ * Removes a specific entry from the forwarding table.
  * @param deviceId - ID of the device (switch).
  * @param mac - MAC address of the entry to remove.
  */
-export function removeSwitchingTableEntry(
+export function removeForwardingTableEntry(
   datagraph: DataGraph,
   deviceId: DeviceId,
   mac: string,
@@ -62,18 +62,18 @@ export function removeSwitchingTableEntry(
     console.warn(`Device with ID ${deviceId} is not a switch.`);
     return;
   }
-  device.switchingTable.softRemove(mac);
+  device.forwardingTable.softRemove(mac);
   datagraph.notifyChanges();
 }
 
 /**
- * Manually updates an entry in the switching table.
+ * Manually updates an entry in the forwarding table.
  * @param deviceId - ID of the device (switch).
  * @param mac - MAC address of the entry to update.
  * @param col - Column index (0 for MAC, 1 for port).
  * @param newValue - New value for the field.
  */
-export function saveSwitchingTableManualChange(
+export function saveForwardingTableManualChange(
   datagraph: DataGraph,
   deviceId: DeviceId,
   mac: string,
@@ -89,27 +89,27 @@ export function saveSwitchingTableManualChange(
   if (!MacAddress.isValidMac(mac)) {
     throw new InvalidMacError();
   }
-  const entry = device.switchingTable.get(mac);
+  const entry = device.forwardingTable.get(mac);
 
-  if (col === SWITCHING_TABLE_CONSTANTS.MAC_COL_INDEX) {
+  if (col === FORWARDING_TABLE_CONSTANTS.MAC_COL_INDEX) {
     // Validate MAC address
     if (!MacAddress.isValidMac(newValue)) {
       throw new InvalidMacError();
     }
     if (entry && entry.mac === newValue) return false;
     if (entry) {
-      device.switchingTable.edit(mac, { mac: newValue.trim() });
+      device.forwardingTable.edit(mac, { mac: newValue.trim() });
       datagraph.notifyChanges();
       return true;
     }
-  } else if (col === SWITCHING_TABLE_CONSTANTS.PORT_COL_INDEX) {
+  } else if (col === FORWARDING_TABLE_CONSTANTS.PORT_COL_INDEX) {
     // Validate port
     const port = parseInt(newValue, 10);
     if (isNaN(port) || port < 0) {
       throw new InvalidPortError();
     }
     if (entry && entry.port === port) return false;
-    device.switchingTable.add({ mac, port, edited: true });
+    device.forwardingTable.add({ mac, port, edited: true });
     datagraph.notifyChanges();
     return true;
   }
@@ -117,13 +117,13 @@ export function saveSwitchingTableManualChange(
 }
 
 /**
- * Updates all entries in the switching table that match the old port, setting them to the new port.
+ * Updates all entries in the forwarding table that match the old port, setting them to the new port.
  * @param datagraph - The data graph.
  * @param deviceId - ID of the switch device.
  * @param oldPort - The port number to replace.
  * @param newPort - The new port number to set.
  */
-export function updateSwitchingTablePort(
+export function updateForwardingTablePort(
   datagraph: DataGraph,
   deviceId: DeviceId,
   oldPort: number,
@@ -136,10 +136,10 @@ export function updateSwitchingTablePort(
   }
 
   let changed = false;
-  device.switchingTable.all().forEach((entry) => {
+  device.forwardingTable.all().forEach((entry) => {
     if (entry.port === oldPort) {
       entry.port = newPort;
-      device.switchingTable.edit(entry.mac, entry, false);
+      device.forwardingTable.edit(entry.mac, entry, false);
       changed = true;
     }
   });
diff --git a/src/types/view-devices/vSwitch.ts b/src/types/view-devices/vSwitch.ts
index 51373ba1..87a9fbad 100644
--- a/src/types/view-devices/vSwitch.ts
+++ b/src/types/view-devices/vSwitch.ts
@@ -48,7 +48,7 @@ export class ViewSwitch extends ViewDevice {
 
   showInfo(): void {
     const info = new DeviceInfo(this);
-    info.addSwitchingTable(this.viewgraph, this.id);
+    info.addForwardingTable(this.viewgraph, this.id);
     RightBar.getInstance().renderInfo(info);
   }
 
@@ -70,14 +70,14 @@ export class ViewSwitch extends ViewDevice {
     return `MAC: ${this.interfaces[iface].mac.toCompressedString()}`;
   }
 
-  updateSwitchingTable(mac: MacAddress, iface: number): void {
+  updateForwardingTable(mac: MacAddress, iface: number): void {
     this.viewgraph.getDataGraph().modifyDevice(this.id, (device) => {
       if (!device) {
         console.error(`Switch with id ${this.id} not found in datagraph`);
         return;
       }
       if (device instanceof DataSwitch) {
-        device.updateSwitchingTable(mac, iface);
+        device.updateForwardingTable(mac, iface);
       }
     });
   }
@@ -116,20 +116,20 @@ export class ViewSwitch extends ViewDevice {
       });
       return;
     }
-    // Update the switching table with the source MAC address
-    this.updateSwitchingTable(frame.source, iface);
+    // Update the forwarding table with the source MAC address
+    this.updateForwardingTable(frame.source, iface);
 
-    // If the destination MAC address is in the switching table, send the frame
+    // If the destination MAC address is in the forwarding table, send the frame
     // to the corresponding device
-    // If the destination MAC address is not in the switching table, send the frame
+    // If the destination MAC address is not in the forwarding table, send the frame
     // to all devices connected to the switch
     const dDevice = this.viewgraph.getDataGraph().getDevice(this.id);
     if (!dDevice || !(dDevice instanceof DataSwitch)) {
       console.warn(`Switch with id ${this.id} not found in datagraph`);
       return;
     }
-    const switchingTable = dDevice.switchingTable;
-    const destEntry = switchingTable.get(frame.destination.toString());
+    const forwardingTable = dDevice.forwardingTable;
+    const destEntry = forwardingTable.get(frame.destination.toString());
     const sendingIfaces: DeviceId[] =
       destEntry && !destEntry.deleted
         ? [destEntry.port]
diff --git a/src/types/viewportManager.ts b/src/types/viewportManager.ts
index 7c750ecc..f1b307ca 100644
--- a/src/types/viewportManager.ts
+++ b/src/types/viewportManager.ts
@@ -133,7 +133,7 @@ function setUpDeviceInfo(ctx: GlobalContext, type: DeviceType): DataNode {
     interfaces.push(iface);
   }
   if (isSwitch) {
-    return { x, y, type, interfaces, switchingTable: [] };
+    return { x, y, type, interfaces, forwardingTable: [] };
   }
   const mask = ctx.getMask();
   return { x, y, type, mask, interfaces, arpTable: [] };
diff --git a/src/utils/constants/alert_constants.ts b/src/utils/constants/alert_constants.ts
index 8561bc54..1da0ab27 100644
--- a/src/utils/constants/alert_constants.ts
+++ b/src/utils/constants/alert_constants.ts
@@ -19,10 +19,11 @@ export const ALERT_MESSAGES = {
   ARP_TABLE_ENTRY_ADDED: "ARP table entry added successfully.",
   ARP_TABLE_ENTRY_DELETED: "ARP table entry deleted successfully.",
   ARP_TABLE_REGENERATED: "ARP table regenerated successfully.",
-  SWITCHING_TABLE_ENTRY_EDITED: "Switching table entry edited successfully.",
-  SWITCHING_TABLE_ENTRY_ADDED: "Switching table entry added successfully.",
-  SWITCHING_TABLE_ENTRY_DELETED: "Switching table entry deleted successfully.",
-  SWITCHING_TABLE_REGENERATED: "Switching table regenerated successfully.",
+  FORWARDING_TABLE_ENTRY_EDITED: "Forwarding table entry edited successfully.",
+  FORWARDING_TABLE_ENTRY_ADDED: "Forwarding table entry added successfully.",
+  FORWARDING_TABLE_ENTRY_DELETED:
+    "Forwarding table entry deleted successfully.",
+  FORWARDING_TABLE_REGENERATED: "Forwarding table regenerated successfully.",
   PARAMETER_UPDATED: "Parameter updated successfully.",
   NO_PROGRAM_SELECTED: "Please select a program to run.",
   LAYER_CHANGED:
@@ -35,7 +36,7 @@ export const ALERT_MESSAGES = {
   INVALID_PORT:
     "Invalid port number. Expected format: XX where XX is a positive number",
   INEXISTENT_PORT: (deviceId: string) =>
-    `Port ${deviceId} does not exist. Please verify the switching table.`,
+    `Port ${deviceId} does not exist. Please verify the forwarding table.`,
   NON_NEIGHBOR_PORT: (deviceId: string) =>
-    `Port ${deviceId} is not a neighbor. Please verify the switching table.`,
+    `Port ${deviceId} is not a neighbor. Please verify the forwarding table.`,
 };
diff --git a/src/utils/constants/table_constants.ts b/src/utils/constants/table_constants.ts
index fa93c6b0..a7c5deb1 100644
--- a/src/utils/constants/table_constants.ts
+++ b/src/utils/constants/table_constants.ts
@@ -20,7 +20,7 @@ export const ROUTER_TABLE_CONSTANTS = {
   TABLE_FIELDS_PER_ROW: 3,
 } as const;
 
-export const SWITCHING_TABLE_CONSTANTS = {
+export const FORWARDING_TABLE_CONSTANTS = {
   MAC_COL_INDEX: 0,
   PORT_COL_INDEX: 1,
   TABLE_FIELDS_PER_ROW: 2,
diff --git a/src/utils/constants/tooltips_constants.ts b/src/utils/constants/tooltips_constants.ts
index e9a4c3bb..bd242201 100644
--- a/src/utils/constants/tooltips_constants.ts
+++ b/src/utils/constants/tooltips_constants.ts
@@ -72,7 +72,7 @@ export const TOOLTIP_KEYS = {
   ARP_TABLE: "ARP Table",
   IFACE_EDITOR: "iface-editor",
   PORT: "Port",
-  SWITCHING_TABLE: "Switching Table",
+  FORWARDING_TABLE: "Forwarding Table",
   MULTI_EDGE_CONNECTED_DEVICES: "Multi Edge Connected Devices",
   ETHERTYPE: "EtherType",
   // ARP Details
@@ -233,9 +233,9 @@ export const TOOLTIP_CONTENT = {
   [TOOLTIP_KEYS.IFACE_EDITOR]:
     "Modify the network interface used by this device.",
   [TOOLTIP_KEYS.PORT]:
-    "The port in the switching table refers to the physical or logical interface on the switch where a device is connected. It is used to forward frames to the correct destination based on the MAC address. This should not be confused with the 'port' used in transport layer protocols (such as TCP/UDP port numbers), which identify specific applications or services.",
-  [TOOLTIP_KEYS.SWITCHING_TABLE]:
-    "The switching table is a data structure used by switches to map MAC addresses to specific ports. It helps the switch determine where to forward incoming frames based on their destination MAC address.",
+    "The port in the forwarding table refers to the physical or logical interface on the switch where a device is connected. It is used to forward frames to the correct destination based on the MAC address. This should not be confused with the 'port' used in transport layer protocols (such as TCP/UDP port numbers), which identify specific applications or services.",
+  [TOOLTIP_KEYS.FORWARDING_TABLE]:
+    "The forwarding table is a data structure used by switches to map MAC addresses to specific interface. It helps the switch determine where to forward incoming frames based on their destination MAC address.",
   [TOOLTIP_KEYS.MULTI_EDGE_CONNECTED_DEVICES]:
     "This field shows the devices connected to the selected edge. It provides a list of all devices that are directly connected.",
   [TOOLTIP_KEYS.SEND_ARP_REQUEST]: