The app at 1.06×10500 magnification — a Misiurewicz spiral, Newton-refined to 522 digits — with the linked Julia view of the point it is centred on, in the Ember palette. The Controls panel shows the colouring and quality settings. This shot regenerates from a location file in the repository, so it can be reproduced exactly.
Fractadyne renders the Mandelbrot set and its relatives on the GPU, and keeps rendering them correctly far past the point where ordinary floating point falls apart.
Zoom deep enough into a fractal and the arithmetic runs out of precision long before the detail does. Fractadyne carries the centre of the view in arbitrary precision, computes one exact reference orbit on the CPU, and expresses every pixel as a small deviation from it — switching number formats automatically as the view deepens. So the depth you can reach is set mostly by patience and by how much work the GPU will take, rather than by the arithmetic giving out.
It is free, open source, and a single self-contained executable: no installer, no runtime, no account.
This is a work in progress. Fractadyne is under active development and has not had a wide release. It is written and tested mostly on one machine, so other GPUs and drivers are the least-proven part of it, and deep views in particular are still being worked on. There is a list of the current rough edges further down — please read it before deciding whether it is worth your time, and if something breaks, a report genuinely helps.
Unzip and run fractadyne.exe — 64-bit Windows 10 or 11, and a GPU with Vulkan,
DirectX 12 or OpenGL. Nothing is installed; delete the folder to remove it.
⚠Which build. The current build is v0.3.0-beta.9, a beta. The
0.3.0 betas continue the v0.2.41 series under a new version number. The
first button opens its release page, where the Windows zip, the Linux tarballs and the
accelerated variants all live; the few betas before it stay listed on the releases page. The old
stable v0.2.40 has been withdrawn so that nobody lands on a build a month behind.
Expect the Linux binaries to be less tested than the Windows build, because they are.
The releases page also carries downloads ending -accelerated — a .zip
for Windows and, from v0.2.41-beta.20, a .tar.gz for Linux. They are
optional and explained further down.
-accelerated downloadIt is the same program as the standard build, with one difference: it computes deep-zoom reference orbits using the MPFR and GMP libraries instead of the pure-Rust arithmetic the standard build uses. That step is the CPU pause before a deep view starts resolving, and it runs roughly 2.5× to 6.4× faster there, more so the deeper you go.
It is not a general speed-up. It does not raise the frame rate, and it does not change the picture — the two builds produce byte-identical images. That is checked rather than assumed: the same reference orbits across every formula, at arithmetic widths from 64 bits to 132,000, plus the whole 39-location comparison corpus. A difference between them would be a bug worth reporting.
.dll files next to fractadyne.exe; it will
not start without them.Why it is a separate download, rather than simply being the build: MPFR cannot be built with the Microsoft compiler the standard Windows binary uses, so it comes from a different toolchain; and MPFR and GMP are licensed under the GNU LGPL v3, while Fractadyne itself is MIT OR Apache-2.0. Keeping them in a separate, clearly labelled download leaves the standard build free of those terms. The full notices and licence texts are inside the zip.
If you do not need it, take the plain download. The app will offer you this one later under
Help → Faster deep zoom, linked to the version and platform you are running. The Linux
accelerated tarball (beta track, from v0.2.41-beta.20) uses the system's GMP and
MPFR rather than bundling them, and needs GMP 6.3 and glibc 2.39 or newer — Ubuntu 24.04 or
equivalent — where the standard Linux build runs on 22.04.
Past about 104×, where the direct mode ends, a moving view used to show its last complete picture stretched to follow the zoom — about 1.5× on average — while the next one was rebuilt over a dozen frames or more, even when the graphics card could draw the whole frame in a few milliseconds. Now a frame measured as cheap is drawn fresh and shown at once. A dearer one, up to 36 ms of GPU work, is drawn in up to eight pieces, one per displayed frame, each a checkerboard of small squares spread over the whole picture, while the previous picture follows the zoom until the last piece lands. On the development card (an RTX 3080 at 120 Hz, a 1280×800 window) the picture during a zoom from 106× to 1012× is now stretched about 1.08× instead of 1.54–1.60×, at 120 frames a second, and from 1012× to 1018× about 1.2× instead of 1.65×. Deeper than that the view behaves as before.
The automatic iteration count also stops climbing on views that do not need it: at the whole-set view it could run ten times higher than necessary for the rest of the session. On the Radeon RX 6800 XT at a 1280×800 window the new drawing cannot make a piece cheaper than the whole frame, so it stays out of the way there, and that fix is what shows: a zoom from 104× to 4×109× at 60 Hz now shows its picture stretched about 1.5× instead of 2.2–3.2×.
The 150 betas since v0.2.40 went out as v0.2.41-beta.N. This
release marks that run as 0.3.0: it has the code of the last 0.2.41 beta, and the
changelog
now opens with a summary of the whole series by theme. It is still a beta, and the app's beta
update track offers it as the next build.
Deep exports are faster again. An export renders the picture in tiles, one after another, and each tile was sized as if every pixel ran every iteration, so at high iteration counts the tiles were too small to keep the graphics card busy. Deep tiles are now much larger, and what keeps each piece of GPU work short is a limit on the steps each pixel may take in it. On the development card a 4K image at 10148× takes 6.4 seconds instead of 11.5, and at 10275× 2.5 instead of 4.1. On the Radeon RX 6800 XT the graphics card's share at 10148× fell from 6.9 to 4.4 seconds, and no single piece of work took longer than 176 ms. The new and old tiling produce identical pictures. The changed GPU program moves 3 pixels of 8.3 million at 10275× in the standard build compared with the previous beta, and the standard and accelerated builds now agree there exactly, as they do at the other scenes checked. The log also reports the GPU time of every export and how long writing the image took.
Deep renders are many times faster: on the development card a 4K image at
101105× now takes 2.5 seconds, where beta.139 took 76. Four changes do
most of it. Exports of Mandelbrot and Multibrot views no longer run glitch correction — a
new check against exact arithmetic found that it repaired nothing there and made a few pixels
worse. The work before rendering starts (the reference orbit and the series approximation)
is no longer repeated, and runs in parallel. A deep step switches to cheaper arithmetic once
that is safe. And a command-line --render starts that work before its window
opens. Dropping glitch correction changes a few pixels, for the better wherever the check can
tell, and on the development card the cheaper arithmetic changes up to 0.14% of pixels by
fractions of an iteration; the other changes leave the picture identical to the pixel.
A new safety stop catches a frame that runs dangerously long and backs the app's frame budget off. On the Radeon RX 6800 XT, in a test that recreates the conditions of an earlier driver reset, it kept the machine running where the previous build hung it. Each graphics card also gets a fixed cap on how much work it is given at once. Zooming no longer freezes on a blown-up picture that looked like a single colour, and a command-line render that takes longer than about a second no longer reports a failure it did not have.
The auto-zoom (the A key, or the ship's-wheel button) now steers toward the
richest edge in view instead of drifting into flat, empty regions, and eases into its dive
instead of sliding sideways as it starts. It no longer flashes to black or to a single colour
while it moves, and at extreme depth it goes blank far less often. A new Auto-zoom
priority chooses between speed and picture quality, and Auto-zoom target can
now pick the nearest Misiurewicz point and dive into it exactly. View → Show
auto-zoom target draws where it is heading, and when it stops because the iteration
count ran out, it says so.
Behind that, the app now keeps a record of the last few thousand frames it drew — what it was asked for, what the GPU did and what reached the screen — in a file that survives the app being killed, and a crash report carries it. Every build names the commit it came from (title bar, Help → About), Report an issue no longer includes your user name, and the log rolls over instead of growing without limit. None of this changes a picture; it is there so that the next crash arrives with evidence.
Live zooms are paced for smoothness at every zoom speed. An interactive zoom now builds reference orbits ahead of where you are heading, as a scripted tour always did, and each refresh is sized from what the GPU actually measured: on the development card the worst frame of a 1× to 10100× dive at the fastest zoom speed fell from 246 ms to 61 ms. A settled deep view still sharpens by progressive supersampling, and no longer leaves a faint copy of the previous location behind it; a large click-zoom no longer flashes black while the new view builds; and a shallow view no longer runs a hundred times the iterations it needs.
Click to zoom works in either panel of the dual view, with a new 25× step, an optional
snap onto the nearest minibrot centre, and a magnifier on Shift that previews
where a click will land, with four times finer aim. Normalize deep colors now
decides from how much of the view actually aliases — before, at the default Cycle, it
could never switch on at all — and a new Always fit range spreads the palette
across what is on screen whenever you ask. The nearest-minibrot key (M) works
in the dual view and no longer freezes the window at depth, and the gradient editor opens
on the palette you are actually using.
Full history in the changelog. The app can check for updates itself (Help → Check for updates); with no stable release on the page at the moment, the beta track is the one that finds anything.
Named here rather than discovered later. None of these are secret — they are the things being worked on, in roughly the order they are likely to affect you.
| Platform | Windows 10/11 64-bit; Linux x64 |
| Graphics | Vulkan, DirectX 12 or OpenGL, via wgpu |
| Written in | Rust, with egui for the interface |
| Licence | MIT or Apache-2.0, at your option |
| Price | Free, and free of tracking, ads and accounts |
Bug reports and feature requests are best filed as GitHub issues — they are public and searchable, so other people can confirm and follow them. The app can open a prefilled report for you from Help → Report an issue, including the version and hardware details.
If you would rather not use GitHub, write to feedback@fractadyne.org.