Robotic Arm Trajectory Planning Based on Improved Slime Mold Algorithm

If you're hiking deep in the forest, the last thing you'd expect to encounter is...well...anything that has to do with computer science. But in shady woodlands around the world, that's exactly what you find. In the form of: slime mold. It's not a plant, it's not an animal, and it's not fungi. It's what's called a "protist". It's a brightly-colored (often yellow), thin layer of gooey film that looks a bit like spilled egg yolk. It stretches across the forest floor and wraps itself around leaves and branches. You'll find it growing on tree trunks, and piles of wet leaves, and rotting wood, and moss. And as it turns out, slime mold is particularly good at one thing: finding efficient routes through complex environments. You see, slime mold is hungry...all the time. And it's constantly looking for new things to eat, whether that be bits of bark or decaying leaves. And this is true even when it already has a food source to use. It wants to keep eating the food it already has while simultaneously finding more. More, more, more. It never stops. But it can't track food down or scavenge in the usual sense. So to find its next meal, it spreads out in all directions, then pulls back to leave only the most direct connection between its current food sources. What you're left with is a series of points (food sources) connected by a network of perfectly efficient paths. And that behavior (the ability to discover optimal routes without any central control) has made it the subject of a lot of attention from computer scientists.

Back in 2020, Li et al published a paper called, fittingly: Slime Mould Algorithm: A New Method for Stochastic Optimization. In it, they laid out a metaheuristic (the type you'd use to solve path-planning or resource-allocation problems), that's designed to mimic the real thing. It spreads out, senses gradients, and adapts its structure over time. By optimizing for proximity and "nutrient" concentration, it's able to explore widely and then converge precisely.

And since its publication, use of the Slime Mould Algorithm (SMA) has exploded. It's now used in scheduling and energy systems, in image processing and heavy machinery. You'll see SMA references in papers on everything from network optimization to route optimization. And today we're looking at a new paper that follows this trend. This time, the authors are applying the slime mold algorithm to robotic arm trajectory planning. They've built a model that smooths motion paths while minimizing vibration and impact. By using SMA to optimize B-spline trajectories, they're able to shorten movement time and reduce joint stress without sacrificing precision. On today's episode we're going to dive into how their system works, how they built it, how they tested it, and the results they obtained. Let's dive in.

Imagine you're watching a factory robot on an assembly line. It picks up a part, moves through space, and places it precisely where it needs to go. The movement looks smooth, deliberate, almost organic. But what you're not seeing is the computational nightmare happening under the hood. That robotic arm isn't just moving from point A to point B. It's solving a multidimensional optimization problem in real time, one that involves minimizing movement time while also minimizing something called impact force. These impact forces, which spike during rapid changes in motion, cause vibration and wear. Over time, they degrade mechanical components, reduce precision, and shorten the arm's lifespan. So the question isn't just "how do we get there fast?" It's "how do we get there fast, smoothly, and without destroying the hardware in the process?"

Traditional trajectory planning methods struggle with these kinds of multi-objective challenges. They either optimize for time or they optimize for smoothness, but rarely both. And even when they try, they often produce motion curves with abrupt changes in velocity or acceleration that create exactly the kind of destructive impacts that the system is trying to avoid. The challenge is that this is a constrained optimization problem. You can't just minimize time. You also have to respect physical limits on joint angles, angular velocities, angular accelerations, and something called jerk, which is the rate of change of acceleration. Jerk is what causes those destructive impacts I mentioned earlier.

What makes this problem particularly tough is that the constraints interact in complex nonlinear ways. A trajectory that minimizes time might violate acceleration limits. A trajectory that satisfies all kinematic constraints might take too long or produce excessive wear. And because robotic arms operate in "joint space" rather than in Cartesian space, you're not just planning a path through three-dimensional coordinates. You're planning synchronized motion across six or more rotating joints, each with its own constraints and dynamics. The search space is, therefore, high-dimensional, non-convex, and full of local optima.

Not fun.

That's where SMA comes in. It treats potential solutions as positions in a search space. It initializes a population of candidate solutions, then iteratively updates their positions based on three mechanisms.

First, there's a contraction mode where solutions move toward the current best position, simulating how slime moulds concentrate biomass near food sources. This is controlled by a weight factor that's calculated based on the fitness ranking of each solution. Solutions in the top half of the population get positive weights that pull them toward high-quality regions, while solutions in the bottom half get negative weights that push them away. Second, there's an oscillation mechanism that allows solutions to explore regions around the best position without collapsing immediately. This parameter oscillates randomly and gradually converges to zero as iterations progress. This creates a search pattern that's aggressive early on and more refined later.

And third, there's a random exploration mode that helps the algorithm avoid getting stuck in local optima by occasionally jumping to entirely new regions of the space. Not that much though, it happens with a small probability to ensure the algorithm doesn't settle prematurely on a suboptimal solution. The position update works like this: if a random threshold is met based on solution quality, the new position moves toward the best known position, adjusted by a weighted combination of two randomly selected solutions. Otherwise, the position updates based on the oscillation parameter, multiplied by the current position. The oscillation range starts large to encourage exploration, then shrinks over time to enable refinement. This ensures that large exploratory jumps happen early, and small refinements happen late.

The original SMA formulation was pretty good. It converged quickly, handled high-dimensional problems reasonably well, and didn't require gradient information. But it wasn't perfect. One of its main weaknesses was that the initial population was generated randomly. This meant that the distribution of starting positions could be uneven. This affected both convergence speed and solution quality. Another issue was that the feedback mechanisms weren't adaptive. The oscillation parameter decreased linearly regardless of how the search was actually progressing. And finally, the algorithm could struggle with local optima in complex landscapes, especially when the problem had many competing objectives.

So the authors of this paper made five specific modifications to address these weaknesses. Let's walk through them.

• First, they replaced random initialization with Bernoulli chaotic mapping. Chaotic maps are deterministic functions that generate sequences of numbers with properties similar to random sequences, but with better coverage of the search space. The Bernoulli map is defined by a piecewise function that produces values based on whether the current position falls above or below a threshold. The parameter controlling this threshold determines how the map behaves, and the authors found experimentally that a specific mid-range value gives the best performance. What makes Bernoulli mapping better is its ergodic property. The sequence it generates visits every region of the space more uniformly than pseudo-random number generators, which tend to cluster. This gives the algorithm a better starting point, improving both convergence speed and solution quality.
• Second, they introduced an adaptive feedback factor to replace the linear decay of the oscillation parameter. The new approach uses exponential decay that drops quickly in early iterations, (encouraging broad exploration) then stabilizes in later iterations to enable fine-tuned exploitation.
• Third, they added a crossover operator. At each iteration, with some probability, the algorithm takes a current solution and the current best solution and generates two offspring using weighted combinations. This accelerates convergence by allowing good solutions to propagate through the population more quickly.
• Fourth, they integrated an improved artificial bee colony search strategy. The artificial bee colony algorithm uses employed bees to generate new candidate solutions by perturbing existing ones. The original approach moves along the vector between two existing solutions. The authors improved this by adding guidance from the global best solution. Their modified version creates new solutions by moving along the original vector but also pulling toward the best known position. This modification biases the search toward promising regions without eliminating exploration entirely.
• And fifth, they added quadratic interpolation for local refinement. This technique takes three candidate solutions and fits a parabola through them based on their fitness values, then uses the parabola's minimum as a new candidate solution. The new position is calculated as a weighted combination of the three original positions, where the weights depend on both the positions themselves and their fitness values. This quadratic interpolation is particularly useful in the late stages of optimization when the algorithm is refining its search around a narrow region. It helps squeeze out additional accuracy without requiring many additional function evaluations.

So how did they apply this to trajectory planning for the robotic arm? That's where B-splines come in. A B-spline is a mathematical curve defined by a series of control points, and it's often used in robotics because it produces smooth, continuous paths that can be tightly constrained by velocity and acceleration limits. Here the authors used a seventh-order non-uniform B-spline to represent the motion of each joint in the arm. Each segment of the curve describes how a joint moves from one position to the next, while the shape of the curve determines how quickly and smoothly it transitions. The SMA is then used to tune these control points, optimizing the path to minimize movement time, vibration, and impact force, essentially teaching the arm to move as efficiently and gently as possible. Once the B-spline representation was set up, they defined an objective function that captured what they wanted the arm to optimize for (shorter motion time, less vibration, and minimal impact at each joint). The algorithm then searched through possible B-spline shapes, adjusting the control points until that objective function was minimized. In other words, it wasn't just drawing a smooth curve, it was mathematically shaping one that made the arm's movement as efficient as possible.

They validated the result both in simulation and on a physical robot. In simulation, they visualized the arm moving through three-dimensional space, confirming that it avoided all obstacles and reached the target position correctly. On the physical robot, they loaded the trajectory into the controller and executed it. The robot moved smoothly with no vibration or jerky motions. The sound was consistent, with no sudden changes in motor pitch that would indicate acceleration spikes. And the endpoint tracking was accurate, reaching the target within the expected precision. Then they ran the experiment with obstacles placed in the workspace. These were cylinders and rectangular boxes positioned at various locations. The algorithm adapted to the additional constraints without requiring manual tuning. It found trajectories that navigated around the obstacles while maintaining smooth motion. This demonstrates the algorithm's flexibility and its ability to handle real-world complexity.

The key takeaway here is that metaheuristic optimization, when properly designed, can solve complex trajectory planning problems that would be difficult or impossible to solve with traditional methods. If you're working on robotic motion planning, or if you're exploring metaheuristic algorithms for constrained optimization, this paper is worth downloading. The authors provide more than the algorithmic details: they include flowcharts, full convergence plots for all test functions, breakdowns of the B-spline construction process, and the robot's experimental results with photos showing the arm at each waypoint. All these materials should be useful if you're going to try to replicate this work yourself.