A month ago i was looking for an app that i could use to explore mandelbrot to its deepest levels, but i couldn’t find anything that had good precision, therefore giving up and becoming blurry/pixellated at like 600x… When i did this on Windows, i used an app called Visions of Chaos for this and also a few other projects and cool stuff, but i can’t find anything that matches up to it or is better yet.
Anyone have recommendations/a link i can find the stuff at? Would be appreciated for a new wallpaper
Hi and welcome to the forum, while i don’t have any suggestions for a similar program perhaps you could try run it using WINE? (I would use something like heroic game launcher, lutris or bottles to make doing this easier)
Hello, i was just about to edit this and say i forgot Wine exists so i tried that and it runs fine, some features are broken but not the ones i use. Thanks for mentioning it
Cool, will check this out
By Gemini:
For a high-performance, GPU-accelerated Mandelbrot experience on Arch Linux (especially within the KDE Plasma 6 environment), you have a few excellent options. Since you are running an AMD GPU and a Wayland-based setup, the following tools leverage OpenCL or Vulkan for computation while providing a modern Qt-based interface.
1. Mandelbulber2 (The Powerhouse)
This is arguably the most advanced fractal generator available for Linux. While it is famous for 3D fractals (like Mandelbulbs), it has an incredibly robust engine for 2D Mandelbrot sets.
- GPU Support: Full OpenCL acceleration. This allows you to utilize your AMD GPU for real-time zooming and high-resolution rendering.
- UI: Built with Qt. While the official release is still moving toward full Qt6 integration, it integrates seamlessly with KDE Plasma 6’s window management and themeing.
- Arch Installation:
Bash
# Standard version
sudo pacman -S mandelbulber2
# For OpenCL support, ensure you have the AMD OpenCL runtime
sudo pacman -S opencl-amd # (if using proprietary) or rocm-opencl-runtime
2. XaoS (The Interactive Classic)
If your goal is “browsing” rather than “rendering,” XaoS is the legendary choice. It uses a unique asynchronous calculation engine that allows for fluid, continuous zooming.
- GPU Support: Historically CPU-based, but so highly optimized that it often out-performs GPU generators for simple 2D navigation.
- UI: Version 4.x is Qt5/Qt6 based. It feels right at home in a KDE environment.
- Arch Installation:
Bash
sudo pacman -S xaos
```
### 3. Fraqtive (The Qt Native)
Fraqtive is a versatile fractal generator specifically designed for the Qt framework. It is very stable and provides a clean, KDE-like interface for exploring Mandelbrot and Julia sets.
* **GPU Support:** Primarily uses highly optimized CPU instructions (SSE/AVX), but its multi-core scaling is excellent.
* **UI:** Native **Qt**. It is one of the most "KDE-feeling" apps in the list.
* **Arch Installation:** Available via the AUR.
```bash
yay -S fraqtive
```
### 4. Gfractal (The Modern Choice)
A more recent project that focuses on high performance and modern rendering pipelines.
* **GPU Support:** Specifically designed to use **OpenCL** for lightning-fast calculations.
* **UI:** Qt-based, making it highly compatible with your KDE/Wayland setup.
* **Arch Installation:**
```bash
yay -S gfractal
```
---
### Technical Recommendation for your Setup
Given your history with **Arch Linux** and **AMD GPU** troubleshooting (specifically with KWin and Wayland), here is how to get the best performance:
1. **OpenCL Runtime:** Since you are on AMD, ensure your OpenCL environment is correctly configured. For the best performance in `mandelbulber2`, I recommend the **ROCm** stack:
```bash
sudo pacman -S rocm-opencl-runtime
```
2. **Environment Variables:** If you encounter any flicker in Mandelbulber or Fraqtive under Wayland, you can force the Qt backend:
```bash
export QT_QPA_PLATFORM=wayland
```
3. **Performance Tip:** For real-time "infinite" zooming, **XaoS** remains the gold standard because its "zooming" is an approximation that doesn't wait for a full re-render at every frame, providing a much smoother experience than almost any pure GPU renderer.
