×


Adjust image size under "window options" below.

go to location by center and scale
? At scales above 3.0e13, perturbation theory math must be used, which is slower than the floating point math that can be used at smaller scales.
center x:
center y:
 
scale:
scale is (pixels/unit) so bigger = more zoom
magnif-
ication:
magnification of 1 shows the entire plot. 2 shows the plot at 2x the size, 5e2 at 500x, etc.
go to location by bounds
? The entered points will be fit into the screen. Depending on the window proportions, additional area beyond the entered points may be displayed.
top left x:
top left y:
 
bottom right x:
bottom right y:
iterations
iterations:
gradient editor
? Enter a series of colors to form a gradient with which to draw the plot.

Colors are entered as a single letter:
  • r - red
  • o - orange
  • y - yellow
  • g - green
  • b - blue
  • v - violet/purple
  • p - violet/purple
  • w - white
  • B - Black
Colors may be defined or re-defined with an option like "o.f1593c" which defines a hex orange color for the letter o, or like "G~90.90.90" which defines an rgb gray color for the letter G.

Options: after the series of color letters are given, zero or more gradient options may be entered. Each option must be preceded with a dash "-".
  • mod# - where # is the modulo to take for the number of values of N (for Mandelbrot, iterations) for each pixel (for example, if a pixel has 10,123 iterations, and mod10000 is used, the pixel will be colored as if it had 123 iterations) (this is incompatible with the "width" option)
  • repeat# - where # is the number of times to repeat the color series
  • shift# - where # is the number of colors to shift off the end of the series and move onto the beginning
  • mirror# - like "repeat" but adds the reverse of the entire series from one repetition to the next
  • width# - where # is the percentage of width the gradient should be squeezed into (if not given, the gradient takes up 100% of the possible colors to draw) (this is incompatible with the "mod" option)
  • offset# - where # is the percentage to move the gradient if squeezed into a smaller width using the "width" option (for gradients with the mod option, offset is a number to add to the value of the pixel before taking the modulus)
Examples:

"roygbv-mod1000" creates a rainbow gradient that repeats every 1000 values of N (for mod plots only, like Mandelbrot set)

"roygbv-repeat2" creates a gradient with "roygbvroygbv"

"pBpw-p~240.160.200" creates a gradient with "p" re-defined as pink

"roygbv-mirror1" creates a gradient with "roygbvbgyor"

"roygbv-width25-offset75" creates a rainbow gradient squeezed down to 25% of the available width, and moved all the way to the top end of the available width
gradient:
preset:
add color:
smooth and slope
? The "large bailout" option increases the bailout value for the Mandelbrot set algorithm to use while calculating iterations for each pixel. When unchecked, the bailout value is the smallest possible bailout which allows faster computation for all locations. When enabled, the bailout value is much larger which allows a few more iterations to occur for each pixel. This is required for smooth coloring and slope shading. If you don't want to enable smooth coloring or slope shading (while exploring, for example), you can turn this off for faster rendering.

 The "smooth" option creates smooth transitions between colors, and is especially useful with the "slope shading" options. It requires the "large bailout" option.

The "slope shading" option uses the final image to compute a local slope value for each pixel based on its neighboring pixels, and uses that information to add highlights and shadows. This creates a 3D shading effect similar to relief carving. Choose the location of the light source, and a depth value between 1 and 64.
large bailout: (changing causes full re-render)
smooth:
slope shading: (smooth recommended)
slope depth: 1-64
workers options
? Increase workers to increase computation speed, depending on your computer/device.

Increasing the number of workers will cause your computer/device to consume more power/battery, but the computation will be completed faster.

Increasing the number of workers beyond a certain point will have no effect depending on the number of cores/threads your computer or browser can devote to this page.

Very Plotter uses one thread for the user interface and one for worker management. Therefore if you want maximum performance, I recommend running one or two fewer workers than your computer core/thread count. For example, if your computer has 8 high-performance cores/threads, I recommend using 6 or 7 workers. If your computer has 4 high-performance cores and 4 efficiency cores, I recommend using 4 workers. But of course, your results may vary depending on many factors.
window options
? Turn on window lock if you are running a long render. It will prevent the render from restarting if the browser asks the window to resize itself (which can happen when switching browser tabs, or turning off your monitor). Window lock will also disable the keyboard and mouse controls (again, to avoid interfering with a long-running render). Otherwise, it's probably best left off.

With photo editing software, you can resize the full size render down for a smaller, smoother-looking image.
window lock:
render size:
Smaller images are fast, and good for exploring. Larger images have much more detail but take a lot more time to render. Use the "Save Image" button to download the full-size render.
algorithm options
? The "auto" option picks the algorithm depending on the scale. Users that are familiar with Mandelbrot set calculation algorithms may be able to select a better-performing algorithm at specific locations.

The "stripes" options use an alternate coloring algorithm. Stripes coloring is currently implemented for the basic and perturbation theory algorithms, but not for series approximation and arbitrary-precision numbers used for the super-deep zooms (beyond scales of 1e100). For those deep locations, regular iteration count coloring will work far better.

When using "stripes" coloring, you'll likely want to use a "-mod#" option with your gradient with a much higher modulus number than you'd use for regular iteration coloring. For example, if you would use "-mod500" with iteration coloring, try starting with "-mod50000" for stripes coloring.
algorithm:
options:
chunk ordering
? By default, vertical stripes of pixels (chunks) are drawn in random order. This helps provide a sense of the overall image earlier than if the chunks were drawn left-to-right. While exploring very slow locations, enabling "center first" order may allow you to decide more quickly whether to continue zooming in.
chunk order:
animation options
loop:
step interval:
×

tips for the Mandelbrot set plot (more tips)

screen black? increase iterations with M key or settings menu

too slow? add a few workers with U key or settings menu

mouse

drag mouse to move — scroll mouse wheel to zoom

hold alt (option on Mac) and drag mouse to zoom

hold shift and click to re-center (good for slow-to-draw plots)

keyboard (or click/tap key icons below)

help
 H
plots
 P
controls
  O
presets
 1 - 5
center at (0,0)
      C

move
  W
ASD
move less
     ↑
  ←↓→
zoom
Q  E
zoom less
   − +

line width
    Z
fewer/more points
    N M

change plot
    X
line color
    V
bg color
   B

show mouse pos
    R
show params
    T

fewer/more workers
    Y U
stop
 Esc