Turn fractal seeds into animated videos. FractalFlow is a free, MIT-licensed Windows desktop app for exploring fractals, animating parameters, composing layers, and exporting video. It combines a native Direct3D 12 GPU renderer, a CPU fallback, procedural visual workspaces, and a timeline editor in one portable application.
Download the portable EXE ? Release and ZIP downloads · Read the illustrated Wiki · Make your first video · Build from source
Actual native fractal and Generator Lab renders, converted to smaller GIFs for this page. Final exports use your selected resolution and frame rate.
Build motion in Compose and explore procedural color in Shader Lab. Click a screenshot to explore further.
- 2D and 3D fractal animation: 233 formulas across 14 families, including Mandelbrot/Julia-style sets, Mandelbulb/Mandelbox, KIFS, quaternion slices, flames, attractors, Buddhabrot, cellular automata, and L-systems.
- Layered compositions: combine compatible 3D formulas or composite separate sources with blend modes, opacity, color keys, and per-layer motion.
- Animated seeds: save reusable parameter motion, local motion, and timeline behavior with a seed, then control its speed and phase in Compose.
- Camera and parameter animation: build camera segments, edit keyframes and interpolation, and preview selected intervals before a full render.
- Procedural visuals: explore Live FX, Generator Lab, and Shader Lab, including Twigl and Shadertoy-style workflows.
- Finished video: review renders in Clip Studio, trim, change speed, build ping-pong clips, animate effects, and export edited copies.
- Automation: use Auto Builder, the command line, or the local HTTP API. API Lab is an in-app request/response workbench.
- Open Releases and download
Fractalflow.exe, or the Windows x64 ZIP with licenses and start-up instructions. GitHub's Source code downloads are for building the app; they are not the portable executable. - Put the app in a writable folder, such as
C:\FractalFlow. The self-contained executable does not require a separate .NET installation. - Run
Fractalflow.exe. The first-run window checks renderer availability, FFmpeg, and WebView2. - If procedural workspaces need Microsoft Edge WebView2 Evergreen, follow the first-run setup instructions. FFmpeg is downloaded on demand for video encoding; you can also supply a compatible
ffmpeg.exebeside the app for offline use. - Open Resources, confirm the enabled GPUs, and start with a moderate worker budget and a small test render.
The app stores its library/settings under data and rendered files under output beside the executable, unless you set the documented path overrides. To update, close the app and replace the executable while keeping those folders.
| Component | Requirement |
|---|---|
| Operating system | Windows x64; Windows 10 version 1809 or newer, or Windows 11 |
| GPU rendering | A Direct3D 12-capable GPU and a working driver |
| CPU fallback | Available across the formula catalog; complex 3D/path-traced scenes can be slow |
| Procedural workspaces | Microsoft Edge WebView2 Evergreen Runtime |
| Video encoding | FFmpeg, installed on demand or supplied separately |
| Storage | A writable app/output location; retained PNG sequences can be much larger than video |
CPU and HLSL lighting are not identical. Keep the same renderer when comparing a preview with a final render.
Explore → Fine tune → Heart a seed → Compose → Save composition → Render → Videos
- In Explore, generate a few seeds or select a guided starter.
- Open Fine tune on a seed you like. Adjust its parameters, optionally enable saved animation, and render a short preview. Heart the result.
- In Compose, select the hearted seed. Start with four seconds at 30 FPS. Add camera motion or parameter animation.
- Preview the start, a transition, and the end. Add layers after the first source works.
- Click Save composition. On Render, select that saved composition and use a small output size for the first test.
- Open the result under Videos → Clip Studio to trim, add effects, or export a final copy.
For a render that differs from Compose, follow the save-to-render checklist. Saving the final draft, selecting the correct saved name, and comparing the same timestamp are essential.
Browse formula families, generate variations, and keep favorite seeds. Fine Tune saves both the look and optional seed animation.
Route sources as compatible formula mixes or independent layers. Camera, Parameters, and Visuals workspaces control the timeline, with storyboard and animation previews for checking motion.
Render saved compositions, queue native jobs, and inspect progress. Use Clip Studio for playback, trimming, retiming, and animated post effects.
Live FX, Generator Lab, and Shader Lab produce clips directly into the same video library. Their exact-output settings are separate from native composition rendering.
A four-second Generator Lab clip rendered by the release executable at 24 FPS, shown here as a smaller GIF.
| Workspace | Best starting point |
|---|---|
| Live FX | Choose an effect, generate or mutate a look, then explore motion and color controls. |
| Generator Lab | Choose a visual family and tune its scene, palette, motion, and overlays. |
| Shader Lab | Start from a built-in shader or import a project; review imports, compile, and preview before rendering. |
Auto Builder plans native or procedural clips. Start with Preview plan, then generate one clip before queuing a batch. Optional visual scoring renders candidate samples and takes additional time; the bundled starter requests leave it disabled.
The executable also accepts CLI commands:
.\Fractalflow.exe help
.\Fractalflow.exe catalog formulas --json
.\Fractalflow.exe compositions list --json
.\Fractalflow.exe api --bind 127.0.0.1 --port 8080The API server prints its bearer token at startup. Enter that token and base URL in API Lab. See CLI/API instructions and the sample Auto requests.
Use Resources to set CPU workers, GPU concurrency, enabled adapters, preview size, and output format. Native HLSL can use multiple enabled GPUs. Eligible procedural exports divide frames across verified GPU workers; history-dependent effects and stateful timelines render in order.
More concurrency is not always faster: large frames and multiple layers increase GPU memory use, while PNG retention increases disk traffic. Begin with a short job, leave CPU/GPU headroom for the desktop, and raise one setting at a time. Preview resolution does not change final output resolution.
The 18-chapter illustrated manual covers every main workspace, first-video workflows, file locations, backups, CLI/API usage, and troubleshooting. Screenshots open at their original resolution.
- First-video walkthroughs
- Seed fine tuning and animation
- Layers, keyframes, and Compose
- Rendering saved compositions correctly
- Troubleshooting
- Backup and recovery
- Build and package the app
The manual is available in the repository immediately. A GitHub Wiki can be added later without making the instructions depend on it.
src/ WPF app, CLI/API, core model, render pipeline, CPU/HLSL renderers
tools/Fractalflow.ShaderCompiler/ Build-time shader compiler
tools/Fractalflow.GeneratorLab/ Editable procedural scene source and MIT frame player
scripts/ Build, package, and manual-generation tools
manual/ Illustrated chapters, screenshots, and request examples
docs/ Build instructions and README media
licenses/ Dependency license notices
This public repository contains the app's source and necessary build/documentation assets. Local libraries, renders, caches, audit logs, and the private test workspace are excluded. See CONTRIBUTING.md for a reproducible bug-report checklist.
FractalFlow's application code and documentation are available under the MIT License: free to use, modify, and redistribute, including commercially, with the license notice preserved. Third-party components and imported media retain their own terms; see THIRD_PARTY_NOTICES.md.
Created by aivrar.