diff --git a/lib/ramble/ramble/appkit.py b/lib/ramble/ramble/appkit.py
index 5d8ff425c..ca54dd060 100644
--- a/lib/ramble/ramble/appkit.py
+++ b/lib/ramble/ramble/appkit.py
@@ -28,6 +28,7 @@
 from ramble.util.logger import logger as tty
 
 from ramble.util.file_util import get_file_path
+from ramble.util.foms import FomType
 
 from ramble.util.output_capture import OUTPUT_CAPTURE
 
diff --git a/var/ramble/repos/builtin/applications/nvidia-hpl-mxp/application.py b/var/ramble/repos/builtin/applications/nvidia-hpl-mxp/application.py
new file mode 100644
index 000000000..ce6bb869b
--- /dev/null
+++ b/var/ramble/repos/builtin/applications/nvidia-hpl-mxp/application.py
@@ -0,0 +1,227 @@
+# Copyright 2022-2025 The Ramble Authors
+#
+# Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+# https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+# <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+# option. This file may not be copied, modified, or distributed
+# except according to those terms.
+
+from ramble.appkit import *
+
+from ramble.base_app.builtin.hpl import Hpl as HplBase
+
+
+class NvidiaHplMxp(HplBase):
+    """This application defines how to run NVIDIA's optimized version of HPL,
+    which is contained in NVIDIA's HPC-Benchmarks collection.
+
+    The NVIDIA HPC-Benchmarks collection provides four benchmarks (HPL,
+    HPL-MxP, HPCG, and STREAM) widely used in the HPC community optimized for
+    performance on NVIDIA accelerated HPC systems.
+
+    NVIDIA's HPL and HPL-MxP benchmarks provide software packages to solve a
+    (random) dense linear system in double precision (64-bit) arithmetic and in
+    mixed precision arithmetic using Tensor Cores, respectively, on
+    distributed-memory computers equipped with NVIDIA GPUs, based on the Netlib HPL
+    benchmark and HPL-MxP benchmark.
+
+    https://catalog.ngc.nvidia.com/orgs/nvidia/containers/hpc-benchmarks
+    """
+
+    name = "nvidia-hpl-mxp"
+
+    maintainers("douglasjacobsen")
+
+    tags("benchmark-app", "benchmark", "linpack", "optimized", "nvidia")
+
+    executable(
+        "execute",
+        './hpl-mxp.sh --gpu-affinity "{gpu_affinity}" --n {Ns} --nb {block_size} --nprow {Ps} --npcol {Qs} --nporder {nporder}',
+        use_mpi=True,
+    )
+
+    workload("standard", executables=["execute"])
+    workload("calculator", executables=["execute"])
+
+    workload_group("standard", workloads=["standard"], mode="append")
+    workload_group("calculator", workloads=["calculator"], mode="append")
+    workload_group(
+        "all_workloads",
+        workloads=["standard", "calculator"],
+    )
+
+    workload_variable(
+        "nvshmem_disable_cuda_vmm",
+        default="1",
+        description="",
+        workload_group="all_workloads",
+    )
+    environment_variable(
+        "NVSHMEM_DISABLE_CUDA_VMM",
+        "{nvshmem_disable_cuda_vmm}",
+        description="",
+        workload_group="all_workloads",
+    )
+
+    workload_variable(
+        "hpl_fct_comm_policy",
+        default="1",
+        description="",
+        workload_group="all_workloads",
+    )
+    environment_variable(
+        "HPL_FCT_COMM_POLICY",
+        "{hpl_fct_comm_policy}",
+        description="",
+        workload_group="all_workloads",
+    )
+
+    workload_variable(
+        "hpl_use_nvshmem",
+        default="0",
+        description="Whether to use NVSHMEM or not",
+        workload_group="all_workloads",
+    )
+    environment_variable(
+        "HPL_USE_NVSHMEM",
+        "{hpl_use_nvshmem}",
+        description="Whether or not to use NVSHMEM",
+        workload_group="all_workloads",
+    )
+
+    workload_variable(
+        "hpl_p2p_as_bcast",
+        default="0",
+        description="0 = ncclBcast, 1 = ncclSend/Recv",
+        workload_group="all_workloads",
+    )
+    environment_variable(
+        "HPL_P2P_AS_BCAST",
+        "{hpl_p2p_as_bcast}",
+        description="Whether or not to use P2P for BCAST",
+        workload_group="all_workloads",
+    )
+
+    workload_variable(
+        "pmix_mca_gds",
+        default="^ds12",
+        description="",
+        workload_group="all_workloads",
+    )
+    environment_variable(
+        "PMIX_MCA_gds",
+        "{pmix_mca_gds}",
+        description="PMIX MCA gds",
+        workload_group="all_workloads",
+    )
+
+    workload_variable(
+        "ompi_mca_btl",
+        default="^vader,tcp,openib,uct",
+        description="",
+        workload_group="all_workloads",
+    )
+    environment_variable(
+        "OMPI_MCA_btl",
+        "{ompi_mca_btl}",
+        description="OpenMPI MCA btl",
+        workload_group="all_workloads",
+    )
+
+    workload_variable(
+        "ompi_mca_pml",
+        default="ucx",
+        description="",
+        workload_group="all_workloads",
+    )
+    environment_variable(
+        "OMPI_MCA_pml",
+        "{ompi_mca_pml}",
+        description="OpenMPI MCA pml",
+        workload_group="all_workloads",
+    )
+
+    workload_variable(
+        "ucx_net_devices",
+        default="enp6s0,enp12s0,enp134s0,enp140s0",
+        description="",
+        workload_group="all_workloads",
+    )
+    environment_variable(
+        "UCX_NET_DEVICES",
+        "{ucx_net_devices}",
+        description="UCX Net Devices",
+        workload_group="all_workloads",
+    )
+
+    workload_variable(
+        "ucx_max_rndv_rails",
+        default="4",
+        description="",
+        workload_group="all_workloads",
+    )
+    environment_variable(
+        "UCX_MAX_RNDV_RAILS",
+        "{ucx_max_rndv_rails}",
+        description="UCX MAximum RNDV Rails",
+        workload_group="all_workloads",
+    )
+
+    workload_variable(
+        "block_size",
+        default="1024",
+        description="Size of each block",
+        workload_group="calculator",
+    )
+
+    workload_variable(
+        "nporder",
+        default="row",
+        description="Major order to use for matrix",
+        values=["row", "column"],
+        workload_group="all_workloads",
+    )
+
+    workload_variable(
+        "gpu_affinity",
+        default="0:1:2:3:4:5:6:7",
+        description="Colon delimited list of GPU IDs",
+        workload_group="all_workloads",
+    )
+
+    # MxP FOMs
+    gflops_regex = (
+        r"\s+GFLOPS = (?P<gflops>\S+), per GPU =\s+(?P<per_gflops>\S+)"
+    )
+    lu_gflops_regex = (
+        r"\s+LU GFLOPS = (?P<gflops>\S+), per GPU =\s+(?P<per_gflops>\S+)"
+    )
+    figure_of_merit(
+        "Total GFlops",
+        fom_regex=gflops_regex,
+        group_name="gflops",
+        units="GFLOP/s",
+        fom_type=FomType.THROUGHPUT,
+    )
+    figure_of_merit(
+        "Per GPU GFlops",
+        fom_regex=gflops_regex,
+        group_name="per_gflops",
+        units="GFLOP/s",
+        fom_type=FomType.THROUGHPUT,
+    )
+
+    figure_of_merit(
+        "Total LU GFlops",
+        fom_regex=lu_gflops_regex,
+        group_name="gflops",
+        units="GFLOP/s",
+        fom_type=FomType.THROUGHPUT,
+    )
+    figure_of_merit(
+        "Per GPU LU GFlops",
+        fom_regex=lu_gflops_regex,
+        group_name="per_gflops",
+        units="GFLOP/s",
+        fom_type=FomType.THROUGHPUT,
+    )
diff --git a/var/ramble/repos/builtin/applications/nvidia-hpl/application.py b/var/ramble/repos/builtin/applications/nvidia-hpl/application.py
index f75e71eeb..29a5b511d 100644
--- a/var/ramble/repos/builtin/applications/nvidia-hpl/application.py
+++ b/var/ramble/repos/builtin/applications/nvidia-hpl/application.py
@@ -200,3 +200,14 @@ class NvidiaHpl(HplBase):
         description="Colon delimited list of GPU IDs",
         workload_group="mxp",
     )
+
+    figure_of_merit(
+        "Per GPU GFlops",
+        fom_regex=r".*\s+(?P<N>[0-9]+)\s+(?P<NB>[0-9]+)\s+(?P<P>[0-9]+)"
+        + r"\s+(?P<Q>[0-9]+)\s+(?P<time>[0-9]+\.[0-9]+)\s+"
+        + r"(?P<gflops>\S+)\s+\(\s+(?P<per_gpu_gflops>\S+)\)",
+        group_name="per_gpu_gflops",
+        units="GFLOP/s",
+        contexts=["problem-name"],
+        fom_type=FomType.THROUGHPUT,
+    )
diff --git a/var/ramble/repos/builtin/base_applications/hpcg/base_application.py b/var/ramble/repos/builtin/base_applications/hpcg/base_application.py
index 07feb943c..5007c606a 100644
--- a/var/ramble/repos/builtin/base_applications/hpcg/base_application.py
+++ b/var/ramble/repos/builtin/base_applications/hpcg/base_application.py
@@ -57,23 +57,25 @@ class Hpcg(ExecutableApplication):
 
     figure_of_merit(
         "Status",
-        fom_regex=r"Final Summary::HPCG result is (?P<status>[a-zA-Z]+) with a GFLOP/s rating of=(?P<gflops>[0-9]+\.[0-9]+)",
+        fom_regex=r"Final Summary::HPCG result is (?P<status>[a-zA-Z]+) with a GFLOP/s rating of=(?P<gflops>[0-9\.]+)",
         group_name="status",
         units="",
     )
 
     figure_of_merit(
-        "Gflops",
-        fom_regex=r"Final Summary::HPCG result is (?P<status>[a-zA-Z]+) with a GFLOP/s rating of=(?P<gflops>[0-9]+\.[0-9]+)",
+        "GFlops",
+        fom_regex=r"Final Summary::HPCG result is (?P<status>[a-zA-Z]+) with a GFLOP/s rating of=(?P<gflops>[0-9\.]+)",
         group_name="gflops",
         units="GFLOP/s",
+        fom_type=FomType.THROUGHPUT,
     )
 
     figure_of_merit(
         "Time",
-        fom_regex=r"Final Summary::Results are.* execution time.*is=(?P<exec_time>[0-9]+\.[0-9]*)",
+        fom_regex=r"Final Summary::Results are.* execution time.*is=(?P<exec_time>[0-9\.]*)",
         group_name="exec_time",
         units="s",
+        fom_type=FomType.TIME,
     )
 
     figure_of_merit(
@@ -106,9 +108,10 @@ class Hpcg(ExecutableApplication):
 
     figure_of_merit(
         "HPCG 2.4 Rating",
-        fom_regex=r"Final Summary::HPCG 2\.4 rating.*=(?P<rating>[0-9]+\.*[0-9]*)",
+        fom_regex=r"Final Summary::HPCG 2\.4 rating.*=(?P<rating>[0-9\.]+)",
         group_name="rating",
         units="",
+        fom_type=FomType.THROUGHPUT,
     )
 
     register_template(
diff --git a/var/ramble/repos/builtin/base_applications/hpl/base_application.py b/var/ramble/repos/builtin/base_applications/hpl/base_application.py
index 47f36a9b2..8ee831f2e 100644
--- a/var/ramble/repos/builtin/base_applications/hpl/base_application.py
+++ b/var/ramble/repos/builtin/base_applications/hpl/base_application.py
@@ -272,93 +272,59 @@ class Hpl(ExecutableApplication):
     # FOMs:
     figure_of_merit(
         "Time",
-        fom_regex=r".*\s+(?P<N>[0-9]+)\s+(?P<NB>[0-9]+)\s+(?P<P>[0-9]+)\s+(?P<Q>[0-9]+)\s+(?P<time>[0-9]+\.[0-9]+)\s+(?P<gflops>[0-9].*)\n",
+        fom_regex=r".*\s+(?P<N>[0-9]+)\s+(?P<NB>[0-9]+)\s+(?P<P>[0-9]+)\s+(?P<Q>[0-9]+)\s+(?P<time>[0-9]+\.[0-9]+)\s+(?P<gflops>\S+)",
         group_name="time",
         units="s",
         contexts=["problem-name"],
+        fom_type=FomType.TIME,
     )
 
     figure_of_merit(
         "GFlops",
-        fom_regex=r".*\s+(?P<N>[0-9]+)\s+(?P<NB>[0-9]+)\s+(?P<P>[0-9]+)\s+(?P<Q>[0-9]+)\s+(?P<time>[0-9]+\.[0-9]+)\s+(?P<gflops>[0-9].*)\n",
+        fom_regex=r".*\s+(?P<N>[0-9]+)\s+(?P<NB>[0-9]+)\s+(?P<P>[0-9]+)\s+(?P<Q>[0-9]+)\s+(?P<time>[0-9]+\.[0-9]+)\s+(?P<gflops>\S+)",
         group_name="gflops",
         units="GFLOP/s",
         contexts=["problem-name"],
+        fom_type=FomType.THROUGHPUT,
     )
 
     figure_of_merit_context(
         "problem-name",
-        regex=r".*\s+(?P<N>[0-9]+)\s+(?P<NB>[0-9]+)\s+(?P<P>[0-9]+)\s+(?P<Q>[0-9]+)\s+(?P<time>[0-9]+\.[0-9]+)\s+(?P<gflops>[0-9].*)\n",
+        regex=r".*\s+(?P<N>[0-9]+)\s+(?P<NB>[0-9]+)\s+(?P<P>[0-9]+)\s+(?P<Q>[0-9]+)\s+(?P<time>[0-9]+\.[0-9]+)\s+(?P<gflops>\S+)",
         output_format="N-NB-P-Q = {N}-{NB}-{P}-{Q}",
     )
 
-    # MxP FOMs
-    gflops_regex = (
-        r"\s+GFLOPS = (?P<gflops>\S+), per GPU =\s+(?P<per_gflops>\S+)"
-    )
-    lu_gflops_regex = (
-        r"\s+LU GFLOPS = (?P<gflops>\S+), per GPU =\s+(?P<per_gflops>\S+)"
-    )
-    figure_of_merit(
-        "Total GFLOPs",
-        fom_regex=gflops_regex,
-        group_name="gflops",
-        units="GFLOPs",
-    )
-    figure_of_merit(
-        "Per GPU GFLOPs",
-        fom_regex=gflops_regex,
-        group_name="per_gflops",
-        units="GFLOPs",
-    )
-
-    figure_of_merit(
-        "Total LU GFLOPs",
-        fom_regex=lu_gflops_regex,
-        group_name="gflops",
-        units="GFLOPs",
-    )
-    figure_of_merit(
-        "Per GPU LU GFLOPs",
-        fom_regex=lu_gflops_regex,
-        group_name="per_gflops",
-        units="GFLOPs",
-    )
-
-    # ( setting_name, setting_description )
+    # List of setting names for input
     hpl_settings = [
-        ("output_file", "output file name (if any)"),
-        ("device_out", "(FORTRAN) device out (6=stdout,7=stderr,file)"),
-        ("N-Ns", "Number of problem sizes (N)"),
-        ("Ns", "Ns, Problem Sizes"),
-        ("N-NBs", "Number of NBs"),
-        ("NBs", "NBs, Block sizes"),
-        ("PMAP", "PMAP process mapping (0=Row-,1=Column-major)"),
-        ("N-Grids", "Number of Grids, process grids (P x Q)"),
-        ("Ps", "Ps, Dimension 1 parallelization"),
-        ("Qs", "Qs, Dimension 2 parallelization"),
-        ("threshold", "threshold"),
-        ("NPFACTs", "Number of PFACTs, panel fact"),
-        ("PFACTs", "PFACT Values (0=left, 1=Crout, 2=Right)"),
-        ("N-NBMINs", "Number of NBMINs, recursive stopping criteria"),
-        ("NBMINs", "NBMINs (>= 1)"),
-        ("N-NDIVs", "Number of NDIVs, panels in recursion"),
-        ("NDIVs", "NDIVs"),
-        ("N-RFACTs", "Number of RFACTS, recursive panel fact."),
-        ("RFACTs", "RFACTs (0=left, 1=Crout, 2=Right)"),
-        ("N-BCASTs", "Number of BCASTs, broadcast"),
-        (
-            "BCASTs",
-            "BCASTs (0=1rg,1=1rM,2=2rg,3=2rM,4=Lng,5=LnM,6=MKL BPUSH,7=AMD Hybrid Panel)",
-        ),
-        ("N-DEPTHs", "Number of DEPTHs, lookahead depth"),
-        ("DEPTHs", "DEPTHs (>=0)"),
-        ("SWAP", "SWAP (0=bin-exch,1=long,2=mix)"),
-        ("swapping_threshold", "swapping_threshold"),
-        ("L1", "L1 in (0=transposed,1=no-transposed) form"),
-        ("U", "U  in (0=transposed,1=no-transposed) form"),
-        ("Equilibration", "Equilibration (0=no,1=yes)"),
-        ("mem_alignment", "memory alignment in double (> 0)"),
+        "output_file",
+        "device_out",
+        "N-Ns",
+        "Ns",
+        "N-NBs",
+        "NBs",
+        "PMAP",
+        "N-Grids",
+        "Ps",
+        "Qs",
+        "threshold",
+        "NPFACTs",
+        "PFACTs",
+        "N-NBMINs",
+        "NBMINs",
+        "N-NDIVs",
+        "NDIVs",
+        "N-RFACTs",
+        "RFACTs",
+        "N-BCASTs",
+        "BCASTs",
+        "N-DEPTHs",
+        "DEPTHs",
+        "SWAP",
+        "swapping_threshold",
+        "L1",
+        "U",
+        "Equilibration",
+        "mem_alignment",
     ]
 
     # Integer sqrt
@@ -431,36 +397,30 @@ def _calculate_values(self, workspace, app_inst):
             nBlocks = problemSize // blockSize
             nBlocks -= nBlocks % lcmPQ
             problemSize = blockSize * nBlocks
-            usedPercentage = int(problemSize**2 / fullMemWords * 100)
 
             for name, var in self.workloads["standard"].variables.items():
                 if var.name not in self.variables:
                     self.define_variable(var.name, var.default)
 
             # Key = Variable name
-            #      Value: Value to override variable with
-            #      Comment: Comment to append to variable comment
+            # Value = Value to override variable with
             calculated_settings = {
-                "N-Ns": {"value": 1},
-                "Ns": {
-                    "value": int(problemSize),
-                    "comment": f"(= {usedPercentage}% of total available memory)",
-                },
-                "N-NBs": {"value": 1},
-                "NBs": {"value": blockSize},
-                "Ps": {"value": int(bestP)},
-                "Qs": {"value": int(bestQ)},
-                "N-Grids": {"value": 1},
+                "N-Ns": 1,
+                "Ns": int(problemSize),
+                "N-NBs": 1,
+                "NBs": blockSize,
+                "Ps": int(bestP),
+                "Qs": int(bestQ),
+                "N-Grids": 1,
             }
 
         # Handle applying overrides, and apply comments to variable definitions.
         # If workload is calculator, `calculated_settings` is defined
         # If workload is standard, `calculated_settings` is empty
-        for setting, comment in self.hpl_settings:
+        for setting in self.hpl_settings:
             value = self.expander.expand_var_name(setting)
 
             if setting in calculated_settings:
-                if "value" in calculated_settings[setting]:
-                    value = calculated_settings[setting]["value"]
+                value = calculated_settings[setting]
 
             self.define_variable(setting, value)