RandomWalker: Custom Walks and Double Pendulum Chaos

Learn how to create custom random walk simulations in R and explore chaotic systems with double pendulum simulations, plots, and animations using RandomWalker.
code
rtip
randomwalker
Author

Steven P. Sanderson II, MPH

Published

September 8, 2026

Keywords

Programming, random walk in R, RandomWalker R Package, random walk simulation R, simulatin in R, chaotic systems in R, double pendulum R, custom random walk R, random walk visualization R, Monety Carlo simulation R, how to create a random walk in R, how to simulate a double pendulum in R, create custom random walk simulations in R, visualize a double pendulum in R with gganimate, visualize a double pendulum with ggplot2

The latest release of RandomWalker is now available on CRAN!

This release adds a couple of new tools that expand what you can simulate and visualize with the package. The two main areas are pcustom random walks and double pendulum simulations.

With custom_walk(), you can define your own step-generating function and let RandomWalker build the walks around it. The new double pendulum tools take things in a different direction, allowing us to simulate and visualize a classic chaotic physical system.

In this post, we’ll look at four functions:

Let’s take a look.

Getting Started

First, install the latest release of RandomWalker from CRAN:

install.packages("RandomWalker")

Then load it:

library(RandomWalker)

== Welcome to RandomWalker ========================================================
If you find this package useful, please leave a star: 
   https://github.com/spsanderson/RandomWalker

If you encounter a bug or want to request an enhancement please file an issue at:
   https://github.com/spsanderson/RandomWalker/issues

Thank you for using RandomWalker

Some of the double pendulum functionality uses optional packages, so you may also want:

install.packages(c(
  "deSolve",
  "ggplot2",
  "gganimate",
  "gifski"
))

Creating Your Own Random Walk with custom_walk()

One thing I’ve wanted RandomWalker to support is an easy way to say:

“I have my own rule for generating steps. Just build the random walks for me.”

That is what custom_walk() does.

Instead of choosing one of the distributions already built into RandomWalker, you provide a function that generates a single numeric step.

The basic syntax is:

custom_walk(
  .n = 100,
  .num_walks = 25,
  .initial_value = 0,
  .dimensions = 1,
  .custom_fns
)

The .custom_fns argument takes a function with no parameters that returns one numeric value.

For example, let’s create a random walk that has a small positive bias:

biased_displacement <- function() {
  rnorm(1, mean = 0.1, sd = 1)
}

set.seed(123)

walks <- custom_walk(
  .n = 100,
  .num_walks = 5,
  .custom_fns = biased_displacement,
  .initial_value = 100
)

walks |> head()
# A tibble: 6 × 8
  walk_number step_number      y cum_sum_y cum_prod_y cum_min_y cum_max_y
  <fct>             <int>  <dbl>     <dbl>      <dbl>     <dbl>     <dbl>
1 1                     1 -0.130      99.9       87.0      99.9      99.9
2 1                     2  1.66      102.       231.       99.9     102. 
3 1                     3  0.171     102.       271.       99.9     102. 
4 1                     4  0.229     102.       333.       99.9     102. 
5 1                     5  1.82      104.       937.       99.9     102. 
6 1                     6  0.561     104.      1462.       99.9     102. 
# ℹ 1 more variable: cum_mean_y <dbl>
visualize_walks(walks)

Every step is drawn from a normal distribution with a mean of 0.1.

That small positive mean gives our walks a tendency to move upward over time, although randomness can still send individual walks in very different directions.

Going Beyond One Dimension

custom_walk() supports one, two, or three dimensions.

For example:

set.seed(123)

walks_2d <- custom_walk(
  .n = 100,
  .num_walks = 5,
  .dimensions = 2,
  .custom_fns = biased_displacement,
  .initial_value = 100
)

walks_2d |> head()
# A tibble: 6 × 14
  walk_number step_number      x       y cum_sum_x cum_prod_x cum_min_x
  <fct>             <int>  <dbl>   <dbl>     <dbl>      <dbl>     <dbl>
1 1                     1 -0.130  0.357       99.9       87.0      99.9
2 1                     2  1.66  -0.147      102.       231.       99.9
3 1                     3  0.171 -0.248      102.       271.       99.9
4 1                     4  0.229 -0.852      102.       333.       99.9
5 1                     5  1.82   0.0550     104.       937.       99.9
6 1                     6  0.561 -0.685      104.      1462.       99.9
# ℹ 7 more variables: cum_max_x <dbl>, cum_mean_x <dbl>, cum_sum_y <dbl>,
#   cum_prod_y <dbl>, cum_min_y <dbl>, cum_max_y <dbl>, cum_mean_y <dbl>
visualize_walks(walks_2d)

For two dimensions, RandomWalker returns x and y coordinates. With three dimensions, you’ll get x, y, and z.

The resulting tibble also includes cumulative statistics such as cumulative sums, products, minimums, maximums, and means.

That means you can focus on defining how a step behaves, while RandomWalker handles the structure of the simulation.

See the full custom_walk() documentation.

From Random Walks to Chaos: The Double Pendulum

The other major addition in this release is something a little different.

A double pendulum consists of one pendulum attached to another pendulum.

It sounds simple.

Its behavior isn’t.

Double pendulums are well-known examples of chaotic systems. Very small changes in their starting conditions can eventually produce dramatically different trajectories.

RandomWalker now lets us simulate this directly.

Simulating with double_pendulum_walk()

The new double_pendulum_walk() function simulates a planar, frictionless double pendulum.

A simple simulation looks like this:

set.seed(287)

pendulum <- double_pendulum_walk(
  .num_walks = 5,
  .n = 401
)

pendulum |> head()
# A tibble: 6 × 11
  walk_number step_number  time theta1 theta2 omega1     omega2    x1       y1
  <fct>             <int> <dbl>  <dbl>  <dbl>  <dbl>      <dbl> <dbl>    <dbl>
1 1                     1  0      1.59   1.56  0      0         1.000  0.0145 
2 1                     2  0.05   1.57   1.56 -0.490 -0.0000959 1.000  0.00223
3 1                     3  0.1    1.54   1.56 -0.981 -0.000333  0.999 -0.0345 
4 1                     4  0.15   1.48   1.56 -1.46  -0.0114    0.995 -0.0956 
5 1                     5  0.2    1.39   1.55 -1.92  -0.0628    0.984 -0.180  
6 1                     6  0.25   1.28   1.55 -2.33  -0.203     0.959 -0.283  
# ℹ 2 more variables: x <dbl>, y <dbl>

The default simulation samples the system every 0.05 seconds for 401 observations, giving us 20 seconds of motion.

The returned tibble contains quite a bit of information:

walk_number
step_number
time
theta1
theta2
omega1
omega2
x1
y1
x
y

Here:

  • theta1 and theta2 are the pendulum angles.
  • omega1 and omega2 are their angular velocities.
  • x1 and y1 describe the position of the first bob.
  • x and y describe the position of the second bob.

Where Does the Randomness Come From?

There is an important distinction here. The double pendulum isn’t receiving random forces throughout the simulation. Instead, RandomWalker slightly perturbs the initial angles.

The default is:

.angle_sd = 0.01

Once those initial conditions are created, the motion follows the deterministic equations of the double pendulum. This gives us a nice way to explore a fundamental idea behind chaos:

Nearly identical starting conditions do not necessarily produce nearly identical long-term behavior.

Try increasing the variation:

set.seed(123)

pendulum <- double_pendulum_walk(
  .num_walks = 10,
  .n = 401,
  .angle_sd = 0.05
)

pendulum |> head()
# A tibble: 6 × 11
  walk_number step_number  time theta1 theta2 omega1    omega2    x1      y1
  <fct>             <int> <dbl>  <dbl>  <dbl>  <dbl>     <dbl> <dbl>   <dbl>
1 1                     1  0      1.54   1.56  0      0        1.000 -0.0280
2 1                     2  0.05   1.53   1.56 -0.490 -0.000852 0.999 -0.0403
3 1                     3  0.1    1.49   1.56 -0.977 -0.00618  0.997 -0.0769
4 1                     4  0.15   1.43   1.56 -1.45  -0.0304   0.991 -0.137 
5 1                     5  0.2    1.35   1.56 -1.90  -0.105    0.976 -0.220 
6 1                     6  0.25   1.24   1.55 -2.29  -0.273    0.947 -0.321 
# ℹ 2 more variables: x <dbl>, y <dbl>

Now we’re creating ten slightly different initial conditions and watching how their trajectories evolve.

You can also experiment with the masses, rod lengths, gravity, initial angles, and initial angular velocities.

See the full double_pendulum_walk() documentation.

Plotting the Double Pendulum

Generating the data is useful, but this simulation becomes much easier to understand when we visualize it.

That’s where plot_double_pendulum() comes in.

set.seed(123)

pendulum <- double_pendulum_walk(
  .num_walks = 3,
  .n = 401
)

plot_double_pendulum(
  pendulum,
  .walk = 1
)

The function creates a ggplot2 visualization of the spatial trajectory followed by the second bob. The trajectory is colored according to elapsed time, making it easier to see how the system moves through space. Because the result is a ggplot object, you can also customize it using normal ggplot2 tools.

For example:

library(ggplot2)
Warning: package 'ggplot2' was built under R version 4.6.1
plot_double_pendulum(
  pendulum,
  .walk = 1
) +
  labs(
    title = "Double Pendulum Trajectory",
    subtitle = "Spatial path of the second pendulum bob"
  ) +
  theme_minimal()

You can also compare individual trajectories:

plot_double_pendulum(pendulum, .walk = 1)

plot_double_pendulum(pendulum, .walk = 2)

plot_double_pendulum(pendulum, .walk = 3)

Remember that these walks began with only small differences in their starting angles. Seeing their paths diverge is where the simulation becomes especially interesting. See the full plot_double_pendulum() documentation.

Bringing the Simulation to Life

A static trajectory shows us where the pendulum traveled. An animation shows us how it got there. The animate_double_pendulum() function creates a gganimate object from the simulation data.

animation <- animate_double_pendulum(
  pendulum,
  .walk = 1
)

animation

You can control how much of the recent path remains visible using .trail_length:

animation <- animate_double_pendulum(
  pendulum,
  .walk = 1,
  .trail_length = 50
)

Setting:

.trail_length = 0

turns the trail off completely.

To render the animation as a GIF:

library(gganimate)

gif <- animate(
  animation,
  nframes = attr(pendulum, "n"),
  fps = 1 / attr(pendulum, "delta_time"),
  renderer = gifski_renderer()
)

anim_save(
  "double-pendulum.gif",
  animation = gif
)

Using the simulation’s delta_time to calculate the frame rate lets the animation correspond to simulated time. This is probably my favorite way to explore the new double pendulum functionality because you can actually watch the chaotic motion develop. See the full animate_double_pendulum() documentation.

Why Add a Double Pendulum to RandomWalker?

You might reasonably ask:

Is a double pendulum really a random walk?

Not in the traditional sense.

A traditional random walk introduces randomness as the process evolves. The double pendulum simulation instead introduces randomness into the initial conditions, after which the equations governing the system are deterministic.

I think that makes it an interesting addition to RandomWalker. It gives us another way to explore the relationship between:

randomness → simulation → trajectories → uncertainty

A traditional random walk asks what happens when individual steps are random. The double pendulum asks what happens when the starting point is slightly uncertain but the system itself follows deterministic rules. Those are different ideas, but putting them next to each other can help us build intuition about simulation and uncertainty.

Your Turn!

Now it’s your turn.

Let’s combine the ideas from this release into two small challenges.

Challenge 1: Build Your Own Random Walk

Create a custom step function using a Student’s t-distribution:

my_step <- function() {
  # Your code here
}

Then generate:

  • 10 random walks
  • 250 steps each
  • 2 dimensions
  • an initial value of 0

Think about what you expect the walks to look like compared with steps generated from a normal distribution.

💡 See Solution 
my_step <- function() {
  rt(1, df = 3)
}

set.seed(123)

my_walks <- custom_walk(
  .n = 250,
  .num_walks = 10,
  .initial_value = 0,
  .dimensions = 2,
  .custom_fns = my_step
)

my_walks

Now change:

df = 3

to:

df = 30

How does the behavior change?

What happens to the frequency of unusually large steps?

Challenge 2: Create Some Chaos

Create five double pendulum trajectories:

set.seed(123)

chaos <- double_pendulum_walk(
  .num_walks = 5,
  .n = 401,
  .angle_sd = 0.001
)

Start with a very small perturbation of:

.angle_sd = 0.001

Plot the first trajectory:

plot_double_pendulum(
  chaos,
  .walk = 1
)

Then compare it with:

plot_double_pendulum(
  chaos,
  .walk = 2
)

Finally, animate one:

animation <- animate_double_pendulum(
  chaos,
  .walk = 1,
  .trail_length = 40
)

Now repeat the experiment with:

.angle_sd = 0.01

and then:

.angle_sd = 0.1

What do you notice?

How quickly do the trajectories begin to look different as you increase the uncertainty in the initial conditions?

Quick Takeaways

This RandomWalker release adds some interesting new possibilities.

custom_walk() gives you much more control over how random steps are generated. Instead of being limited to distributions already included in the package, you can supply your own function and create one-, two-, or three-dimensional simulations.

double_pendulum_walk() adds a different type of simulation: deterministic dynamics beginning from randomized initial conditions.

plot_double_pendulum() makes those trajectories easy to inspect using ggplot2.

And animate_double_pendulum() lets you watch the system evolve over time.

Together, these functions expand RandomWalker beyond predefined random-walk generators and give you more room to experiment with randomness, simulation, trajectories, and chaotic behavior.

Conclusion

One of the main ideas behind RandomWalker has always been making simulation approachable.

You shouldn’t need a large amount of setup code just to experiment with a random process.

With custom_walk(), the package becomes more flexible because you define the step-generating rule.

With the new double pendulum functions, we can also explore what happens when tiny amounts of uncertainty are introduced into the starting conditions of a deterministic system.

If you’ve installed the new release, give these functions a try.

More importantly, change the parameters.

Change the distribution.

Change the starting angles.

Change the amount of perturbation.

Increase the number of simulations.

And see what happens.

That’s often where simulation becomes the most useful.

Happy Coding! 🚀

You can connect with me at any one of the below:

Telegram Channel here: https://t.me/steveondata

LinkedIn Network here: https://www.linkedin.com/in/spsanderson/

GitHub Network here: https://github.com/spsanderson

My Book: Extending Excel with Python and R here: https://packt.link/oTyZJ

You.com Referral Link: https://you.com/join/EHSLDTL6

@online{randomwalker_custom_random_walks_and_double_pendulum_simulations_20260908, author = {Sanderson II MPH, Steven P.}, title = {RandomWalker: Custom Random Walks and Double Pendulum Simulations}, date = {2026-09-08}, url = {https://www.spsanderson.com/steveondata/posts/2026-09-08/}, langid = {en} }