Fractals/software

=Fractal software=
 * Mandelbrot by Adrian Rabenseifner, web app
 * almondbread by Eamonn O'Brien-Strain
 * AlmondBread for DOS 2002
 * fractint
 * Spider by Yuval Fisher
 * Mandelbrot Set Explorer by David Eck
 * David Eck's MANDELZOOM at Muency (additions and bugs by Robert Munafo) Successive Refinement version
 * Mandelbrot Set Explorer by David Eck (with changes by Robert Munafo -- 20230505 row-by-row version)
 * MandelRust Rust version of David Eck program (The in-browser calculations are implemented in Rust and deployed in the browser via WebAssembly. For high precision calculations, this is about 5-7 times faster than the Javascript version. The backend server is implemented entirely in Rust using Actix-web. It can be up to 15 times faster than the original Javascript version.)
 * Fragmentarium - GLSL
 * Kalles Fraktaler
 * Mandelbulber ( m3p file holds only the parameters, while .m3i holds also the raw image )
 * Mandel - software for real and complex dynamics by Wolf Jung
 * Mandel Machine
 * gnofract
 * Programs by Claude Heiland-Allen
 * fraktaler-3 - fast deep escape time fractals
 * mandelbrot-book and mandelbrot-book-images
 * mandelbrot-perturbator
 * mightymandel - GLSL
 * mandelbrot in emscripten
 * JS]
 * gmandel - A Mandelbrot Set explorer implemented in Haskell using GTK/OpenGL/libqd, git repo
 * emndl - exponential strip visualisation of the Mandelbrot set
 * zoomasm:
 * program for making video. Zoom videos are a genre of 2D fractal animation. The rendering of the final video can be accelerated by computing exponentially spaced rings around the zoom center, before reprojecting to a sequence of flat images. Some fractal software supports rendering EXR keyframes in exponential map form, which zoomasm can assemble into a zoom video. zoomasm works from EXR, including raw iteration data, and colouring algorithms can be written in OpenGL shader source code fragments.
 * Zoomasm is a zoom video assembler for turning exponential map EXR keyframe sequences into movies. It has a timeline system in which you can set zoom depth at specific times, for example to synchronize with a soundtrack.
 * zoomasm expects a sequence of exponential map strip keyframes as input, not flat frames
 * Some fractal software supports rendering EXR keyframes in exponential map form, which zoomasm can assemble into a zoom video. zoomasm works from EXR, including raw iteration data, and colouring algorithms can be written in OpenGL shader source code fragments.
 * Libraries by Claude Heiland-Allen
 * exrtact various tools to manipulate EXR images compare with OpenExr
 * kf-extras programs for manipulating output from Kalles Fraktaler 2
 * mandelbrot-symbolics - symbolic algorithms related to the Mandelbrot set
 * mandelbrot-numerics - numerical algorithms related to the Mandelbrot set
 * mandelbrot-graphics - CPU-based visualisation of the Mandelbrot set
 * mandelbrot-text - 	parsing and pretty printing related to the Mandelbrot set
 * ruff = relatively useful fractal functions ( in Haskell)
 * UltraFractal
 * M Sargent programs
 * Xaos
 * Shadertoy - GLSL
 * Dynamics - program by Helena E. Nusse and James Yorke
 * The Computer Language Benchmarks Game : mandelbrot
 * lt = a Mac OS X application for researchers in complex dynamical systems.
 * Programs by Curtis McMullen
 * programs by Gert Buschmann
 * RatioField
 * Ratio
 * Fractalzoomer - Java progam by Chris Kalonakis ( with src code)
 * Programs by Dmitry Khmelev
 * DsTool is a computer program for the interactive investigation of dynamical system
 * pyDsToo/
 * matcont - is a Matlab software project for the numerical continuation and bifurcation study of continuous and discrete parameterized dynamical systems
 * Linas' Art Gallery
 * original pages
 * new github repo
 * - fork with new c code
 * kandid "s a java-based genetic art program from 2002 that features several kinds of algorithms including an Iterated Function System Affine Transformation; Voronoi Diagram; Cellular Automata and a bunch of other things. By far my favorite is the iIFS Affine Transformation in Grayscale mode.  It can operate in color modes but the results are always awful."  Tim Hodkinson: Kandid beats Apophysis, Chaotica and JWildfire with millions of colors tied behind its back!!!
 * Dr. Don Spickler - Fractal Generator
 * wolfram language guide: Iterated Maps And Fractals
 * James Gleick's CHAOS: The Software, version by Rudy Rucker in C with code
 * fractalstream-1.0 and home page
 * Polynomial Julia Sets online visualisation with formula parser by Mark McClure
 * Fractalshades by Geoffroy Billotey
 * fractalnow - Fast, advanced, multi-platform fractal generator based on Pthread, GMP, MPFR, MPC and Qt libraries
 * nanobrot by flutomax

Imagina

 * github repo
 * mandelbrot-reference-compression
 * imagina in FF
 * wine ./Imagina.exe
 * unzip ./Imagina.zip
 * .im is a binary file format that can include a compressed reference
 * fractalforums.org: renderdisplay-method-circle-from-center-out-how-does-it-work: Imagina uses a successive refinement technique. It uses this circular rendering on each successive refinement step. In Imagina the image is continuously updated. It's implemented in class StandardPixelManager in PixelManager.h/.cpp, mainly in three functions: Init, GetCoordinate, and WriteResults.
 * Imagina tries to synchronize the approximation steps with minibrot periods, because most of times, it's possible to move forward one minibrot period each time.

Precision
 * floatexp with single precision
 * FloatExp with double precision

Controls

 * Left mouse button
 * Drag - Pan view
 * Double click - Find nearby feature and open Feature Finder dialog
 * Mouse scroll wheel - Zoom
 * A - Increase color density
 * S - Decrease color density
 * D - Increase iteration limit
 * F - Decrease iteration limit
 * E - Cycle color forward
 * R - Cycle color backward

Nanoscope by pauldelbrot
Extra range is needed on a few specific iterations, if zooming past e300 and doing flybys past minibrots below e300.

Nanoscope stores a similar array to KF, 3x double with re, im, and a mag value used for glitch detection. It also stores a pointer that is either null or points to a wide-exponent copy of those three values. If the double precision values underflow (denorm or zero) these get set for that iteration during reference orbit computation. Otherwise the pointer is null. During iteration, if the pointer is not null the next iteration is done using 52-bit mantissa wide-exponent calculations (significantly slower, but for only one iteration).

The circumstances that trigger this are instances like this. Say there's a period-73174 mini at about e380. If the zoom goes very close to that mini, then for images near and deeper than that mini, every 73174th reference orbit iteration is within 1e-380 of zero or so, so it underflows in a double. So wide exponent calculations must be done on those iterations, and those reference orbit entries must be stored with a wide exponent.

For every other iteration below e300, Nanoscope does the calculations with rescaled values that don't need a wide exponent. The rescaling is changed every 500 or so iterations -- this works because until a point is on the verge of escape, its orbit dynamics are dominated by the effects of repelling points in the Julia set nearby, and that typically means its magnitude doubles each iteration. The exponent width of doubles is 11 bits, so from about -1000 to about 1000, representing powers of 2 (not 10), so easily accommodates 500 doublings with plenty of margin for error. Re-rescaling is also done after every iteration that needed a wide-exponent reference point, because the orbit has jumped much closer to 0 again on such iterations.

On "final approach" an escape-bound critical orbit moves faster, with the magnitude squaring each iteration, but by the time this happens the unscaled magnitude is above the e-300 threshold and Nanoscope has switched to bog-standard perturbation calculations without any rescaling or other sneaky tricks. And escape is usually within the next 500 iterations anyway.

NanoMB

 * NanoMB program by knightly
 * nanomb64_generic.exe
 * nanomb64_i7.exe
 * knighty's super series approximation perturbation algorithms

time ./nanomb64_i7.exe --kfr ./test_x1.kfr --maxiters 250000 --period 2489 --width 500 --height 500 --orderM 4 --orderN 4 --output_ppm s.ppm --output_kfb s.kfb --force_type 'floatexp' Period is 2489 nanomb.exe --kfr test_x1.kfr --period 2449 --width 500 --height 500 --orderM 4 --orderN 4 --output_ppm s.ppm --force_type floatexp

SuperMB

 * SuperMB
 * superMB is actually not super at all. It is just a modification of the code Claude posted in the superfractalthing thread. I use it for experimenting. It now have a rudimentary GUI. I've attached below the source code +dependencies

Knighty's SMB which I think is still a bit faster than KF though being more of a testbed than a usable renderer puts the glitches in distinct sets (G1,.., Gn) with same iteration number where glitch was detected. Next references will then be 1 random pixel from each of the G1,..,Gn and is used only to recalculate the pixels in each set G. Secondary glitches simply generate another set G and you just put then in some queue or stack and keep going at it till no more G sets left. When dealing with glitched pixels you can use the same series expansion as a starting point. ( Gerrit)

on GitHub

 * https://github.com/wpwoodjr/MandelRust
 * https://github.com/rodrigosetti/sdl-mandelbrot
 * https://github.com/rust-fractal/rust-fractal-core/tree/master
 * https://github.com/bernds/GAPFixFractal
 * https://github.com/JMaio/mandelbrot-maps
 * https://github.com/Toxe/mandelbrot-sfml-imgui
 * https://github.com/Toxe/mandelbrot-comparison
 * https://github.com/josecelano/c-mandelbrot-arbitrary-precision
 * https://github.com/angeluriot/2D_fractals_generator
 * https://github.com/angeluriot/Graphics_skeleton

=Hubs=
 * openhub: projects tagged fractal
 * sourceforge Search Results for "fractals"
 * fractalforums.org downloads
 * github topics fractals