diff --git a/WENO.F90 b/WENO.F90
index 5a7a6f44e3d9594df952764cf52d7019192c7875..80780a4e6dbb90344c0074ebe0c8f64abb3f8505 100644
--- a/WENO.F90
+++ b/WENO.F90
@@ -61,7 +61,8 @@ subroutine compute_flux_derivatives(nvars, ndim, nx, ny, nz, d, &
                                            generalized_states_frozen, &
                                            generalized_fluxes_frozen)
 
-        call pointwise_eigenvalues(nvars, 1, states(:, i-2:i+3, j, k), lambda_pointwise)
+        call pointwise_eigenvalues(nvars, ndim, 1, states(:, i-2:i+3, j, k), &
+                                    metrics(:, :, i-2:i+3, j, k), lambda_pointwise)
         call roe_eigensystem(nvars, ndim, 1, states(:, i:i+1, j, k), &
                               metrics_frozen, R, R_inv, lambda_roe)
 
@@ -111,7 +112,8 @@ subroutine compute_flux_derivatives(nvars, ndim, nx, ny, nz, d, &
                                            generalized_states_frozen, &
                                            generalized_fluxes_frozen)
 
-        call pointwise_eigenvalues(nvars, 2, states(:, i, j-2:j+3, k), lambda_pointwise)
+        call pointwise_eigenvalues(nvars, ndim, 2, states(:, i, j-2:j+3, k), &
+                                    metrics(:, :, i, j-2:j+3, k), lambda_pointwise)
         call roe_eigensystem(nvars, ndim, 2, states(:, i, j:j+1, k), &
                               metrics_frozen, R, R_inv, lambda_roe)
 
@@ -162,7 +164,8 @@ subroutine compute_flux_derivatives(nvars, ndim, nx, ny, nz, d, &
                                            generalized_states_frozen, &
                                            generalized_fluxes_frozen)
 
-        call pointwise_eigenvalues(nvars, 3, states(:, i, j, k-2:k+3), lambda_pointwise)
+        call pointwise_eigenvalues(nvars, ndim, 3, states(:, i, j, k-2:k+3), &
+                                    metrics(:, :, i, j, k-2:k+3), lambda_pointwise)
         call roe_eigensystem(nvars, ndim, 3, states(:, i, j, k:k+1), &
                               metrics_frozen, R, R_inv, lambda_roe)
 
@@ -199,32 +202,37 @@ subroutine compute_flux_derivatives(nvars, ndim, nx, ny, nz, d, &
   !$loopy end tagged: flux_z_diff
 end subroutine
 
-subroutine pointwise_eigenvalues(nvars, d, states, lambda_pointwise)
+subroutine pointwise_eigenvalues(nvars, ndim, d, states, metrics, lambda_pointwise)
   implicit none
 
   integer, intent(in) :: nvars
+  integer, intent(in) :: ndim
   integer, intent(in) :: d
   real*8, intent(in) :: states(nvars, -2:3)
+  real*8, intent(in) :: metrics(ndim, ndim, -2:3)
   real*8, intent(out) :: lambda_pointwise(nvars, -2:3)
 
-  real*8 u(3), c, p, rho, ke
+  real*8 u(3), c, p, rho, ke, metric_norm
   integer v, k, i
 
   do k=-2,3
     rho = states(1,k)
     ke = 0.0d0
+    metric_norm = 0.0d0
     do i=1,3
       u(i) = states(i+1,k)/rho
       ke = ke + u(i)**2
+      metric_norm = metric_norm + metrics(d,i,k)**2
     end do
+    metric_norm = sqrt(metric_norm)
     p = (1.4d0 - 1)*(states(nvars,k) - 0.5d0*rho*ke)
     c = sqrt(1.4d0*p/rho)
 
     do v=1,nvars-2
       lambda_pointwise(v,k) = u(d)
     end do
-    lambda_pointwise(nvars-1,k) = u(d) + c
-    lambda_pointwise(nvars,k) = u(d) - c
+    lambda_pointwise(nvars-1,k) = u(d) + c*metric_norm
+    lambda_pointwise(nvars,k) = u(d) - c*metric_norm
   end do
 end subroutine
 
diff --git a/test/test_flux_window_ops.py b/test/test_flux_window_ops.py
index f1d1a7eb51ae55d3e944a1d5b23b05e81515ba30..8c22c1370cd8a2c15c9d9117430eae9565e2b9c2 100644
--- a/test/test_flux_window_ops.py
+++ b/test/test_flux_window_ops.py
@@ -58,6 +58,8 @@ class WindowResults:
         self.frozen_jacobian = pair.frozen_jacobian
         self.combined_frozen_metric = pair.combined_frozen_metrics[self.dir_internal]
 
+        self.generalized_states_frozen = self.states/self.frozen_jacobian
+
         self.generalized_fluxes = data.generalized_fluxes
         self.generalized_fluxes_frozen = np.array([np.dot(flux, self.frozen_metrics)
                 for flux in data.fluxes])[:,:,self.dir_internal].T.copy(order="F")
@@ -98,23 +100,21 @@ def window_results(queue, window_data):
 
 def test_pointwise_eigenvalues(queue, window_results):
     data = window_results
-    if not np.array_equal(data.metrics[0], data.metrics[1]):
-        pytest.xfail("expect failure with non-uniform metrics")
 
     prg = u.get_weno_program_with_root_kernel("pointwise_eigenvalues")
 
+    metric_arg = np.moveaxis(data.metrics, 0, -1).copy(order="F")
     lam_dev = u.empty_array_on_device(queue, data.nvars, 6)
 
-    prg(queue, nvars=data.nvars, d=data.direction,
-            states=data.states, lambda_pointwise=lam_dev)
+    prg(queue, nvars=data.nvars, ndim=data.ndim, d=data.direction,
+            states=data.states, metrics=metric_arg,
+            lambda_pointwise=lam_dev)
 
     u.compare_arrays(lam_dev.get(), data.lam_pointwise)
 
 
 def test_flux_splitting(queue, window_results):
     data = window_results
-    if not np.array_equal(data.metrics[0], data.metrics[1]):
-        pytest.xfail("expect failure with non-uniform metrics")
 
     prg = u.get_weno_program_with_root_kernel("split_characteristic_fluxes")
 
@@ -122,7 +122,7 @@ def test_flux_splitting(queue, window_results):
     fluxes_neg_dev = u.empty_array_on_device(queue, data.nvars, 6)
 
     prg(queue, nvars=data.nvars,
-            generalized_states_frozen=data.states,
+            generalized_states_frozen=data.generalized_states_frozen,
             generalized_fluxes_frozen=data.generalized_fluxes_frozen,
             R_inv=data.R_inv,
             wavespeeds=data.wavespeeds,