I want to say. This is the most necessary thing in the Universe. The most profound. And now, in my entire life, I finally started writing code and did it. Quite complex. And the most beautiful. Download and see! It's an executable file, on GitHub.

github: Download Latest Version Windows And Source code

We can't have videos, we can only have static ones. Here they are

True 32-bit BGRA

Migrated to full 32-bit BGRA color output, enabling smooth gradients and millions of unique shades. By utilizing a native 32-bit BGRA pipeline, the engine can render millions of intermediate colors.

Synchronization with DwmFlush

The engine achieves perfect visual smoothness by synchronizing directly with the Windows Desktop Window Manager (DWM):

Adaptive Refresh Rate: The application uses DwmFlush(). This pauses code execution until the DWM has finished compositing the screen.
Monitor-Dependent FPS:
- If your monitor is set to 60 Hz, you get 60 FPS.
- If you are using a gaming monitor at 144 Hz, the function triggers 144 times per second, delivering 144 FPS.
- On high-end 240 Hz displays, you will see a buttery-smooth 240 FPS.

We can't have videos, we can only have static ones. Here they are

High-Precision Rendering (80-bit)

Most Mandelbrot explorers use standard 64-bit double precision, which leads to "pixelation" at zoom levels around 10 14. This project leverages 80-bit Extended Precision Arithmetic (long double) to push the boundaries of the fractal:

My Implementation (80-bit): Provides 4 extra decimal digits of precision, allowing you to explore 10,000x deeper (10 18 range).
Hardware Optimized: Directly utilizes the x87 FPU registers for maximum mathematical depth.

OpenMP

OpenMP is a standard that tells the compiler, "Take this loop and distribute the iterations among the different processor cores." Yes, using OpenMP you are doing parallel programming at the Multithreading level. Everything is powered by OpenMP parallel loops for maximum performance. OpenMP - Scalability: Your code will run equally efficiently on a 4-core laptop and a 128-core server.

We can't have videos, we can only have static ones. Here they are

True SSAA 2x2 (4 independent samples per pixel) direct RGB-space integration

Implemented 'true' 2x2 Supersampling Anti-Aliasing (SSAA). Each screen pixel is computed from four independent fractal coordinate points. High-fidelity per-channel RGB accumulation. The engine calculates the color for each sub-pixel first, then performs a weighted average of their intensities. Unlike standard renderers that average raw iteration counts (leading to 'chromatic noise' and loss of detail), this engine performs direct RGB-space integration. Averaging iterations produces visual noise and artifacts. By accumulating 32-bit color values first, we eliminate this noise entirely. The result is a clean, sharp image where high-frequency details are perfectly reconstructed, not blurred away. True SSAA 2x2 (4 independent samples per pixel) allows for the reconstruction of micro-filaments smaller than a single screen pixel. Technical Note:

Standard Way: Color( (iter1 + iter2 + iter3 + iter4) / 4 ) - Gives Noise/Artifacts.
Your Way: (Color(iter1) + Color(iter2) + Color(iter3) + Color(iter4)) / 4 - Gives Pure Detail.

Averaging iteration counts (indices) is mathematically incorrect because fractal palettes are non-linear. Averaging index A and B often points to a completely unrelated color C, creating high-frequency chromatic noise. Our solution performs integration in the RGB color space. By calculating the specific RGB components for each sub-pixel before downsampling, we ensure that the resulting color is a true optical blend. This eliminates artifacts and reveals the true structural geometry of the Mandelbrot set that is otherwise masked by noise.

We can't have videos, we can only have static ones. Here they are

Why is there noise without Supersampling?

It is a great question! As it turns out, noise without supersampling isn't a CPU error - it is a fundamental phenomenon in digital graphics known as Aliasing. The Mandelbrot set is infinitely complex. At its boundaries, there are "filaments" and details millions of times smaller than a single pixel on your monitor.

Without Supersampling: The processor acts like a "needle," sampling only one single point at the exact center of a pixel. If it hits a microscopic filament, the pixel turns red. If it misses by even a micron, the pixel stays black.
The Result: Neighboring pixels "grab" random fragments of micro-details. This creates mathematical noise (aliasing artifacts), which looks like grain or dirt on the image.

How SSAA 2x2 "Heals" the Image Instead of guessing what lies within a pixel, this engine takes 4 independent samples at different corners of the pixel area.

True Color Computation: The engine calculates 4 real colors for each sample point.
RGB Blending: These colors are blended together in a 32-bit color space.
The Magic of Precision: If a thin filament falls within a pixel, it no longer "screams" with a single harsh color or disappears entirely. Instead, it becomes a clean, semi-transparent line that accurately represents the true fractal geometry.

We can't have videos, we can only have static ones. Here they are

Visual Aesthetics. Color rotation

The engine uses a sophisticated hybrid approach to color mapping. Smooth Transitions (Blue & Green): These channels are driven by phase-shifted sine and cosine waves (127 + 127 2 pi * sin / cos). This creates deep, hypnotic gradients. High-Frequency Contrast (Red): The Red channel is populated using a pseudo-random distribution (stochastic noise). The "Shimmer" Effect: By mixing smooth harmonic oscillations (G, B) with per-index noise (R), the renderer achieves a unique shimmering texture. The juxtaposition of rhythmic Green/Blue waves and 'noisy' Red values. It mimics the visual complexity.

Controls & Hotkeys

The application provides intuitive mouse and keyboard controls for exploring the fractal:

Mouse Controls

Left Click (WM_LBUTTONDOWN): Zoom in (2x) and center the view around the clicked point.
Right Click (WM_RBUTTONDOWN): Zoom out (2x) from the current view.

Keyboard Navigation

F1 - F8 Keys: Instantly jump to 8 predefined iconic locations within the Mandelbrot set.

const long double PRESETS[8][3] = {
    {-0.7849975438787509L, 0.1465897423090329L, 0.00000000000015L},
    {-1.39968383250956L, -0.0005525550160L, 0.0000000000146L},
    {-0.8069595889803L, -0.1593850218137L, 0.00000000006L},
    {-0.618733273138252L, -0.456605361076005L, 0.0000000000046L},
    {-0.550327628L, -0.625931405602L, 0.00000000781L},
    {-0.55033233469975L, 0.62593882612931L, 0.0000000000023L},
    {-1.3996669964593604L, 0.0005429083913L, 0.000000000000026L},
    {-0.5503493176297569L, 0.6259309572825709L, 0.00000000000031L}
};

LEFT / RIGHT Arrows: Fine-tuned zoom in/out by a factor of 1.1x.

Data Management

ENTER (VK_RETURN): Export current coordinates. The program saves the exact absc, ordi, and size_val to Mandelbrot.txt.

BACKSPACE (VK_BACK): Import coordinates. Reads the three values from Mandelbrot.txt and instantly renders that location.

github: Download Latest Version Windows And Source code

Mandelbrot set. 32-bit TrueColor. 60 FPS. 80-bit long double. OpenMP. Supersampling 2x2 (4 passes). Color rotation