diff --git a/examples/tree_2d_dgsem/elixir_euler_blast_wave_sc_subcell_nonperiodic.jl b/examples/tree_2d_dgsem/elixir_euler_blast_wave_sc_subcell_nonperiodic.jl
index 6ff381b896c..00d3c69f2e6 100644
--- a/examples/tree_2d_dgsem/elixir_euler_blast_wave_sc_subcell_nonperiodic.jl
+++ b/examples/tree_2d_dgsem/elixir_euler_blast_wave_sc_subcell_nonperiodic.jl
@@ -41,8 +41,9 @@ surface_flux = flux_lax_friedrichs
 volume_flux = flux_ranocha
 basis = LobattoLegendreBasis(3)
 limiter_idp = SubcellLimiterIDP(equations, basis;
-                                local_minmax_variables_cons = ["rho"],
-                                math_entropy = true)
+                                local_twosided_variables_cons = ["rho"],
+                                local_onesided_variables_nonlinear = [(Trixi.entropy_math,
+                                                                       max)])
 volume_integral = VolumeIntegralSubcellLimiting(limiter_idp;
                                                 volume_flux_dg = volume_flux,
                                                 volume_flux_fv = surface_flux)
diff --git a/examples/tree_2d_dgsem/elixir_euler_sedov_blast_wave_sc_subcell.jl b/examples/tree_2d_dgsem/elixir_euler_sedov_blast_wave_sc_subcell.jl
index 64cae963158..d3bb6a819b5 100644
--- a/examples/tree_2d_dgsem/elixir_euler_sedov_blast_wave_sc_subcell.jl
+++ b/examples/tree_2d_dgsem/elixir_euler_sedov_blast_wave_sc_subcell.jl
@@ -42,8 +42,9 @@ surface_flux = flux_lax_friedrichs
 volume_flux = flux_chandrashekar
 basis = LobattoLegendreBasis(3)
 limiter_idp = SubcellLimiterIDP(equations, basis;
-                                local_minmax_variables_cons = ["rho"],
-                                spec_entropy = true)
+                                local_twosided_variables_cons = ["rho"],
+                                local_onesided_variables_nonlinear = [(Trixi.entropy_spec,
+                                                                       min)])
 volume_integral = VolumeIntegralSubcellLimiting(limiter_idp;
                                                 volume_flux_dg = volume_flux,
                                                 volume_flux_fv = surface_flux)
diff --git a/examples/tree_2d_dgsem/elixir_eulermulti_shock_bubble_shockcapturing_subcell_minmax.jl b/examples/tree_2d_dgsem/elixir_eulermulti_shock_bubble_shockcapturing_subcell_minmax.jl
index 4b606502ebe..b2d49ecbd48 100644
--- a/examples/tree_2d_dgsem/elixir_eulermulti_shock_bubble_shockcapturing_subcell_minmax.jl
+++ b/examples/tree_2d_dgsem/elixir_eulermulti_shock_bubble_shockcapturing_subcell_minmax.jl
@@ -86,8 +86,8 @@ volume_flux = flux_ranocha
 basis = LobattoLegendreBasis(3)
 
 limiter_idp = SubcellLimiterIDP(equations, basis;
-                                local_minmax_variables_cons = ["rho" * string(i)
-                                                               for i in eachcomponent(equations)])
+                                local_twosided_variables_cons = ["rho" * string(i)
+                                                                 for i in eachcomponent(equations)])
 volume_integral = VolumeIntegralSubcellLimiting(limiter_idp;
                                                 volume_flux_dg = volume_flux,
                                                 volume_flux_fv = surface_flux)
diff --git a/src/callbacks_stage/subcell_bounds_check.jl b/src/callbacks_stage/subcell_bounds_check.jl
index e3b8afb9391..ba193ab2997 100644
--- a/src/callbacks_stage/subcell_bounds_check.jl
+++ b/src/callbacks_stage/subcell_bounds_check.jl
@@ -77,28 +77,27 @@ function init_callback(callback::BoundsCheckCallback, semi, limiter::SubcellLimi
         return nothing
     end
 
-    (; local_minmax, positivity, spec_entropy, math_entropy) = limiter
+    (; local_twosided, positivity, local_onesided) = limiter
     (; output_directory) = callback
     variables = varnames(cons2cons, semi.equations)
 
     mkpath(output_directory)
     open("$output_directory/deviations.txt", "a") do f
         print(f, "# iter, simu_time")
-        if local_minmax
-            for v in limiter.local_minmax_variables_cons
+        if local_twosided
+            for v in limiter.local_twosided_variables_cons
                 variable_string = string(variables[v])
                 print(f, ", " * variable_string * "_min, " * variable_string * "_max")
             end
         end
-        if spec_entropy
-            print(f, ", specEntr_min")
-        end
-        if math_entropy
-            print(f, ", mathEntr_max")
+        if local_onesided
+            for (variable, min_or_max) in limiter.local_onesided_variables_nonlinear
+                print(f, ", " * string(variable) * "_" * string(min_or_max))
+            end
         end
         if positivity
             for v in limiter.positivity_variables_cons
-                if v in limiter.local_minmax_variables_cons
+                if v in limiter.local_twosided_variables_cons
                     continue
                 end
                 print(f, ", " * string(variables[v]) * "_min")
@@ -126,15 +125,15 @@ end
 
 @inline function finalize_callback(callback::BoundsCheckCallback, semi,
                                    limiter::SubcellLimiterIDP)
-    (; local_minmax, positivity, spec_entropy, math_entropy) = limiter
+    (; local_twosided, positivity, local_onesided) = limiter
     (; idp_bounds_delta_global) = limiter.cache
     variables = varnames(cons2cons, semi.equations)
 
     println("─"^100)
     println("Maximum deviation from bounds:")
     println("─"^100)
-    if local_minmax
-        for v in limiter.local_minmax_variables_cons
+    if local_twosided
+        for v in limiter.local_twosided_variables_cons
             v_string = string(v)
             println("$(variables[v]):")
             println("- lower bound: ",
@@ -143,17 +142,19 @@ end
                     idp_bounds_delta_global[Symbol(v_string, "_max")])
         end
     end
-    if spec_entropy
-        println("spec. entropy:\n- lower bound: ",
-                idp_bounds_delta_global[:spec_entropy_min])
-    end
-    if math_entropy
-        println("math. entropy:\n- upper bound: ",
-                idp_bounds_delta_global[:math_entropy_max])
+    if local_onesided
+        for (variable, min_or_max) in limiter.local_onesided_variables_nonlinear
+            variable_string = string(variable)
+            minmax_string = string(min_or_max)
+            println("$variable_string:")
+            println("- $minmax_string bound: ",
+                    idp_bounds_delta_global[Symbol(variable_string, "_",
+                                                   minmax_string)])
+        end
     end
     if positivity
         for v in limiter.positivity_variables_cons
-            if v in limiter.local_minmax_variables_cons
+            if v in limiter.local_twosided_variables_cons
                 continue
             end
             println(string(variables[v]) * ":\n- positivity: ",
diff --git a/src/callbacks_stage/subcell_bounds_check_2d.jl b/src/callbacks_stage/subcell_bounds_check_2d.jl
index 61920565dde..4b8fb34c6b5 100644
--- a/src/callbacks_stage/subcell_bounds_check_2d.jl
+++ b/src/callbacks_stage/subcell_bounds_check_2d.jl
@@ -8,7 +8,7 @@
 @inline function check_bounds(u, mesh::AbstractMesh{2}, equations, solver, cache,
                               limiter::SubcellLimiterIDP,
                               time, iter, output_directory, save_errors)
-    (; local_minmax, positivity, spec_entropy, math_entropy) = solver.volume_integral.limiter
+    (; local_twosided, positivity, local_onesided) = solver.volume_integral.limiter
     (; variable_bounds) = limiter.cache.subcell_limiter_coefficients
     (; idp_bounds_delta_local, idp_bounds_delta_global) = limiter.cache
 
@@ -21,8 +21,8 @@
     # Since there are no processors with caches over 128B, we use `n = 128B / size(uEltype)`
     stride_size = div(128, sizeof(eltype(u))) # = n
 
-    if local_minmax
-        for v in limiter.local_minmax_variables_cons
+    if local_twosided
+        for v in limiter.local_twosided_variables_cons
             v_string = string(v)
             key_min = Symbol(v_string, "_min")
             key_max = Symbol(v_string, "_max")
@@ -43,35 +43,30 @@
             end
         end
     end
-    if spec_entropy
-        key = :spec_entropy_min
-        deviation_threaded = idp_bounds_delta_local[key]
-        @threaded for element in eachelement(solver, cache)
-            deviation = deviation_threaded[stride_size * Threads.threadid()]
-            for j in eachnode(solver), i in eachnode(solver)
-                s = entropy_spec(get_node_vars(u, equations, solver, i, j, element),
-                                 equations)
-                deviation = max(deviation, variable_bounds[key][i, j, element] - s)
-            end
-            deviation_threaded[stride_size * Threads.threadid()] = deviation
-        end
-    end
-    if math_entropy
-        key = :math_entropy_max
-        deviation_threaded = idp_bounds_delta_local[key]
-        @threaded for element in eachelement(solver, cache)
-            deviation = deviation_threaded[stride_size * Threads.threadid()]
-            for j in eachnode(solver), i in eachnode(solver)
-                s = entropy_math(get_node_vars(u, equations, solver, i, j, element),
+    if local_onesided
+        foreach(limiter.local_onesided_variables_nonlinear) do (variable, min_or_max)
+            key = Symbol(string(variable), "_", string(min_or_max))
+            deviation_threaded = idp_bounds_delta_local[key]
+            @threaded for element in eachelement(solver, cache)
+                deviation = deviation_threaded[stride_size * Threads.threadid()]
+                for j in eachnode(solver), i in eachnode(solver)
+                    v = variable(get_node_vars(u, equations, solver, i, j, element),
                                  equations)
-                deviation = max(deviation, s - variable_bounds[key][i, j, element])
+                    if min_or_max === max
+                        deviation = max(deviation,
+                                        v - variable_bounds[key][i, j, element])
+                    else # min_or_max === min
+                        deviation = max(deviation,
+                                        variable_bounds[key][i, j, element] - v)
+                    end
+                end
+                deviation_threaded[stride_size * Threads.threadid()] = deviation
             end
-            deviation_threaded[stride_size * Threads.threadid()] = deviation
         end
     end
     if positivity
         for v in limiter.positivity_variables_cons
-            if v in limiter.local_minmax_variables_cons
+            if v in limiter.local_twosided_variables_cons
                 continue
             end
             key = Symbol(string(v), "_min")
@@ -115,8 +110,8 @@
         # Print to output file
         open("$output_directory/deviations.txt", "a") do f
             print(f, iter, ", ", time)
-            if local_minmax
-                for v in limiter.local_minmax_variables_cons
+            if local_twosided
+                for v in limiter.local_twosided_variables_cons
                     v_string = string(v)
                     print(f, ", ",
                           idp_bounds_delta_local[Symbol(v_string, "_min")][stride_size],
@@ -124,15 +119,16 @@
                           idp_bounds_delta_local[Symbol(v_string, "_max")][stride_size])
                 end
             end
-            if spec_entropy
-                print(f, ", ", idp_bounds_delta_local[:spec_entropy_min][stride_size])
-            end
-            if math_entropy
-                print(f, ", ", idp_bounds_delta_local[:math_entropy_max][stride_size])
+            if local_onesided
+                for (variable, min_or_max) in limiter.local_onesided_variables_nonlinear
+                    print(f, ", ",
+                          idp_bounds_delta_local[Symbol(string(variable), "_",
+                                                        string(min_or_max))][stride_size])
+                end
             end
             if positivity
                 for v in limiter.positivity_variables_cons
-                    if v in limiter.local_minmax_variables_cons
+                    if v in limiter.local_twosided_variables_cons
                         continue
                     end
                     print(f, ", ",
diff --git a/src/solvers/dgsem_tree/subcell_limiters.jl b/src/solvers/dgsem_tree/subcell_limiters.jl
index bd865b8e1e4..7b06149148d 100644
--- a/src/solvers/dgsem_tree/subcell_limiters.jl
+++ b/src/solvers/dgsem_tree/subcell_limiters.jl
@@ -14,30 +14,36 @@ end
 
 """
     SubcellLimiterIDP(equations::AbstractEquations, basis;
-                      local_minmax_variables_cons = String[],
+                      local_twosided_variables_cons = String[],
                       positivity_variables_cons = String[],
                       positivity_variables_nonlinear = [],
                       positivity_correction_factor = 0.1,
-                      spec_entropy = false,
-                      math_entropy = false,
+                      local_onesided_variables_nonlinear = [],
                       max_iterations_newton = 10,
                       newton_tolerances = (1.0e-12, 1.0e-14),
                       gamma_constant_newton = 2 * ndims(equations))
 
 Subcell invariant domain preserving (IDP) limiting used with [`VolumeIntegralSubcellLimiting`](@ref)
 including:
-- Local maximum/minimum Zalesak-type limiting for conservative variables (`local_minmax_variables_cons`)
+- Local two-sided Zalesak-type limiting for conservative variables (`local_twosided_variables_cons`)
 - Positivity limiting for conservative variables (`positivity_variables_cons`) and nonlinear variables
 (`positivity_variables_nonlinear`)
-- One-sided limiting for specific and mathematical entropy (`spec_entropy`, `math_entropy`)
+- Local one-sided limiting for nonlinear variables, e.g. `entropy_spec` and `entropy_math`
+with `local_onesided_variables_nonlinear`
 
-Conservative variables to be limited are passed as a vector of strings, e.g. `local_minmax_variables_cons = ["rho"]`
-and `positivity_variables_cons = ["rho"]`. For nonlinear variables the specific functions are
-passed in a vector, e.g. `positivity_variables_nonlinear = [pressure]`.
+To use these three limiting options use the following structure:
+
+***Conservative variables*** to be limited are passed as a vector of strings, e.g.
+`local_twosided_variables_cons = ["rho"]` and `positivity_variables_cons = ["rho"]`.
+For ***nonlinear variables***, the wanted variable functions are passed within a vector: To ensure
+positivity use a plain vector including the desired variables, e.g. `positivity_variables_nonlinear = [pressure]`.
+For local one-sided limiting pass the variable function combined with the requested bound
+(`min` or `max`) as a tuple. For instance, to impose a lower local bound on the specific entropy
+use `local_onesided_variables_nonlinear = [(Trixi.entropy_spec, min)]`.
 
 The bounds are calculated using the low-order FV solution. The positivity limiter uses
 `positivity_correction_factor` such that `u^new >= positivity_correction_factor * u^FV`.
-The limiting of nonlinear variables uses a Newton-bisection method with a maximum of
+Local and global limiting of nonlinear variables uses a Newton-bisection method with a maximum of
 `max_iterations_newton` iterations, relative and absolute tolerances of `newton_tolerances`
 and a provisional update constant `gamma_constant_newton` (`gamma_constant_newton>=2*d`,
 where `d = #dimensions`). See equation (20) of Pazner (2020) and equation (30) of Rueda-Ramírez et al. (2022).
@@ -58,16 +64,17 @@ where `d = #dimensions`). See equation (20) of Pazner (2020) and equation (30) o
 !!! warning "Experimental implementation"
     This is an experimental feature and may change in future releases.
 """
-struct SubcellLimiterIDP{RealT <: Real, LimitingVariablesNonlinear, Cache} <:
+struct SubcellLimiterIDP{RealT <: Real, LimitingVariablesNonlinear,
+                         LimitingOnesidedVariablesNonlinear, Cache} <:
        AbstractSubcellLimiter
-    local_minmax::Bool
-    local_minmax_variables_cons::Vector{Int}                   # Local mininum/maximum principles for conservative variables
+    local_twosided::Bool
+    local_twosided_variables_cons::Vector{Int}                 # Local two-sided limiting for conservative variables
     positivity::Bool
     positivity_variables_cons::Vector{Int}                     # Positivity for conservative variables
     positivity_variables_nonlinear::LimitingVariablesNonlinear # Positivity for nonlinear variables
     positivity_correction_factor::RealT
-    spec_entropy::Bool
-    math_entropy::Bool
+    local_onesided::Bool
+    local_onesided_variables_nonlinear::LimitingOnesidedVariablesNonlinear # Local one-sided limiting for nonlinear variables
     cache::Cache
     max_iterations_newton::Int
     newton_tolerances::Tuple{RealT, RealT}  # Relative and absolute tolerances for Newton's method
@@ -76,43 +83,56 @@ end
 
 # this method is used when the limiter is constructed as for shock-capturing volume integrals
 function SubcellLimiterIDP(equations::AbstractEquations, basis;
-                           local_minmax_variables_cons = String[],
+                           local_twosided_variables_cons = String[],
                            positivity_variables_cons = String[],
                            positivity_variables_nonlinear = [],
                            positivity_correction_factor = 0.1,
-                           spec_entropy = false,
-                           math_entropy = false,
+                           local_onesided_variables_nonlinear = [],
                            max_iterations_newton = 10,
                            newton_tolerances = (1.0e-12, 1.0e-14),
                            gamma_constant_newton = 2 * ndims(equations))
-    local_minmax = (length(local_minmax_variables_cons) > 0)
+    local_twosided = (length(local_twosided_variables_cons) > 0)
+    local_onesided = (length(local_onesided_variables_nonlinear) > 0)
     positivity = (length(positivity_variables_cons) +
                   length(positivity_variables_nonlinear) > 0)
-    if math_entropy && spec_entropy
-        error("Only one of the two can be selected: math_entropy/spec_entropy")
+
+    # When passing `min` or `max` in the elixir, the specific function of Base is used.
+    # To speed up the simulation, we replace it with `Trixi.min` and `Trixi.max` respectively.
+    local_onesided_variables_nonlinear_ = Tuple{Function, Function}[]
+    for (variable, min_or_max) in local_onesided_variables_nonlinear
+        if min_or_max === Base.max
+            push!(local_onesided_variables_nonlinear_, tuple(variable, max))
+        elseif min_or_max === Base.min
+            push!(local_onesided_variables_nonlinear_, tuple(variable, min))
+        elseif min_or_max === Trixi.max || min_or_max === Trixi.min
+            push!(local_onesided_variables_nonlinear_, tuple(variable, min_or_max))
+        else
+            error("Parameter $min_or_max is not a valid input. Use `max` or `min` instead.")
+        end
     end
+    local_onesided_variables_nonlinear_ = Tuple(local_onesided_variables_nonlinear_)
 
-    local_minmax_variables_cons_ = get_variable_index.(local_minmax_variables_cons,
-                                                       equations)
+    local_twosided_variables_cons_ = get_variable_index.(local_twosided_variables_cons,
+                                                         equations)
     positivity_variables_cons_ = get_variable_index.(positivity_variables_cons,
                                                      equations)
 
     bound_keys = ()
-    if local_minmax
-        for v in local_minmax_variables_cons_
+    if local_twosided
+        for v in local_twosided_variables_cons_
             v_string = string(v)
             bound_keys = (bound_keys..., Symbol(v_string, "_min"),
                           Symbol(v_string, "_max"))
         end
     end
-    if spec_entropy
-        bound_keys = (bound_keys..., :spec_entropy_min)
-    end
-    if math_entropy
-        bound_keys = (bound_keys..., :math_entropy_max)
+    if local_onesided
+        for (variable, min_or_max) in local_onesided_variables_nonlinear_
+            bound_keys = (bound_keys...,
+                          Symbol(string(variable), "_", string(min_or_max)))
+        end
     end
     for v in positivity_variables_cons_
-        if !(v in local_minmax_variables_cons_)
+        if !(v in local_twosided_variables_cons_)
             bound_keys = (bound_keys..., Symbol(string(v), "_min"))
         end
     end
@@ -124,11 +144,13 @@ function SubcellLimiterIDP(equations::AbstractEquations, basis;
 
     SubcellLimiterIDP{typeof(positivity_correction_factor),
                       typeof(positivity_variables_nonlinear),
-                      typeof(cache)}(local_minmax, local_minmax_variables_cons_,
+                      typeof(local_onesided_variables_nonlinear_),
+                      typeof(cache)}(local_twosided, local_twosided_variables_cons_,
                                      positivity, positivity_variables_cons_,
                                      positivity_variables_nonlinear,
                                      positivity_correction_factor,
-                                     spec_entropy, math_entropy,
+                                     local_onesided,
+                                     local_onesided_variables_nonlinear_,
                                      cache,
                                      max_iterations_newton, newton_tolerances,
                                      gamma_constant_newton)
@@ -136,24 +158,21 @@ end
 
 function Base.show(io::IO, limiter::SubcellLimiterIDP)
     @nospecialize limiter # reduce precompilation time
-    (; local_minmax, positivity, spec_entropy, math_entropy) = limiter
+    (; local_twosided, positivity, local_onesided) = limiter
 
     print(io, "SubcellLimiterIDP(")
-    if !(local_minmax || positivity || spec_entropy || math_entropy)
+    if !(local_twosided || positivity || local_onesided)
         print(io, "No limiter selected => pure DG method")
     else
         features = String[]
-        if local_minmax
+        if local_twosided
             push!(features, "local min/max")
         end
         if positivity
             push!(features, "positivity")
         end
-        if spec_entropy
-            push!(features, "specific entropy")
-        end
-        if math_entropy
-            push!(features, "mathematical entropy")
+        if local_onesided
+            push!(features, "local onesided")
         end
         join(io, features, ", ")
         print(io, "Limiter=($features), ")
@@ -164,19 +183,19 @@ end
 
 function Base.show(io::IO, ::MIME"text/plain", limiter::SubcellLimiterIDP)
     @nospecialize limiter # reduce precompilation time
-    (; local_minmax, positivity, spec_entropy, math_entropy) = limiter
+    (; local_twosided, positivity, local_onesided) = limiter
 
     if get(io, :compact, false)
         show(io, limiter)
     else
-        if !(local_minmax || positivity || spec_entropy || math_entropy)
+        if !(local_twosided || positivity || local_onesided)
             setup = ["Limiter" => "No limiter selected => pure DG method"]
         else
             setup = ["Limiter" => ""]
-            if local_minmax
+            if local_twosided
                 setup = [
                     setup...,
-                    "" => "Local maximum/minimum limiting for conservative variables $(limiter.local_minmax_variables_cons)",
+                    "" => "Local two-sided limiting for conservative variables $(limiter.local_twosided_variables_cons)",
                 ]
             end
             if positivity
@@ -187,14 +206,10 @@ function Base.show(io::IO, ::MIME"text/plain", limiter::SubcellLimiterIDP)
                     "" => "- with positivity correction factor = $(limiter.positivity_correction_factor)",
                 ]
             end
-            if spec_entropy
-                setup = [setup..., "" => "Local minimum limiting for specific entropy"]
-            end
-            if math_entropy
-                setup = [
-                    setup...,
-                    "" => "Local maximum limiting for mathematical entropy",
-                ]
+            if local_onesided
+                for (variable, min_or_max) in limiter.local_onesided_variables_nonlinear
+                    setup = [setup..., "" => "Local $min_or_max limiting for $variable"]
+                end
             end
             setup = [
                 setup...,
diff --git a/src/solvers/dgsem_tree/subcell_limiters_2d.jl b/src/solvers/dgsem_tree/subcell_limiters_2d.jl
index 3d831e4fa39..e820bed667c 100644
--- a/src/solvers/dgsem_tree/subcell_limiters_2d.jl
+++ b/src/solvers/dgsem_tree/subcell_limiters_2d.jl
@@ -44,20 +44,16 @@ function (limiter::SubcellLimiterIDP)(u::AbstractArray{<:Any, 4}, semi, dg::DGSE
     # TODO: Do not abuse `reset_du!` but maybe implement a generic `set_zero!`
     @trixi_timeit timer() "reset alpha" reset_du!(alpha, dg, semi.cache)
 
-    if limiter.local_minmax
-        @trixi_timeit timer() "local min/max limiting" idp_local_minmax!(alpha, limiter,
-                                                                         u, t, dt, semi)
+    if limiter.local_twosided
+        @trixi_timeit timer() "local twosided" idp_local_twosided!(alpha, limiter,
+                                                                   u, t, dt, semi)
     end
     if limiter.positivity
         @trixi_timeit timer() "positivity" idp_positivity!(alpha, limiter, u, dt, semi)
     end
-    if limiter.spec_entropy
-        @trixi_timeit timer() "spec_entropy" idp_spec_entropy!(alpha, limiter, u, t, dt,
-                                                               semi)
-    end
-    if limiter.math_entropy
-        @trixi_timeit timer() "math_entropy" idp_math_entropy!(alpha, limiter, u, t, dt,
-                                                               semi)
+    if limiter.local_onesided
+        @trixi_timeit timer() "local onesided" idp_local_onesided!(alpha, limiter,
+                                                                   u, t, dt, semi)
     end
 
     # Calculate alpha1 and alpha2
@@ -179,44 +175,48 @@ end
     return nothing
 end
 
-@inline function calc_bounds_onesided!(var_minmax, minmax, typeminmax, variable, u, t,
-                                       semi)
+@inline function calc_bounds_onesided!(var_minmax, min_or_max, variable, u, t, semi)
     mesh, equations, dg, cache = mesh_equations_solver_cache(semi)
     # Calc bounds inside elements
     @threaded for element in eachelement(dg, cache)
+        # Reset bounds
         for j in eachnode(dg), i in eachnode(dg)
-            var_minmax[i, j, element] = typeminmax(eltype(var_minmax))
+            if min_or_max === max
+                var_minmax[i, j, element] = typemin(eltype(var_minmax))
+            else
+                var_minmax[i, j, element] = typemax(eltype(var_minmax))
+            end
         end
 
         # Calculate bounds at Gauss-Lobatto nodes using u
         for j in eachnode(dg), i in eachnode(dg)
             var = variable(get_node_vars(u, equations, dg, i, j, element), equations)
-            var_minmax[i, j, element] = minmax(var_minmax[i, j, element], var)
+            var_minmax[i, j, element] = min_or_max(var_minmax[i, j, element], var)
 
             if i > 1
-                var_minmax[i - 1, j, element] = minmax(var_minmax[i - 1, j, element],
-                                                       var)
+                var_minmax[i - 1, j, element] = min_or_max(var_minmax[i - 1, j,
+                                                                      element], var)
             end
             if i < nnodes(dg)
-                var_minmax[i + 1, j, element] = minmax(var_minmax[i + 1, j, element],
-                                                       var)
+                var_minmax[i + 1, j, element] = min_or_max(var_minmax[i + 1, j,
+                                                                      element], var)
             end
             if j > 1
-                var_minmax[i, j - 1, element] = minmax(var_minmax[i, j - 1, element],
-                                                       var)
+                var_minmax[i, j - 1, element] = min_or_max(var_minmax[i, j - 1,
+                                                                      element], var)
             end
             if j < nnodes(dg)
-                var_minmax[i, j + 1, element] = minmax(var_minmax[i, j + 1, element],
-                                                       var)
+                var_minmax[i, j + 1, element] = min_or_max(var_minmax[i, j + 1,
+                                                                      element], var)
             end
         end
     end
 
     # Values at element boundary
-    calc_bounds_onesided_interface!(var_minmax, minmax, variable, u, t, semi, mesh)
+    calc_bounds_onesided_interface!(var_minmax, min_or_max, variable, u, t, semi, mesh)
 end
 
-@inline function calc_bounds_onesided_interface!(var_minmax, minmax, variable, u, t,
+@inline function calc_bounds_onesided_interface!(var_minmax, min_or_max, variable, u, t,
                                                  semi, mesh::TreeMesh2D)
     _, equations, dg, cache = mesh_equations_solver_cache(semi)
     (; boundary_conditions) = semi
@@ -240,10 +240,10 @@ end
             var_right = variable(get_node_vars(u, equations, dg, index_right..., right),
                                  equations)
 
-            var_minmax[index_right..., right] = minmax(var_minmax[index_right...,
-                                                                  right], var_left)
-            var_minmax[index_left..., left] = minmax(var_minmax[index_left..., left],
-                                                     var_right)
+            var_minmax[index_right..., right] = min_or_max(var_minmax[index_right...,
+                                                                      right], var_left)
+            var_minmax[index_left..., left] = min_or_max(var_minmax[index_left...,
+                                                                    left], var_right)
         end
     end
 
@@ -270,8 +270,8 @@ end
                                                index..., element)
             var_outer = variable(u_outer, equations)
 
-            var_minmax[index..., element] = minmax(var_minmax[index..., element],
-                                                   var_outer)
+            var_minmax[index..., element] = min_or_max(var_minmax[index..., element],
+                                                       var_outer)
         end
     end
 
@@ -279,17 +279,17 @@ end
 end
 
 ###############################################################################
-# Local minimum/maximum limiting
+# Local two-sided limiting of conservative variables
 
-@inline function idp_local_minmax!(alpha, limiter, u, t, dt, semi)
-    for variable in limiter.local_minmax_variables_cons
-        idp_local_minmax!(alpha, limiter, u, t, dt, semi, variable)
+@inline function idp_local_twosided!(alpha, limiter, u, t, dt, semi)
+    for variable in limiter.local_twosided_variables_cons
+        idp_local_twosided!(alpha, limiter, u, t, dt, semi, variable)
     end
 
     return nothing
 end
 
-@inline function idp_local_minmax!(alpha, limiter, u, t, dt, semi, variable)
+@inline function idp_local_twosided!(alpha, limiter, u, t, dt, semi, variable)
     _, _, dg, cache = mesh_equations_solver_cache(semi)
     (; antidiffusive_flux1_L, antidiffusive_flux2_L, antidiffusive_flux1_R, antidiffusive_flux2_R) = cache.antidiffusive_fluxes
     (; inverse_weights) = dg.basis
@@ -351,46 +351,32 @@ end
 end
 
 ##############################################################################
-# Local minimum limiting of specific entropy
-
-@inline function idp_spec_entropy!(alpha, limiter, u, t, dt, semi)
-    _, equations, dg, cache = mesh_equations_solver_cache(semi)
-    (; variable_bounds) = limiter.cache.subcell_limiter_coefficients
-    s_min = variable_bounds[:spec_entropy_min]
-    calc_bounds_onesided!(s_min, min, typemax, entropy_spec, u, t, semi)
+# Local one-sided limiting of nonlinear variables
 
-    # Perform Newton's bisection method to find new alpha
-    @threaded for element in eachelement(dg, cache)
-        inverse_jacobian = cache.elements.inverse_jacobian[element]
-        for j in eachnode(dg), i in eachnode(dg)
-            u_local = get_node_vars(u, equations, dg, i, j, element)
-            newton_loops_alpha!(alpha, s_min[i, j, element], u_local, i, j, element,
-                                entropy_spec, initial_check_entropy_spec_newton_idp,
-                                final_check_standard_newton_idp, inverse_jacobian,
-                                dt, equations, dg, cache, limiter)
-        end
+@inline function idp_local_onesided!(alpha, limiter, u, t, dt, semi)
+    foreach(limiter.local_onesided_variables_nonlinear) do (variable, min_or_max)
+        idp_local_onesided!(alpha, limiter, u, t, dt, semi, variable, min_or_max)
     end
 
     return nothing
 end
 
-###############################################################################
-# Local maximum limiting of mathematical entropy
-
-@inline function idp_math_entropy!(alpha, limiter, u, t, dt, semi)
+@inline function idp_local_onesided!(alpha, limiter, u, t, dt, semi, variable,
+                                     min_or_max)
     _, equations, dg, cache = mesh_equations_solver_cache(semi)
     (; variable_bounds) = limiter.cache.subcell_limiter_coefficients
-    s_max = variable_bounds[:math_entropy_max]
-    calc_bounds_onesided!(s_max, max, typemin, entropy_math, u, t, semi)
+    var_minmax = variable_bounds[Symbol(string(variable), "_", string(min_or_max))]
+    calc_bounds_onesided!(var_minmax, min_or_max, variable, u, t, semi)
 
     # Perform Newton's bisection method to find new alpha
     @threaded for element in eachelement(dg, cache)
         inverse_jacobian = cache.elements.inverse_jacobian[element]
         for j in eachnode(dg), i in eachnode(dg)
             u_local = get_node_vars(u, equations, dg, i, j, element)
-            newton_loops_alpha!(alpha, s_max[i, j, element], u_local, i, j, element,
-                                entropy_math, initial_check_entropy_math_newton_idp,
-                                final_check_standard_newton_idp, inverse_jacobian,
+            newton_loops_alpha!(alpha, var_minmax[i, j, element], u_local,
+                                i, j, element, variable, min_or_max,
+                                initial_check_local_onesided_newton_idp,
+                                final_check_local_onesided_newton_idp, inverse_jacobian,
                                 dt, equations, dg, cache, limiter)
         end
     end
@@ -445,8 +431,8 @@ end
             end
 
             # Compute bound
-            if limiter.local_minmax &&
-               variable in limiter.local_minmax_variables_cons &&
+            if limiter.local_twosided &&
+               variable in limiter.local_twosided_variables_cons &&
                var_min[i, j, element] >= positivity_correction_factor * var
                 # Local limiting is more restrictive that positivity limiting
                 # => Skip positivity limiting for this node
@@ -508,7 +494,7 @@ end
 
             # Perform Newton's bisection method to find new alpha
             newton_loops_alpha!(alpha, var_min[i, j, element], u_local, i, j, element,
-                                variable, initial_check_nonnegative_newton_idp,
+                                variable, min, initial_check_nonnegative_newton_idp,
                                 final_check_nonnegative_newton_idp, inverse_jacobian,
                                 dt, equations, dg, cache, limiter)
         end
@@ -518,8 +504,9 @@ end
 end
 
 @inline function newton_loops_alpha!(alpha, bound, u, i, j, element, variable,
-                                     initial_check, final_check, inverse_jacobian, dt,
-                                     equations, dg, cache, limiter)
+                                     min_or_max, initial_check, final_check,
+                                     inverse_jacobian, dt, equations, dg, cache,
+                                     limiter)
     (; inverse_weights) = dg.basis
     (; antidiffusive_flux1_L, antidiffusive_flux2_L, antidiffusive_flux1_R, antidiffusive_flux2_R) = cache.antidiffusive_fluxes
 
@@ -529,37 +516,38 @@ end
     antidiffusive_flux = gamma_constant_newton * inverse_jacobian * inverse_weights[i] *
                          get_node_vars(antidiffusive_flux1_R, equations, dg, i, j,
                                        element)
-    newton_loop!(alpha, bound, u, i, j, element, variable, initial_check, final_check,
-                 equations, dt, limiter, antidiffusive_flux)
+    newton_loop!(alpha, bound, u, i, j, element, variable, min_or_max, initial_check,
+                 final_check, equations, dt, limiter, antidiffusive_flux)
 
     # positive xi direction
     antidiffusive_flux = -gamma_constant_newton * inverse_jacobian *
                          inverse_weights[i] *
                          get_node_vars(antidiffusive_flux1_L, equations, dg, i + 1, j,
                                        element)
-    newton_loop!(alpha, bound, u, i, j, element, variable, initial_check, final_check,
-                 equations, dt, limiter, antidiffusive_flux)
+    newton_loop!(alpha, bound, u, i, j, element, variable, min_or_max, initial_check,
+                 final_check, equations, dt, limiter, antidiffusive_flux)
 
     # negative eta direction
     antidiffusive_flux = gamma_constant_newton * inverse_jacobian * inverse_weights[j] *
                          get_node_vars(antidiffusive_flux2_R, equations, dg, i, j,
                                        element)
-    newton_loop!(alpha, bound, u, i, j, element, variable, initial_check, final_check,
-                 equations, dt, limiter, antidiffusive_flux)
+    newton_loop!(alpha, bound, u, i, j, element, variable, min_or_max, initial_check,
+                 final_check, equations, dt, limiter, antidiffusive_flux)
 
     # positive eta direction
     antidiffusive_flux = -gamma_constant_newton * inverse_jacobian *
                          inverse_weights[j] *
                          get_node_vars(antidiffusive_flux2_L, equations, dg, i, j + 1,
                                        element)
-    newton_loop!(alpha, bound, u, i, j, element, variable, initial_check, final_check,
-                 equations, dt, limiter, antidiffusive_flux)
+    newton_loop!(alpha, bound, u, i, j, element, variable, min_or_max, initial_check,
+                 final_check, equations, dt, limiter, antidiffusive_flux)
 
     return nothing
 end
 
-@inline function newton_loop!(alpha, bound, u, i, j, element, variable, initial_check,
-                              final_check, equations, dt, limiter, antidiffusive_flux)
+@inline function newton_loop!(alpha, bound, u, i, j, element, variable, min_or_max,
+                              initial_check, final_check, equations, dt, limiter,
+                              antidiffusive_flux)
     newton_reltol, newton_abstol = limiter.newton_tolerances
 
     beta = 1 - alpha[i, j, element]
@@ -573,7 +561,7 @@ end
     if isvalid(u_curr, equations)
         goal = goal_function_newton_idp(variable, bound, u_curr, equations)
 
-        initial_check(bound, goal, newton_abstol) && return nothing
+        initial_check(min_or_max, bound, goal, newton_abstol) && return nothing
     end
 
     # Newton iterations
@@ -608,7 +596,7 @@ end
 
             # Check new beta for condition and update bounds
             goal = goal_function_newton_idp(variable, bound, u_curr, equations)
-            if initial_check(bound, goal, newton_abstol)
+            if initial_check(min_or_max, bound, goal, newton_abstol)
                 # New beta fulfills condition
                 beta_L = beta
             else
@@ -641,26 +629,25 @@ end
     end
 
     new_alpha = 1 - beta
-    if alpha[i, j, element] > new_alpha + newton_abstol
-        error("Alpha is getting smaller. old: $(alpha[i, j, element]), new: $new_alpha")
-    else
-        alpha[i, j, element] = new_alpha
-    end
+    alpha[i, j, element] = new_alpha
 
     return nothing
 end
 
 ### Auxiliary routines for Newton's bisection method ###
 # Initial checks
-@inline function initial_check_entropy_spec_newton_idp(bound, goal, newton_abstol)
+@inline function initial_check_local_onesided_newton_idp(::typeof(min), bound,
+                                                         goal, newton_abstol)
     goal <= max(newton_abstol, abs(bound) * newton_abstol)
 end
 
-@inline function initial_check_entropy_math_newton_idp(bound, goal, newton_abstol)
+@inline function initial_check_local_onesided_newton_idp(::typeof(max), bound,
+                                                         goal, newton_abstol)
     goal >= -max(newton_abstol, abs(bound) * newton_abstol)
 end
 
-@inline initial_check_nonnegative_newton_idp(bound, goal, newton_abstol) = goal <= 0
+@inline initial_check_nonnegative_newton_idp(min_or_max, bound, goal, newton_abstol) = goal <=
+                                                                                       0
 
 # Goal and d(Goal)d(u) function
 @inline goal_function_newton_idp(variable, bound, u, equations) = bound -
@@ -671,8 +658,8 @@ end
 end
 
 # Final checks
-# final check for entropy limiting
-@inline function final_check_standard_newton_idp(bound, goal, newton_abstol)
+# final check for one-sided local limiting
+@inline function final_check_local_onesided_newton_idp(bound, goal, newton_abstol)
     abs(goal) < max(newton_abstol, abs(bound) * newton_abstol)
 end
 
diff --git a/test/test_unit.jl b/test/test_unit.jl
index ce735015012..716493a28c7 100644
--- a/test/test_unit.jl
+++ b/test/test_unit.jl
@@ -416,8 +416,9 @@ end
     indicator_hg = IndicatorHennemannGassner(1.0, 0.0, true, "variable", "cache")
     @test_nowarn show(stdout, indicator_hg)
 
-    limiter_idp = SubcellLimiterIDP(true, [1], true, [1], ["variable"], 0.1, true, true,
-                                    "cache", 1, (1.0, 1.0), 1.0)
+    limiter_idp = SubcellLimiterIDP(true, [1], true, [1], ["variable"], 0.1,
+                                    true, [(Trixi.entropy_spec, min)], "cache",
+                                    1, (1.0, 1.0), 1.0)
     @test_nowarn show(stdout, limiter_idp)
 
     # TODO: TrixiShallowWater: move unit test