Router Rumble: How a WiFi Router Demo Shows Why Gradient Descent Loses to NSGA-II

When an optimization problem's objective function is no longer smooth and continuous, classical gradient descent hits a wall. Developer Austin Starks has open-sourced a Python experiment called Router Rumble that visualizes the difference between gradient descent and the evolutionary algorithm NSGA-II through an intuitive scenario: placing a WiFi router in a simulated room.

A Visible Optimization Challenge

The experiment's setup is refreshingly concrete: place a WiFi router inside a simulated home environment with the goal of maximizing signal coverage. The objective function counts the number of locations that receive a signal strength of at least −57 dBm, out of a total of 560 sampling points.

The critical issue is that this objective function is "staircase-shaped" — the coverage count changes in discrete integer steps rather than along a smooth curve. This is precisely where gradient descent falls short. The project records the search process and renders it as a GIF playback, letting you watch both algorithms "find a spot" in the same room.

Why Gradient Descent Gets Stuck

Gradient descent's working mechanism is what limits it here. In Router Rumble, it starts from a single location and tests the four neighboring positions. Because the objective function is discrete, those four neighbors return the same coverage count, so the algorithm estimates a slope of zero — it concludes it has reached a flat region with nowhere to go.

The result: gradient descent stalls at 100 covered locations and can improve no further. This isn't a bug in the implementation; it's a fundamental weakness of gradient-based methods on non-smooth, discrete objectives. Without usable gradient information, there's no direction to move in.

This phenomenon is known in optimization theory as a "pseudo-plateau" — not a true local optimum, but a gradient blind spot caused by the discrete nature of the objective function. Finite difference is a common substitute for gradient descent when no analytic gradient is available: it approximates the derivative by computing differences in function values at neighboring points. But when the sampling step is smaller than the objective function's minimum change unit, the difference is always zero and gradient estimation breaks down entirely. Router Rumble's four-neighbor probing is essentially this kind of finite difference, and the fact that signal coverage jumps in integer increments means no sufficiently small step can detect a change in function value. Even increasing the step size just degrades the algorithm to random sampling, losing the directional advantage that gradient descent is supposed to provide.

NSGA-II's Population Advantage

NSGA-II takes a completely different approach. As an evolutionary algorithm, it maintains a population of 32 locations scattered across the entire room, exploring simultaneously. This population-based search doesn't rely on gradients — instead, it iteratively improves through selection, crossover, and mutation.

Ultimately, NSGA-II reaches 209 out of 560 sampling locations in coverage, far surpassing gradient descent's 100. Notably, this example uses NSGA-II with only a single objective — the algorithm was originally designed for multi-objective optimization, yet it still demonstrates superior adaptability to discrete problems in a single-objective setting.

NSGA-II (Non-dominated Sorting Genetic Algorithm II) was proposed by Deb et al. in 2002 and is a classic algorithm in multi-objective evolutionary optimization. Its core mechanisms are twofold: non-dominated sorting layers the population by Pareto fronts, ensuring high-quality solutions are preserved; crowding distance measures how sparse individuals are in objective space, preventing the population from clustering in any one local region. Together, these mechanisms maintain both selection pressure toward good solutions and sufficient diversity throughout the search. In Router Rumble's single-objective scenario, non-dominated sorting reduces to simple value comparison, but the global exploration capability brought by population diversity remains the key advantage over gradient descent. pymoo is a Python library specifically implementing multi-objective optimization algorithms, providing ready-to-use implementations of NSGA-II and its variants.

A Fair Experimental Design

To make the comparison credible, the author gives both methods the same "budget": 1,200 objective function evaluations each, including initialization and local probing. The only difference is the starting point — gradient descent begins from a single location, while NSGA-II begins from a population spread across the room.

Beyond this core discrete-objective comparison, the repository includes more complete experimental content:

• Smooth objective function comparisons, showing how both methods perform when gradients are available
• Results across 20 random seeds, validating that the conclusions are robust rather than coincidental
• Interactive playback, letting users scrub frame-by-frame through the search process

Running Locally and Tunable Parameters

The engineering barrier to entry is low — the project is built on NumPy and pymoo, with no GPU required and no API keys needed. Just clone and run:

git clone https://github.com/austin-starks/router-rumble.git
cd router-rumble
uv run run_demo.py

More importantly, it's highly explorable — users can freely modify wall layouts, signal strength targets, random seeds, and evaluation budgets, then rerun the experiment. This makes it more than a static demo; it's a sandbox for teaching and exploration.

Implications for Algorithm Selection

Router Rumble's value lies in using a minimal scenario to illustrate an important principle: algorithm selection must match the nature of the problem. Gradient descent is efficient and reliable for smooth, differentiable continuous optimization, but when faced with discrete, staircase-shaped, or heavily noisy objective functions, the absence of gradient information leaves it unable to make progress.

Gradient-free methods like evolutionary algorithms carry higher computational costs and slower convergence, yet they can find viable solutions on these kinds of "rugged terrain" problems. For developers working on hyperparameter search, engineering layout optimization, or combinatorial optimization, this is an intuitive reference case worth bookmarking.

Gradient-free optimization is a broader family of methods than just evolutionary algorithms — it also includes Bayesian optimization, simulated annealing, particle swarm optimization, and the Nelder-Mead simplex method. What these approaches share is that they rely only on the output values of the objective function, without requiring it to be continuous or differentiable. In practice, gradient-free methods are worth considering when: the objective function involves simulation, experiments, or external system calls (black-box optimization); the parameter space includes discrete or categorical variables; or function evaluations are extremely expensive and you need to make efficient use of a limited query budget. Bayesian optimization generally outperforms evolutionary algorithms when the number of evaluations is very small, because it actively builds a surrogate model of the objective function to guide the search. Evolutionary algorithms have the edge when parallel compute resources are abundant, since an entire generation of the population can be evaluated simultaneously.