Manual ChaoticaIntegration

From MediaWiki
Jump to: navigation, search

About Chaotica

Chaotica is an advanced fractal-software, which was designed to create and render flame-fractals in the best quality possible. It creates brilliant images with rich colors and sharp details in little time, and also supports fractal-animations, with very nice motion-blur-effects. Being a commercial product, it is developed and maintained by Glare Technologies. For a more comprehensive overview over the features please visit the official site

Integration into JWildfire

In the current state, Chaotica clearly focuses on the rendering and has a rather minimal user-interface to design and manage flames. This makes it a perfect candidate for an integration into other programs which may benefit from the truly amazingly fast and high-quality-renderer. Additionally, it uses only a very decent amount of memory, launches very quickly and (per default) occupies not much of the screen, so that the integration really can feel smooth.

Please note, that this integration is not meant to replace the JWildfire-renderer, not now and not in future versions. It is just an additional option to be able to deliver the best possible results in a fair amount of time.
Chaotica Launcher.jpg

Chaotica Community

Feature differences (examples)

But, nothing comes without a cost. So, we can't just export all of our flames to Chaotica and become happy by having rendered them in better quality in less time. Both programs, JWildfire and Chaotica, are very different, and transfering flame-parameters between them is actually a very challenging task. But, many of those differences are not a fault, or something similar, which may be eventually "solved", many differences are influenced by design, and they will remain.

Some examples:

  1. Chaotica currently does not support any (Pseudo)3D-feature, so all the 3D-stuff in JWildfire will not translate. Or in simple words: Fractals in Chaotica are always 2D
  2. JWildfire does not support the loading of any external Apophysis-plugins (and has all plugins integrated), where Chaotica supports both, internal and external plugins. This may lead to different behaviour in certain cases, because there is no garuantee that a certain plugin with the name X will behave in all programs the same. Apo-Plugins were often created in Delphi or C, while JWildfire-plugins are written in Java, and Chaotica probably uses some C-dialect.
  3. In animations, Chaotica is designed to work on a time-basis, while JWildfire works one a frame-basis (which can be translated in each other, of course).
  4. While Chaotica can have any variation as "post_" or "pre_"-variation, JWildfire still uses the Apophysis-approach to decide the priority by name (because of compatiblity reasons)
  5. Chaotica and JWildfire use different models for applying affine transforms
  6. Anti-Aliasing works different in both program

The JWildfire-Chaotica-Bridge

Because of the many differences between JWildfire and Chaotica, exchanging flames between them is a rather challenging task, which is performed by a special layer of software: the JWildfire-Chaotica-Bridge.

Components of the Bridge

The JWildfire-Chaotica-Bridge consists of the following components:

  1. Chaotica-Launcher: translates the current fractal of the Main-Editor into the Chaotica-format and launches Chaotica to render the translated flame
  2. Chaotica-Plugin-Translator: translates the names of certain plugins and plugin-parameters from JWildfire to Chaotica.
    1. Exchanges certain 3D-plugins by 2D-plugins, e.g. "blade3D" ist translated into "blade", because "blade" works the same when the fractal is in 2D.
    2. Removes plugins which can not work by design, e.g. "inflateZ_1", which is a displacement into z-directorion, which would have no effect at all
    3. Forces to use some JWildfire-specific plugins to force that the result looks the same, e.g. renaming "swirl" into "swirl_wf"
    4. Replacing certain unavailable plugins by replacements which work as much the same as possible, e.g. replacing "dcztransl" by "linear"
  3. JWildfire-Chaotica-Plugin-Pack: contains about 250 external plugins in Apo-format to help to translate as many flames from JWildfire to Chaotica as possible. They are made from JWildfire-code and are intended to work the same as the plugins with the same name in JWildfire.

Using all of this components, the bridge can currently handle/translate about 384 plugins.

  1. Chaotica-MotionCurve-Translator: transfers the MotionCurves designed in JWildfire to the Chaotica
  2. Chaotica-Bridge-Random-Flame-Generator: A meta-random-flame-generator which uses other flame-random-generators and the Chaotica-Plugin-Translator to create flames which will probably translate well to Chaotica

Usage of Plugins

Please note, that all plugins are optimized for Chaotica and may not work properly in Apophysis or other programs. So, it is currently recommended to use the JWildfire-plugins only in Chaotica, because that is the only purpose they were made (and tested for).

Supported Platforms and Chaotica-Versions

Because both JWildfire and Chaotica are continously evolving, and both programs are available on many different platforms/architectures, it is impossible to test and support any combination of versions/platforms.

Windows 64 Bit

This is (currently) the only supported platform. You are welcome to try others, but you are on your own. At least the plugin-pack is only tested for Windows 64 Bit yet.

On JWildfire-side, you should use Java7 or higher (Java 8 is not required), and be sure to use a 64 Bit Java, not the default one which comes with your browser.

On Chaotica-side any version since 1.5.5 should work, be sure to use the Windows 64 Bit version

Windows 32 Bit

This platform is available only because of a special very good friend of the author. It is not tested and not officially maintained, but should work.



Install the latest JWildfire-version from the official site and check the option "Chaotica-plugins"


  1. Download Chaotica (64 Bit Windows) from the official site and install it on any location.
  2. Copy the plugins from the JWildfire installation (folder "plugins64" inside installation-directory) into the plugins-folder of Chaotica (also folder "plugins" inside installation-directory)
  3. Create a temporary directory for exchanging flames, e.g. "D:\JWF-Chaotica-flames"

(If you want to use the not officially supported 32 Bit version, just install Chaotica 32 Bit and use the plugins from the "plugins32"-folder instead)

Visual C++ Redistributable Packages für Visual Studio 2013 (vcredist_x64)

When Chaotica can not load the plugins, especially the 64Bit plugins, it may be necessary to install the Visual C++ Redistributable Packages for Visual Studio 2013.

Configure JWildfire

  1. Launch JWildfire and open the Preferences-Window
  2. Set the value of the property tinaIntegrationChaoticaDrawer to the actual path of your Chaotica-installation, e.g. "C:\Program Files\Chaotica"
  3. Set the value of the property Set tinaIntegrationChaoticaFlameDrawer to the path you created to exchange flame-files, e.g. "D:\JWF-Chaotica-flames"

Getting started

  1. Start JWildfire
  2. Choose the random-flame-generator Chaotica Bridge and press the Random batch-button
  3. Double-click at a flame at your choice to load it into the main editor
  4. Choose the desired resolution-profile (the fractal is rendered at this size in Chaotica)
  5. Click at the Chaotica-Bridge-button at the right side of the preview area
  6. If Chaotica launches properly, but you get a black/unwanted fractal, the fractal may use a plugin which is still not available. In this case, please chose another flame, then the plugin may be not available yet.

Which features do no translate

Here is a (not yet complete) list of the features, which do not translate when using the bridge (and also do not translate when importing flames by using the clipboard). So, please, before posting a bug, please be sure, that the problem is not already mentioned here:

  1. Any 3D-stuff, i. e. fractals are always pure 2D in Chaotica
  2. Most DC-stuff (direct-coloring). I have made some plugins which translate the alteration of color into alteration of density, i.e. the effect is monochrome
  3. Post-Symmetry
  4. Bokeh-Effects
  5. Special-Shading
  6. ImageMaps as Gradients
  7. Any Stereo3D-stuff
  8. Post-Symmetry
  9. Layerz (only the first layer is translated)
  10. Color-curves from the channel mixer
  11. Multiple final transforms (only the first final transform is translated)

Tips and Tricks

Here are some advices from Thomas Ludwig, the main developer of Chaotica:

  1. You can run Chaotica as Administrator to enable advanced memory features (which are why Windows XP support was left out in version 1.5), for up to 15% faster rendering. You notice it most on fast CPUs, eg Intel i7. (Although soon this won't matter as much because of future OpenCL support, it's still nice, especially for realtime animation playback.)
  2. When rendering animations, it really helps to use Smooth AA mode, with AA level 2 and ultra quality off. The frames converge very fast and it's very friendly for the compression codecs.