• Category Archives JWildfire releases
  • JWildfire for macOS is now on the AppStore!

    I worked the last four weeks on a dedicated macOS build which can be distributed
    through the App Store.
    Hopefully, this will make it much easier to install updates for Mac users and
    oush the macOS-version to a higher level.

    This step really needed a lot of tweaking, because all the packaging and code-signing
    steps must be performed manually (this is because JWildfire is not made using Xcode,
    which simplifies such stuff a lot.)
    Also, it was necessary to replace almost any file-dialog with a native one.
    Only this seems (currently) to make it possible to exit the macOS-sandbox
    under macOS Catalina (otherwise you would get a “operation not permitted” or
    similar error when trying to write a file.)
    Those dialogs also look better, but lack some features of the JWildfire-dialogs.

    So, I’m really glad, that it all works now! 🙂

    To support the future of this build and to make it possible to extend tests on the
    Mac platform, I decided to make the app not free. Instead, you have to pay about
    10 bucks (once), all future updates will be free.
    You can still use the completely free (*.jar-based) build (or build by yourself),
    of course. But this will require more manual steps to install the software.

    If you once open FileDialog to select a drawer (and not a file), all further
    dialogs will not allow you to select a single file.
    (After the a restart of the app the problem is fixed).
    There is also a permanent workound (which will be included in the next update):

    Edit the file /Applications/JWildfire.app/Contents/app/JWildfire.cfg, e.g. by
    opening a terminal and entering:
    cd /Applications/JWildfire.app/Contents/app
    sudo vi JWildfire.cfg

    Then add the line “-Dapple.awt.fileDialogForDirectories=false” after the line “-Xmx4096m”,
    so that you have the section in the file:
    Save the file, and after restarting JWildfire, the problem will be fixed.

    Here is the link to the App Store: https://apps.apple.com/de/app/jwildfire/id1530646485

    Have fun!

  • JWildfire 6.00 release: improved animation-capabilities and better performance

    After three months of work, I’m glad to release JWildfire V6.00 as another major update.

    This time, the animation-features where greatly improved:

    • animation playback and -editing in the main editor is much smoother now, in general the editing gives much for “fluid” feeling
    • the main editor now supports automatic creation of animation keyframes: you move to a certain frame, change a property, and JWildfire automatically creates a smooth motion curve to interpolate between the values
    • you may now create mp4-files directly from within JWildfire (without using any other tools). You may even create batches of mp4-files.
    • support for Intel’s OIDN denoiser as a powerful tool to cut down render times and improve image quality (works simular to NVidia’s OptiX, but does not requiere a GPU from NVidia)

    But, there are also numerous new non-animation-related improvements, e. g.:

    • new “RunRandomScript”-random-flame-generator which executes randomly selected scripts from your script-library to generate random flames
    • new dark “JWildfire”-theme (based on Nimbus) which is now the default
    • easy revert-to-default-feature for most parameters: just double-click at the label in front of an field to revert the current-value to the default value
    • new function (at the “Anti-Aliasing / Filter”-tab) to apply an AI-Post-Denoiser to a single image (e. g. a previously rendered fractal)
    • numeric fields now also react to inputs of the mousewheel
    • a lot of new variations

    Thanks to Brad Stefanov, Jesus Sosa, Rick Sidwell and Whittaker Courtney to their valuable contributions!

    Hint for Mac users:

    For some reason, macOS Catalina may say that the JWildfire.app is “corrupted”. Workaround: you can download the Windows/Linux-distribution and unzip it. Go into the lib-subfolder and launch the j-wildfire.jar. (When you do not know how to do this, search Google for “macos launch jar”). Good luck! (I will try to fix this as soon as I find the time.)

    Complete list of changes:
    – dramatic improvement of responsiveness to changes in the UI (sliders, number fields, …)
    – faster Undo and Randomizers as well
    – more “fluid” preview
    – automatic creation and updating of keyframes when changing flame-parameters at different frame-numbers, creating
    of flame-animations has never been easier
    – there are the following functions in the UI to deal with keyframes:
    – jump to previous keyframe (takes all keyframes of all motions curves into account and jumps to the closest keyframe)
    – jump to next keyframe (same as before, but in the opposite direction)
    – delete current keyframe (affects all motion curves which contain a corresponding keyframe)
    – duplicate current keyframe (affects all motion curves which contain a corresponding keyframe)
    – reset all motion curves/remove all keyframes
    – you may now create mp4-files directly from within JWildfire (without using any other tools). This feature is available
    in the following places:
    – main-editor (just use the “Render image/movie”-button as usual, but choose the extension “.mp4” as output.
    In the file-dialog you may select “Supported movie files” in order to display only *.mp4-files.)
    – Easy-Movie-Maker (new “MP4”-output-type)
    – Batch renderer (after adding a file you need to set the value “Render animation” to 1 for each file you want to render as animation)
    so you can render small animations very quickly and without involving any other software
    – new option “tina.keep_temp_mp4_frames” in the Preferences to specify if you want to keep the individual frames (and must delete them manually)
    – easy revert-to-default-feature for most parameters: just double-click at the label in front of an field to revert the
    current-value to the default value. To see if a field supprots this feature, just hover with the mouse of the label.
    When the cursor turn into a hand-symbol, the field supports the feature. This function also respects motion-curves and can be undone.
    – new “RunRandomScript”-random-flame-generator which executes randomly selected scripts from your script-library to generate random flames.
    This makes the scripting-feature more visible to users who not already know much about it, and also creates a lot of beautiful new flames.
    The random generator also adds symmetry and weight-fields, accordingly to your selection, on top of the script-generated flames,
    but preserves the script-generated-colors (when any).
    You can use the options tinaRandGenRunRandomScriptIncludedScripts and tinaRandGenRunRandomScriptExcludedScripts in the Preferences to
    include or exclude specific scripts (or both).
    – new dark “JWildfire”-theme (based on Nimbus) which is now the default
    – support for Intel’s OIDN denoiser as a powerful tool to cut down render times and improve image quality (works simular to NVidia’s OptiX,
    but does not requiere a GPU from NVidia)
    Please consult the comprehensive documentation inside the software (“Help -> Supported AI-Post-Denoiser -> Intel’s OIDN Denoiser”) for more information.
    – new function (at the “Anti-Aliasing / Filter”-tab) to apply an AI-Post-Denoiser to a single image (e. g. a previously rendered fractal).
    When using this function, the currently active AI-Post-Denoiser-settings are applied.
    – moved the old webspace to a secured site:
    – https://jwildfire.overwhale.com is the JWildfire site
    – https://jwildfire-forum.overwhale.com is the JWildfire-forum
    – (https://mb3d.overwhale.com is the Mandelbulb3D site)
    – (https://flamelet.overwhale.com is the Flamelet site)
    – https://overwhale.com is my main site
    – made it more visible, when a motion curve/key-frame is associated with a certain flame-parameter
    – Batch-rendering now also supports AI-Post-Denoiser together with GPU-rendering (FACLRender)
    – GPU-rendering in the GPU-render-window also respects the AI-Post-Denoiser from the imported flame
    – added a new option to turn the denoiser off in order to be able to see the raw result from the GPU renderer
    – changed some default settings in regard to flame-animations
    – numeric fields now also react to inputs of the mousewheel
    – added function to reset all motion curves
    – re-implemented animation-playback in the main editor
    – new settings in the Preferences for animation preview in the main editor: tinaRenderAnimPreviewQuality (render quality) and tinaRenderAnimPreviewSize (size of preview)
    – new setting in the Preferences for default state of the animation-controls in the main editor: tinaDefaultAnimationControlsEnabled (per default: true)
    – renamed the “Misc”-tab into “Randomize”, moved the “Randomize weighting-fields”-button to this tab, added also a hint-panel
    – added motion curves for the following flame-parameters: balancingRed/Green/Blue, lowDensityBrightness and foregroundOpacity
    – added new property “tinaDefaultFrameCount” to the Preferences, here you can change the default number of frames for a flame-animation,
    created in the main editor
    – the Quilt-Renderer does ignore the setting of the AI-Post-Denoiser (e.g. OptiX). The current way to denoise such images is to manually denoise the final image
    – new variations:
    -glitchy1 by Brad Stefanov, Rick Sidwell, dark-beam and bezo97
    -pixel_flow by bezo97
    -dc_warping by Jesus Sosa
    -post_log_tile2 by Whittaker Courtney
    – 20 new variations “SDF” for 3D blur objects, by Jesus Sosa
    – added a mode parameter to the elliptic variation to enable compatibility with the apo plugin; see http://jwildfire.org/forum/viewtopic.php?f=22&t=2681
    Also added a higher accuracy mode as described by Claude Heiland-Allen.
    All three modes will look the same for most flames, but the differences are important in some specialized cases, by Rick Sidwell
    – add polarplot variations to solid random flame generator, by Rick Sidwell
    – fixed a bug in blur_zoom, by Rick Sidwell
    – fix shift_z in sphere_nja, by Rick Sidwell
    – fixed a bug in onion2, by Brad Stefanov
    – fixes to package js.colordomain & more params to new variation vortex, fixes to package js.colordomain, more params to new variation vortex, by Jesus Sosa
    – removed the (barely understood) “Mirror translations”-button at the Affine-transforms-tab
    – fixed a bug preventing changing parameters “Blur fade” and “Blur falloff” on the “DOF/Bokeh -> Post blur” -tab
    – fixed a bug regarding calculating the wrong pixels-per-unit-setting when importing a flame from the thumbnail-ribbon
    – fixed bug that the Quilt Renderer did not delete the temporary segments after merging thme into the final images
    – fixed a bug causing the GPU-renderer called twice the same time when changing resolution- or quality-profile in the GPU-renderer-window

    Just click the “Random flames” button to start playing around and have fun  🙂

  • JWildfire 5.60 release: with support for OptiX denoiser

    Just released JWildfire V5.60 as another major update.

    This time, adding support for NVidia’s OptiX denoiser as a powerful tool to cut down render times and improve image quality.

    The OptiX denoiser, developed by NVidia, is included in most of the common 3D rendering software like Arnold, Blender, Lightwave.
    I was enjoying it for a longer time, but did not really think about an integration into JWildfire, because such an integrationg (GPU rendering and Java programs) is always somewhat weak or unstable.
    But then, user [Phaser Rave] at the JWildfire forum, introduced us to the a command-line version of the denoiser, made by Declan Russell. I was immediately hooked and created some "dirty" integration of the tool into the render-flow to play around. I was really excited and the results where amazing, so I kept stuck to the idea and improved the  implementation.
    Now, it is loosely coupled and can not crash your JWildfire process. You will only see the options, when your system can run it. So, it will not confuse users who can not make use of it, either. All others will love it ;-) 
    And, by using the way of utilizing a command-line-tool you are even able to denoise your already rendered images!
    Please consult the comprehensive documentation inside the software ("Help -> OptiX denoiser") for more information.

    There also a lot of other useful additons, contributed by Rick Sidwell, Jesus Sosa, Whittaker Courtney and others – most in the form of new variations – thanks a lot for your efforts!

    Complete list of changes:

    – support for NVidia’s NVidia’s OptiX denoiser as a powerful tool to cut down render times and improve image quality.
    Please consult the comprehensive documentation inside the software (“Help -> OptiX denoiser”) for more information.
    – new commandline-tool to create and render random flames.
    Example: java -cp j-wildfire-5.60/lib/j-wildfire.jar org.jwildfire.cli.CreateRandomFlame -w 1200 -h 675 -q 80
    – new variations:
    -julia_outside by Whittaker Courtney
    -polarplot3d_wf by Rick Sidwell
    -polarplot2d_wf (Like yplot2d_wf, but uses polar coordinates. Fifteen presets of common polar curves) by Rick Sidwell
    -combimirror by Thomas Michels and Brad Stefanov
    -crop_box, post_crop_box,
    -crop_polygon, post_crop_polygon,
    -crop_cross, post_crop_cross,
    -crop_rhombus, post_crop_rhombus,
    -crop_triangle, post_crop_triangle,
    -post_c_var, all created by Jesus Sosa
    – new jitter-option for weighting-fields: Adds noise after transforms, so it works well with blurs as well as normal transforms, by Rick Sidwell
    – some new presets to yplot2d_wf variation, by Rick Sidwell
    – FIXED: added missing parameter colormap_filename for metaballs3d_f variation, by Rick Sidwell
    – FIXED: a bug regarding colormaps in isosfplot_wf, by Rick Sidwell
    – FIXED: a bug in the mask variation, by Rick Sidwell
    – FIXED: made js.glsl classes serializable, fixing a bug where dancing flame projects could not be saved, by Rick Sidwell
    – updated variation credits, by Rick Sidwell

    Now, just click the “Random flames” button (or new “Random”-button at the gradient-tab ) to start playing around and have fun  🙂

  • JWildfire 5.50 release: introducing gradient-curve-editor as new artistic tool

    Just released JWildfire V5.50 as another major update.

    This time, introducing a new color-editing-function that makes it easier to control the final result: the color-curve-editor. It allows a very interactive editing of the gradient and the flame at the same time. Additionally, it allows more direct control over modifying the colors of a gradient, making it much easier to create “dramatic” effects.

    (Internally, each gradient now consist both of the “classic” part of the gradient and three new curves: hue, saturation and luminosity. Those curves belong to the flames, and are also stored within the flame-files.)


    A BIG thanks to Jesus, Rick, Brad and Michael (in no particular order) for their valuable contributions!


    Complete list of changes:

    - New "Curve Editor" for gradients at the gradient tab. This gives much more control over the final result because it allows a very interactive editing
    of the gradient and the flame at the same time. Additionally, it allows more direct control over modifying the colors of a gradient,
    making it much easier to create "dramatic" effects.

    Internally, each gradient now consist both of the "classic" part of the gradient and three new curves: hue, saturation and luminosity.
    Those curves belong to the flames, and are also stored within the flame-files.

    When loading an old flame without those curves, or assigning a "classic" gradient to a flame, the color curves are approximated.
    This usually is only a very raw approximation, but this is absolutely intended. To reach a very accurate approximation, it would require
    to have a lot of curve-points, which would make the curve very hard to edit.

    So, there is no exact synchronisation between the gradient and the colors curves, in order to not break existing flames and concepts.
    Instead, it is meant as powerful additional tool, whioch is useful in very many cases, but might not be useful in each case.

    Only when you start to edit one of the curves, the gradient is synchronized to shape of the curves. When you save and re-load a flame
    you can continue the editing of the curves.

    Each curve has a toolbar with little buttons to help with editing:
    - open a modal dialog for editing an enlarged version of a particular curve
    - create ramp-shaped curve
    - create line-shaped curve at the bottom (constant zero intensity)
    - create line-shaped curve at the middle (constant halve intensity)
    - mirror the curve at the vertical axis
    - mirror the curve at the horizontal axis (e.g., to turn a constant line of zero intensity into a line with maximum intensity)

    Two new random-gradient-generators directly support the concept of color-curves. I. e., they create random color-curves instead of random gradients.
    All existing random-gradient-generators works as before. I.e., they create only random gradients, while the color-curves are approximated from
    the gradients.

    - new "Uneven curves"-random-gradient-generator, which generated both a color-curve and a gradient (derived from this color-curve)

    - new "Uniform curves"-random-gradient-generator, which generated both a color-curve and a gradient (derived from this color-curve)

    - made "Uneven curves" the new default random-gradient-generator

    - New coloring type (by Rick Sidwell):
    CYCLIC shifts the gradient index right by the amount specified by Speed,
    wrapping as needed to cycle through gradient colors. It doesn't converge
    to a color when iterated, so some other transform needs to use DIFFUSION
    to get a stable color that CYCLIC can use as a starting point.
    CYCLIC is especially useful for coloring tilings.

    - function to create a simular gradient (using the currently loaded gradient as reference)

    - new "EDisc"-random-flame-generator

    - new "Save Gradient"-button at the gradient-tab

    - new "Random Gradient"-button direct at the gradient-tab

    - new variations (no particular order):
    - octapol (by xyrus02)
    - sinusgrid (by xyrus02)
    - csin (by zephyrtronium)
    by Jesus Sosa
    - cut_tileillusion
    - dc_fractcolor
    - cut_fractal
    - cut_zigzag
    - cut_x
    - cut_spiral
    - cut_spiralcb
    - joukowski
    - jac_elk
    - c_symmetry
    - cut_celtic
    - cut_triskel
    - cut_vasarely
    - cut_web
    - cut_spots
    - cut_btruchet
    - cut_c
    - c_var
    - cut_magfield
    - cut_btree
    - cut_2ewangtile
    - cut_alientext
    - cut_apollonian
    - cut_booleans
    - cut_bricks
    - cut_cirdes
    - cut_fingerprint
    - cut_fun
    - cut_glypho
    - cut_hexdots
    - cut_hextruchetflow
    - cut_jigsaw
    - cut_kaleido
    - cut_metaballs
    - cut_pattern
    - cut_randomtile
    - cut_rgrid
    - cut_shapes
    - cut_sincos
    - cut_snowflake
    - cut_sqcir
    - cut_sqsplits
    - cut_swarp
    - cut_triantess
    - cut_truchet
    - cut_truchetweaving
    - cut_tstruchet
    - cut_wood
    - cut_yuebing
    - dc_booleans
    - dc_butterflies
    - dc_spacefold
    - f_complex
    - msTruchet
    by Brad Stefanov
    - exp_multi (by Whittaker Courtney)
    - parallel
    - shredded (by Brad Stefanov and Rick Sidwell)
    - post_crosscrop (by Whittaker Courtney)

    - added "Lumiere Scripts" by Michael Bourne (a collection of 22 scripts) as built-in scripts
    - added "The Yugen Scripts" by Michael Bourne (a collection of 17 scripts) as built-in scripts
    - added "Keep 'Em Separated and Framed Script" by Brad Stefanov as built-in scripts
    - added "Minkowscope Painting Script" by Brad Stefanov as built-in scripts

    - fixed a nasty bug which could cause the final image to contain black stripes

    - Making a variaton a pre or post now works as intended

    - added standard shortcuts to Undo/Redo (<Strg>+Z/Y)

    - slighlty increased variation cost threshold to increase diversity in random flames

    - small optimization of the space at WField-tab

    - new README-file with hints for Linux-users

    - Additional presets added to isosfplot3d_wf variation

    - Two modes added to jubiQ variation

    - New option to specify color for DiminishZ; this is useful when using DiminishZ with a colored background

    - New coloring types descriptions in the Fractal Flames: Help window

    - New Density option for layers (by Rick Sidwell).
    Layer density allows fading some layers with respect to others to better
    balance the overall flame. It is complimentary to Weight, which controls
    the intensity of the layer to balance its brightness, but can only make
    it darker, not less dense.

    - New layer Extract button extracts the selected layer to a new flame in the editor

    - New ZBuffer controls (by Rick Sidwell)
    - ZBuffer bias makes the background appear closer. This is sometimes needed when using the ZBuffer
    for 3D photos in Facebook, which creates white splotches if the background is too far away.
    - ZBuffer filename option to select between traditional zbuf_name and name_depth (what Facebook requires).

    - New Camera tab Bank control to rotate flame around the Y axis. This rotation is normally called Roll,
    but that name is already used; Bank is a synonym. It works in conjunction with Pitch (rotate around X
    axis) and Yaw (rotate around Z axis).

    - New FastNoiseCreator in Image Processing to create images containing various types of noise

    - Change Easy movie maker FADE function to better fade between flames. A compatibility option allows using the old method.

    - Tooltips added to many controls

    - Rick Sidwell: Various fixes, including one that prevented the Mesh generator from working.
    1. Added some null pointer checks to AnimationService.java
    2. Removed print statement from Variation.java (only noticable if
    started from the command line for debugging)
    3. Fixed BokehOptionsBuggon tooltip text
    4. Corrected class for PerlinNoiseCreator so Transformation expression
    can be edited
    5. Camera distance field now allows negative distances.
    6. Motion curve for Fade to white now works.
    7. Edit gradient now puts focus on gradient so cursor keys work.
    8. Make a copy of a thumbnail flame before appending it as a layer to avoid confusing situations when editing one flame changes another.


    Now, just click the “Random flames” button (or new “Random”-button at the gradient-tab ) to start playing around and have fun  🙂

  • JWildfire 4.00 release: game-changing improvements in the user-interface

    Just released JWildfire V4.00 as a special X-mas-gift to the fractal-loving community.
    Big and warm thanks to Rick Sidwell, Whittaker Courtney, Jesus Sosa, Brad Stefanov, Michael Bourne and DarkBeam (in no particular order) for their contributions!

    This version is somewhat special to me: after really getting extremely pissed of at Facebook, I nearly threw the towel. But, after taking some time, I wanted to create something special, turning back to the roots. To put the user-experience into the centre. So the main changes in this version are not new functions (which are included a lot, of course :-)), but changes in the user-interface.
    They are rather complex, so I’m sorry, if they will not work for all of you “out-of-the-box”, I’m aware, that there is much room for improvement and fine-tuning.

    Breaking changes in short:

    • Realtime-editing was extremely optimized, editing fractals much feels like playing with liquid paint now (tested on Windows 10, Ubuntu 18.04, and macOS Mojave)
    • Creating random flames does not interrupt your workflow anymore, you may render or save flames, while random flames still are being generated, or have a closer look at random flames which are already were generated, …
    • Scripts can be easily imported from within the software by just chosing the *.zip-file, no manual extracting or copying of files is required anymore
    • Improved render-quality in the realtime-editor and more precise editing
    • Rendering of images with literally unlimited size (which exchanges render-size against time, so maximum size is not a matter of the power of your computer, it is just matter of dedication)
    • Some really interesting GLSL-emulation by Jesus Sosa, allowing to translate certain fragments from shadertoy.com into JWildfire-variations  – awesome idea!

    Complete changes (you can also see this list inside the program at the any time, see Help->List of changes ):

    • dramatically improved the smootheness of the real-time-editing: while dragging the mouse, the view is constantly updated,
      reflecting the change of the fractal. When you only see black editing-area, then often the fractal is changing too rapidly,
      just move slowlier to see the shape evolving, or wait a moment, while still having the left mouse-button pressed

      • reduded the change-rate when editing affine controls
    • new “Quilt Renderer”-module to render flames in nearly unlimited size. This works by splitting the whole image into tiles.
      You may freely specify how the tiles are generited, e.g. splitting the image in 3×2 tiles or 8 vertical stripes.
      Each of the rendered tiles is a valid image. So, even JWildfire would finally fail to assemble the tiles into one
      final image (due to memory restrictions), you could perform this step using external image-processing-software,
      which is more optimized to handle large images. But images with a size upto 32K (30720×17280) where tested
      without any problems so far. You can cancel/resume the rendering-process at tile-level.
      Please note: Due to the nature of the flame-fractal-algorithm, the rendering of each tile may take as long as you
      would render the whole image at once. So, this method is not efficient, but effective.
      A 16K render on a modern computer can take about 12 hours, but you will usually get an awesome result with endless details.
    • new button to easily import-scripts at the “Scripts and Custom-Buttoms”-tab. This function accepts all *.zip-files containing at least one script file (with the extension *.jwfscript). Associated text-files (descriptions) and any *.ugr-gradients are imported as well.
      Any other files are ignored. If the *.zip-file contains sub-folders, only the scripts inside the folders are extracted, but not
      the folder-structure itself. The function warns before overwriting files.
    • the flame-thumbnails on the left may now be properly scrolled using the mousewheel
    • selecting (double- or right-clicking) a frame from the thumbnail-bar now works much more reliable
    • many new variations:
      • metaballs3d_wf (somewhat slow, but can generate very nice organic shapes)
      • pointgrid_wf (flat random grid of points)
      • pointgrid3d_wf (3d-array of points)
      • invpolar (Brad Stefanov)
      • stripfit (Dark Beam, Brad Stefanov)
      • hypershift2 (Tatasz, Brad Stefanov)
      • hypercrop (Tatasz, Brad Stefanov)
      • truchet2 (Tatasz, Brad Stefanov, Jesus Sosa)
      • arcsinh (Tatasz, DarkBeam)
      • arcsech2 (Tatasz, DarkBeam)
      • arctanh (Tatasz, DarkBeam)
      • invsquircular (DarkBeam, Jesus Sosa)
      • squircular (DarkBeam, Jesus Sosa)
      • pyramid (Dark Beam, Brad Stefanov)
      • corners (Whittaker Courtney)
      • csc_squared (Whittaker Courtney)
      • atan2_spirals (Whittaker Courtney)
      • inverted_julia (Whittaker Courtney, Brad Stefanov)
      • acosech (Whittaker Courtney, Tatasz, DarkBeam)
      • acoth (Whittaker Courtney, Tatasz, DarkBeam)
      • acosh (Whittaker Courtney, Tatasz, DarkBeam)
      • intersection (Brad Stefanov)
      • curliecue (Jesus Sosa)
      • curliecue2 (Jesus Sosa)
      • szubieta (Jesus Sosa)
      • starfractal (Jesus Sosa)
      • triantruchet (Jesus Sosa)
      • arctruchet (Jesus Sosa)
      • swirl3D_wf (Jesus Sosa)
      • mandala (Jesus Sosa)
      • mandala2 (Jesus Sosa)
      • jac_asn (Jesus Sosa)
      • colordomain (Jesus Sosa)
      • ducks (Jesus Sosa)
      • bipolar2 (Brad Stefanov)
      • elliptic2 (Brad Stefanov)
    • new GLSL-family of variations by Jesus Sosa:
      After implementing a set of java functions that simulate almost the bunch of functions used in GLSL code for fragment shaders,
      I start to develop a set of JWF variations using the implemented functions, so I have translated fragment shaders (GLSL code)
      to java, using examples found in shadertoy.com and glslsandbox.com sites.

      • glsl_mandala
      • glsl_apollonian
      • glsl_fractaldots
      • glsl_circuits
      • glsl_mandelbox2D
      • glsl_hoshi
      • glsl_kaleidocomplex
      • glsl_starsfield
      • glsl_kaleidoscopic
      • glsl_randomoctree
      • glsl_acrilic
      • glsl_circlesblue
      • glsl_kaliset
      • glsl_kaliset2
      • glsl_grid3D
      • glsl_hyperbolictile
      • glsl_squares
      • glsl_code (to try out own stuff)
    • updated variations:
      • splits (new shear-parameters, Dark Beam, Brad Stefanov)
    • many awesome scripts, provided my Michael Bourne:
      • “UmmaGumma”-scripts (see new scripts starting with “UG-” in “Built-In-scripts”-category)
      • “Hubble”-scripts (see new scripts starting with “HB-” in “Built-In-scripts”-category)
      • “Samhain Splits”-scripts (see new scripts starting with “SX-” in “Built-In-scripts”-category)
    •  removed the dialog-options from the following built-in scripts, so they can executed in a more quick and simple
      manner (required paramerers are chosen randomly, instead of asking the user):

      • “Oily_Juliascope_Rev1”
      • “Oily_Rev3”
      • “Plastic”
      • “HypertilePoincare_Rev2”
      • “SphericalCross_Rev2”
      • “SuperSusan_Rev1”
      • “Textured_Cylinders_Rev01_by_MH”
      • “TomsSpiralSpiral_Rev3”
    • scripts can also be executed by simply double-clicking at them
    • new “JulianRings”-random-flame-generator
    • Main-Editor: there are now new three buttons at the left to easily open Interactive Renderer, Movie-Maker or Flame-Browser
      (the two buttons “Send to IR” and “Send to MovieMaker” are replaced by them)
    • new “reset clr”-button the “Gradient”-tab to reset all color-values and color-speed-values to 0
    • render-priority in the ui should now be set to low
    • bug-fix regarding rendering with enabled post-symmetry (Rick Sidwell):
      When Post symmetry is enabled, the result of clicking Render was dimmer
      than using Interactive Render, especially with large Symmetry order
      values. This change makes Render Fractal and Interactive Render produce
      the same results when Post symmetry is enabled.
    • bug fix EasyMovieMaker: when using multiple flames to morph between the slider at the bottom covered the edit, replace, remove buttons
    • internal scripts may provide their own gradients now
    • moved the “Misc”-tab to the bottom, the “Script”-tab was renamed into “Scripts and Custom-Buttoms” to give it more attention
    • improved the “Solid Labyrinth”-random-flame-generator
    • contributed two new images to the Launcher

    Just click the “Random flames” button to start playing around and have fun 🙂

  • JWildfire 3.50 release: big update!

    Just released JWildfire V3.50 which is a rather big update. Again, thanks Rick Sidwell, Jesus Sosa and Brad Stefanov for their valuable contributions!

    Changes in short:

    • simplified and faster user interface, no more nested windows
    • support for Java 10 (but you can still use Java 8)
    • affine3D-transform and affine3D-random-flame-generator which creates nice 3d-shapes
    • lots of new variations/transforms/formulas
    • lots of optimizations

    Complete changes (you can also see this list inside the program at the any time, see Help->List of changes ):

    • removed the desktop and the Navigator-window in order to simplify and speed-up the user-interface
    • faster app-startup, there are now 3 random flames generated at start (and it is still faster than before)
    • improved the resize-behaviour/speed of the main-editor-window
    • support for Java 10 (Please note, that JWildfire still works with Java 8 and Java 8 ist still supported by Oracle.
      But, Java 10 is also supported now, and when you want to use the UI-scaling-feature, you will need Java 10.)
    • many new variations:
      • affine3D (ported from Flamelet)
      • anamorphcyl (Jesus Sosa)
      • dc_kaleidotile (Brad Stefanov)
      • disc3 (Brad Stefanov)
      • glynns3subfl (Jesus Sosa)
      • gpattern (Jesus Sosa)
      • hyperbolicellipse (Jesus Sosa)
      • lazysensen (Brad Stefanov)
      • lozi (Brad Stefanov)
      • nsudoku (Jesus Sosa)
      • projective (Brad Stefanov)
      • pulse (Brad Stefanov)
      • pTransform (Rick Sidwell)
      • q_ode (Brad Stefanov)
      • ringsubflame (Jesus Sosa)
      • sunflower (Jesus Sosa)
      • sunvoroni (Jesus Sosa)
      • taprats (Jesus Sosa)
      • terrain3D (Jesus Sosa)
      • vibration2 (Brad Stefanov)
      • wangtiles (Jesus Sosa)
    • new “Affine3D”-random-flame-generator (also taken from Flamelet)
    • updated the jsyntaxpane-library (used for syntax-highlighting while editing text) to version 1.1.5
    • increased the default font size for the script-editor inside JWildfire
    • internal optimization/API-changes: extended the API of variations:
      there is now an initOnce()-Event which is only called once for the
      first thread (unlike to init() which is called for each thread).
      This new event should be used for heavy init-operations (like loading and parsing a file)
    • the following variations use the new API and should behave more smooth (=use less memory and CPU)
      when initializing for a render:

      • wangtiles
      • terrain3D
      • dla_wf
      • dla3d_wf
      • knots3D
      • sattractor3D
    • improved the speed of the following variations:
      • dustpoint
      • knots3D
      • sattractor3D
    • improved the stability of the following variations (Rick Sidwell):
      • brownian_js
      • dragon_js
      • glynnsim3
      • ghosperisland
      • hilbert_js
      • htree_js
      • koch_js
      • lsystem_js
      • rsquares_js
      • tree_js
      • new property tinaLSystemMaxLength in the prefs to specify maximum size of the generated string for the L-System variation
    • bug fixes for symmetry order and animation control update
    • fixed a bug regarding rendering motion-blur

    Just click the “Random flames” button to start playing around and have fun 🙂

  • JWildfire 3.31 release: Happy Easter!

    Just released JWildfire V3.31 – again with MUCH help of our contributors Rick Sidwell, Jesus Sosa and Brad Stefanov. Thank you, guys!

    Complete list of changes (you can also see this list inside the program at the any time, see Help->List of changes ):

    • new variations:
      • apollony (Jesus Sosa)
      • chrysanthemum (Jesus Sosa)
      • dc_dmodulus (Jesus Sosa, Rick Sidwell, and Brad Stefanov)
      • dc_gnarly (Rick Sidwell, and Brad Stefanov)
      • dustpoint (Jesus Sosa)
      • iconattractor (Jesus Sosa)
      • knots3D_js (Jesus Sosa)
      • macmillan_js (Jesus Sosa)
      • recurrenceplot_js (Jesus Sosa)
      • seashell3D (Jesus Sosa)
      • sattractor3d (Jesus Sosa)
      • threepoint (Jesus Sosa)
      • prepost_circlize (Rick Sidwell)
      • prepost_affine (Rick Sidwell)
      • prepost_mobius (Rick Sidwell)
        • Prepost variations are executed both before the other variations (along with other pre_ variations) and after the other variations (along with other post_ variations). One of the two will be an inverse function, calling invtransform instead of transform. Prepost variations are identified with priority 2 (calls invtransform for pre and transform for post) or -2 (calls transform for pre and invtransform for post).—
    • updated variations:
      • hamid_js – added more variables
      • jubiq – made it respect other 3D objects instead of making it flat
      • siercarpet_js – added preserveZ
      • parplot2d_wf – added a solid variable by default no new changes. Set to 0 they react more like traditional flames
      • pre_stabilize – Added a direct color option to pre_stabilize for coloring glitch flames
    • general changes/fixes:
      • changed the default filter to the same that is used by Flamelet which creates nice sharp images,changed the default filter to the same that is used by Flamelet which creates nice sharp images,  if you do not like it, you may change it in the Preferences
      • fixed the problem with the Mac-version, which could not be installed on many Macs in previous versions (because the new APFS was used due to a bug in the build tool)
      • optimed some default settings in order to allow faster editing
      • Make random gradients without fade colors use the right number of colors.
      • Bug fixes and enhancements to parameter list
        • 1. Pre button for variation 11 didn’t work
        • 2. Slider for params with dynamic parameter expansion didn’t work
        • 3. Added tool tip with full name when parameter name is truncated
      • Fix bugs with duplicate transform
        • 1. Final transforms now duplicate as final transforms
        • 2. Normal transforms now duplicate From Xaos as well as To Xaos
      • Fix UGR gradient loading for gradients saved by Ultra Fractal
        • 1. Newer version of Ultra Fractal don’t use numnodes, so the number of colors it contains is used to determine whether interpolation is needed instead.
        • 2. The UGR parameter “smooth=yes” indicates that the curves used to fade the gradient are smoothed, not that the gradient isn’t faded. The setColorsSmooth function was changed to reflect this.
      • Make the “Add linked transform” button copy xaos
      • Fixed bug with dynamic parameter expansion
      • Stereo3d bug fixes
      • Made labels reflect the current edit plane
        • Specifically, when the edit plane is changed, the affine labels (X1, X2, Y1, Y2) and the labels on the triangles (or rectangles) now change to match the new edit plane. This will make it easier to identify just what the modified values will affect.
      • Bug fix:gradient reset button breaks range editing
      • Made random gradient generator use variable widths for the colors

    Just click the “Random flames” button to start playing around and have fun 🙂 Happy Easter!

  • JWildfire 3.30 release: Merry Christmas!

    Just released JWildfire V3.30 – with MUCH help of our contributors Gregg Helt, Rick Sidwell, Jesus Sosa and Brad Stefanov. Thank you, guys!

    Again, there are  a lot of new variations – we have now more than 500! So, you will probably also like another new feature, allowing you to (de)activate rarely used variations (on the fly).

    Complete list of changes (you can also see this list inside the program at the any time, see Help->List of changes ):

    • new variations provided by Gregg Helt, Rick Sidwell, Jesus Sosa and Brad Stefanov:
      • dc_triTile, crop3D, spherecrop, loq
      • jubiQ, complex, quaternion
      • lsystem_js, lsystem3D_js, lorenz_js
      • brownian_js, dragon_js, gosperisland_js, hamid_js
      • hilbert_js, htree_js, koch_js, rsquares_js, tree_js
      • sattractor_js, wallpaper_js, hadamard_js, crown_js
      • apocarpet_js, invtree_js, siercarpet_js, woggle_js
      • lace_js, harmonograph_js, clifford_js, svensson_js
      • pre_stabilize to help stabilize glitch flames
      • pre_spherical, post_spherical
      • klein_group, inversion
    • new window to (de)active rarely used variations. When you are loading a flame (from disc or from the random generator),
      and a deactivated variation is detected, this variation will be enabled for this flame. So, you have not to worry about
      old flames or flames made by others (using another set of variations).
      Deactivated variations are indicated by a label having a font in strikethrough style.
      You may activate/deactivate variations at any time, in some cases you will have to reload the flame when you do this while
    • new “Raster”-random-flame-generator
    • new “Outlines”-random-flame-generator
    • new “Bold”-random-gradient-generator
    • changed the distribution of random gradient generators inside the “All”-random-gradient-generator (affects random flames)
    • increased flame-thumbnail-size from 90×68 to 120×68 (16:9)
    • Experimental “Mirror Translation” toggle-button to the Affine tab. The toggle applies to all three planes XY, YZ, and ZX.
      When toggled on, if viewing pre-affine, changing translation (01 or 02 coefficients) is mirrored by reversing the translation
      (setting post-affine to -01 and -02). And vice-versa if viewing post-affine. This mirroring is very handy for some of the new
      variations I’ve added such as Inversion and KleinGroup and for existing variations such as Spherical, which use mathematical
      operations that typically in other contexts are composed with a translation T and its inverse T’ to move their center from the
      origin: G_shifted = T(G(T’)). A boolean is added to the transform in the flame so that the mirror toggle state is saved to
      and restored from flame files.

    Just click the “Random flames” button to start playing around and have fun 🙂 Merry Christmas!

  • JWildfire 3.21 release: many new variations

    Just released JWildfire V3.21 – most work was done by Brad Stefanov, Darkbeam, Gregg Helt and Rick Sidwell this time – thanks a bunch, guys!

    Complete list of changes (you can also see this list inside the program at the any time, see Help->List of changes ):

    • Add setBGTransparency line to scripts converted from flames. When a script creates a new flame, it sets bgTransparency to true by
      default, so scripts converted from flames didn’t preserve the setting from the flame. Added a setBGTransparency call to do so. By Rick Sidwell
    • Compatibility for addLinkedXForm. Made addLinkedXForm set the draw mode of the from xform to HIDDEN and the symmetry
      of the to xform to 1. This matches the behavior of Apophysis, making it easier to follow tutorials for that program. By Rick Sidwell
    • New variations (Thanks to Gregg Helt, dark-beam (Luca), Rick Sidwell and Brad Stefanov for conversions and new variations):
      • MaurerLines, MaurerRose, Minkowskope, TruchetFill, Panorama2, Panorama1, SphTiling3V2, TruchetAE, R_Circleblur, MinkQM, Sigmoid, BlurLinear, Gridout2, Gridout, Crob, Hole2, Cpow2, Cpow3_wf and DCCracklePWF.
      • Added Apo Cpow3 and had to rename previous Cpow3 by Gregg Helt too Cpow3_wf
      • Bugfix on isoplot variation formula 26
    • Even more work on variations, contributed by Rick Sidwell:
      • dc_cylinder
      • dc_cylinder2
      • swirl3
      • cardiod
      • shredrad
      • improved backwards-compatibility for oscilloscope and oscilloscope2
    • experimental “UI scale”-setting in the launcher. Works only since Java9. Scales up the UI, in a consistent manner, by the given factor.
      (To use Java9: install it from oracle, then in the launcher chose “Add runtime”. Navigate to “C:\Program Files\Java\jdk-9\bin” and select “java.exe”)
      (For good results, you should reset the value of “tina.general.font_scale” in the Preferences to 1, if you used a higher value)
      (Please note, that Java 9 is not officially supported, yet – there are already known problems (e. g. custom gradiens seem not to work).
    • fixed the font-size of the edit-plane-buttons

    Just click the “Random flames” button to start playing around and have fun 🙂

  • JWildfire 3.20 release: point-cloud export

    Just released JWildfire V3.20 – which is another community release, thanks to Brad, Rick and Luca for your contributions!

    This is a major release featuring a new kind of mesh-export: point-clouds. Point-clouds basically are meshes with 1-point-polygons.
    In contrast to the solid meshes, the “points” of the generated point-clouds may have also an individual color and an alpha channel
    (which may be used in rendering).

    3D-Packages like Houdini can render point-clouds in the way that each point is represented by a little sphere
    (you usually can adjust the size of those spheres), generating a “solid” shape.
    You can apply materials to point-clouds like to any regular mesh. Especially in Houdini, the points keep their individual
    (diffuse) color.

    You can also generate “solid” meshes from point-clouds, for example using the ball-pivoting-algorithm inside

    Important Parameters for point-cloud-generation in JWildfire (use “Output type” POINTCLOUD to enable it):

    • CELL-SIZE: the program uses an octree to quantize the space into little small cubes. All samples inside a cube
      are later condensed into one point of the point-cloud. So, this setting basically affects the
      “resolution” of the generated mesh. But beware, please make it only smaller in small steps,
      otherwise memory consumption may grow in an “explosive” way
    • RENDER QUALITY: overall number of samples, increase it only if your mesh has noise/holes in it
    • OUTPUT FORMAT: you may either use *.ply or *.obj. But beware, this option has also an impact on the generation
      of the point-cloud:

      • PLY-Format: only vertices (“points”), with color and alpha channel (works good for Houdini)
      • OBJ-Format: vertices and 1-point-polygons, NO color and NO alpha channel (works good for Lightwave Hypervoxels)

    Complete list of changes (you can also see this list inside the program at the any time, see Help->List of changes ):

    • New “POINTCLOUD”-generator inside the Mesh-Generator.
    • New Variations – Thanks to dark-beam (Luca) and Brad Stefanov for conversions
      • Spirograph3D by Rick Sidwell.
      • Hypershift, Helicoid, Helix by Zy0rg.
      • Atan by FractalDesire.
      • Chunk, Erf, Erf3D, Gamma, XErf by zephyrtronium.
      • Circular, DSpherical, Shift by Tatyana Zabanova.
      • Circular2 by Tatyana Zabanova variables added by Brad Stefanov.
      • Pressure_wave by timothy-vincent.
    • Fixes
      • Fixed issue reading apo parameters in GlynnSim variations. By Rick Sidwell
      • Fix bug reading repeated variations in a transform. By Rick Sidwell
      • Added lgamma to Math.lib for gamma variation to work.
      • Fixed some performance problem in solid rendering
      • fixed a problem with calculation of normals in solid rendering

    Just click the “Random flames” button to start playing around and have fun 🙂

  • JWildfire 3.11 release: many new variations

    Just released JWildfire V3.11 – most work was done by Brad Stefanov and Rick Sidwell this time – thanks guys!

    Complete list of changes (you can also see this list inside the program at the any time, see Help->List of changes ):

    • New Variations:
      • Cot2_BS,Csc2_BS,Tan2_BS,Sec2_BS,Exp2_BS,Sin2_BS,Csch2_BS,Cosh2_BS,Sech2_BS,Coth2_BS,Sinh2_BS,andTanh2_BS complex variations by cothe with added variables by Brad Stefanov
      • Cosq,Sinq,Tanq,Tanhq,Coshq,Sinhq,Cotq,Cothq,Cscq,Cschq,Estiq,Secq,Sechq from the Quaternion Apo Plugin Pack by zephyrtronium implemented into JWF by Brad Stefanov
    • Fixes
      • Fixed bug in TileHlp. by Brad Stefanov
      • Fixed Log_tile with new variation Tile_log for keeping compatibility … will keep both variations since they work in different ways. By Brad Stefanov
      • Fixed bugs in XTrb by Rick Sidwell
      • Changed getCoeffxy to getXYCoeffxy for variations that use them. By Rick Sidwell
      • Fixed bugs with the Falloff3 variations. By Rick Sidwell
      • Fix misc. variation bugs. Most pre and post variations should assign, not add their results. Fixed this in multiple variations to match the original apo plugins. By Rick Sidwell
    • Misc
      • rendering/processor-usage is more smooth now, avoids blocking (may slightly decrease render speed, but is more responsive on most systems.
        If max render speed is extremely important for you, than keep the old version) – by Andreas Maschke
      • “subflame_wf” – variation now also supports flame-sequences as input (to animate the subflame) – by Andreas Maschke

    Just click the “Random flames” button to start playing around and have fun 🙂

  • JWildfire 3.10 release: improved image-quality and much other fun

    Just released JWildfire V3.10.

    Among a lot of different changes, two major features stand out: improved image-quality (sharpening and anti-aliasing) and an easy-to-use background-gradient-function.

    Complete list of changes (you can also see this list inside the program at the any time, see Help->List of changes ):

    • Image-quality:
      • new “Filtering”-option at the Anti-Aliasing/Filtering-tab to distinguish between the various types of filtering:
        GLOBAL_SHARPENING, GLOBAL_SMOOTHING, ADAPTIVE. The “Filter kernel” option is populated accordingly.
      • new MITCHELL_SMOOTH-filter kernel (derived from MITCHELL), which is now the default
      • improved the behaviour of sharpening filters (causing less artifacts)
      • “Sharpness indicator” and “Low density”-parameters at the “Anti-Aliasing/Filter”-tab (affects only adaptive filtering)
      • new experimental adaptive MITCHELL_SINEPOW-filter (sharpenung details, smoothing “unsharp” areas as well as areas with low density)
      • new “low brightness”-property to show/hide areas with lower density, increasing this value usually leads to more detail, while decreasing
        this value may help to hide unwanted border areas
      • increased default oversampling to 2 in order to increase default quality
    • Editing:
      • reimplemented the preview-cache (all options at the coloring-tab do not need a recalculation do show changes). In general, all properties
        which do not need a re-render are indicated by a star at the label, e.g. “Brightness*”. Is is recommended to do a quickrender before adjusting them,
        so can apply changes in almsot realtime to a decent image.
      • improved the quality of the preview in the main editor
      • the channel-mixer also works in “realtime-mode” now
      • new color-balancing options at the “Coloring”-tab
    • Flame-saving/flame-thumbnail-selection
      • new SaveAll-button which saves all selected flames into a single file (thanks to Michael Bourne for the suggestion)
      • new checkbox at each flame-thumbnail to (de)select it
      • new popup-menus at the flame-thumbnails (press the right mouse-button over a button to display the menu):
        • remove-button: new popup-menu to remove all or remove selected flames
        • checkbox (sometimes referred as “select-button”: new popoup-menu to toggle selection or deselect all
      • added confirmation dialog to the thumbnail-delete button
    • Background-gradients:
      • new 2×2 gradient-type for the background of fractals , may also be changed in “realtime mode”
      • new 2×2+c gradient-type for the background of fractals (which is the new default)
    • Mesh-Generator:
      • optional post-smooth (Taubin-smooth) in the mesh generator
      • removed the parameters “Thickness mod” and “Thickness samples” (just fix your model if is has “holes”) in the mesh generator
      • improved the rotation-behaviour of the mesh-preview in the Mesh-Generator
      • improved the heuristics to calculate “depth” when creating a mesh from a voxelstack
      • fixed (again) a serious bug in the Mesh-Generator: when rendering image-stacks
    • Misc:
      • new “Machine”-random-flame-generator
      • detect flames with invalid (xaos) settings and stop to render them
      • indicator-mode for adapative filtering (i. e. showing sharp/smooth regions)
      • fixed some labels which were not scale accordingly the global “tinaFontScale”-property
      • rearranged some controls at the coloring-tab
      • new variations, provided by Brad Stefanov (“waves2_radial”, “spliptic_bs”, “circlesplit”, “log_tile2”, “mobiq”, “tile_hlp”)
      • lots of new presets for the “isosfplot3d_wf”-variation, provided by Frank Baumann and Brad Stefanov
      • some performance increase on some of the DOF-blur-shapes
      • increased quality of DOF in 3D-mode, but needs much more time to compute
      • removed the color-oversampling/jittering-option

    Just click the “Random flames” button to start playing around and have fun 🙂

  • JWildfire 3.01 release: major bugfix in MeshGen

    Just released JWildfire V3.01.

    List of changes:

    • Fixed a serious bug in the Mesh-Generator: when rendering image-stacks
      each image inside a slice was the same. This was causing meshes to be very
      “chunky”, depending on slice-size.
      The only workaround was to set slice-size to 1, i. e. rendering one image
      per slice, which causes a major slowdown.
    • minor improvement in rendering speed
    • new “isosfplot3d_wf”-variation for plotting iso-surfaces (may be very slow on old machines)
    • new “dc_color”-parameter for the “colormap_wf” and “post_colormap_wf”-variations
      to turn coloring off (in case you want only use the image as heightmap)
    • new “blend_colormap” -parameter for the “colormap_wf” and “post_colormap_wf”-variations
      to improve quality

    Just click the “Random flames” button to start playing around and have fun 🙂

  • JWildfire 3.00 release: 3D rendering, improved UI and Mac OS X support

    It has been a while since the last release, but sometimes things just need time 🙂
    I can’t remember exactly, but I think we had in the end 6 ALPHA versions and 9 BETA versions to finally finish
    what is now simply called “JWildfire 3.0“.

    I know, most people never read notes, and I hope I will still have your attention. In short:
    new version = 3d rendering + new UI + experimental GPU rendering + Mac OS X support + endless list of changes

    endless list of changes = integrated in the UI, so no need to read too much at once, it will be still there
    when you start the app the next time 😀

    The complete list of changes is tremendous, I will post only a little excerpt:
    – completely new 3d (solid) rendering mode for flame fractals, featuring
    – ambient shadows
    – distant light-sources
    – specular lighting, several diffuse-response functions
    – reflection-mapping
    – hard and soft shadows
    – z-buffer-output

    – new “obj_mesh_wf” and “obj_mesh_primitive_wf”-variations to allow you to integrate
    meshes as shapes into your fractals. While “obj_mesh_wf” allows you to load arbitrary
    meshes (e .g. found in the web, there are tons of free meshes out there), you may
    use “obj_mesh_primitive_wf” to use numerous predifined presets
    – both variations support:
    – uv-colormaps
    – uv-displacement-maps
    – geometry-smoothing (using the Taubin-smooth-algorithm)

    – new “yplot2d_wf”-, “yplot3d_wf”- and “parplot2d_wf”-variations to generate geometry
    by plotting arbitrary mathematical functions (e.g. “sin(x*x+z*z)”)
    – all of those variations contain many very cool presets, e.g. there are 35 presets
    included in the “parplot2d_wf”-variaton, just slide through them by changing the

    – new “plane_wf”-variation for easy creation of a textured plane
    – script-generator (which creates scripts from a flame) also creates solid-attributes
    for solid flames

    – support for invisible objects which can receive shadows. This way you can let
    fractals cast real-looking shadows on objects inside a background-image, inspired
    by Oak Fractal Sandbox by David Byrd (http://www.davidbyrd.io/)
    – this options is supported by the variations “obj_mesh_wf”, “obj_mesh_primitive_wf”
    and “plane_wf”

    – completely new DOF for solid rendering with bokeh-effects. This DOF is a post-effect
    (and works totally different than the regular DOF) and is not visible in the fast-preview(!).
    But, it also gives better results.
    One way to adjust the DOF is to turn solid rendering of in order to show the regular DOF
    in fast-preview, adjust it (position and strength),
    and then turn solid rendering on again

    – new “Solid Julia3D”-random-flame-generator to create random solid flames
    – new “Solid (experimental)”-random-flame-generator to create random solid flames
    – new “Solid (stunning)”-random-flame-generator to create random solid flames
    – new “Solid Labyrinth”-random-flame-generator
    – new option in the Prefrences to disable solid-flame-random-generators inside the global “All”-random-flame-generator

    – huge UI change: the main flame-window was broken into multiple smaller windows
    – new Navigator-window to make it easier to navigate between windows
    – window-state for all windows inside the desktoip is saved in the Preferences
    – new “Tips of the day”-window, may be turned off
    – the Welcome-window (still providing some useful links) is not show per default,
    but you can reach it in the menu
    – Customizable background and convenience-darkening effect (see
    desktopBackgroundImagePath and desktopBackgroundDarkenAmount in the Preferences)
    – supplied a background-image from my own library
    – removed the combobox to select the edit-plane, and added three buttons in the
    main editor area instead
    – new “List of changes”-window to display the list of changes made in the software
    – improved image-quality for scaled image-display on the desktop (e. g. after
    loading an image or displaying a rendered image)
    – option to auto-reload saved images from the interactive renderer (in order so be
    able to check them quickly), may be turned off in the Preferences
    – option to manually save a z-buffer-image in the interactive renderer
    – buttons to easily randomize light-position and light-color (for solid flames)
    – the params in the nonlinear-tab can now get “expanded” in order to access them
    all at one time, thanks to Martin Flink to the suggestion!
    – new parameter tinaDefaultExpandNonlinearParams in the Preferences to turn the
    expansion of the nonlinear-param-controls per default to on
    – exchanged some icons in the main editor
    – variations-editing: the controls use non-fractional step-size when changing a parameter having integer-values (like
    power of “julia3D”-variation)

    – experimental gpu-rendering by integration of FACLRender, and external GPU
    renderer, made by Steven Brodhead (see the integrated info-window for more
    – new info-window about GPU-rendering
    – new GPU-render window to interactively render flames, only available
    under Windows.
    Quick way to test out if a certain flame works, you would usually do this,
    before you animate it, and then finally use the batch-renderer with enabled
    GPU-renderer to render a sequence.
    – integrated the external OpenCL-renderer in the batch-renderer
    – new option tinaFACLRenderOptions in the Preferences to influence the options
    used to invoke the external GPU render

    – native installer for Mac OS
    – some optimizations for Mac OS X to improve user experience
    – made “System” the default theme under MacOS
    – renamed the main class to JWildfire in order to get “JWildfire” displayed as application on Mac
    – changed to initial directory for the directory-select-box in the flame-browser (works now on Mac)
    – set up default resolution- and quality-profiles when no preferences file could be found

    – new “Orchids”-random-flame-generator

    – New local hue parameter at the Local Gamma tab (called “Gamma”), allowing much more variations in color than using only the default coloring
    – New randomizer-buttons at the Local Gamma tab, to randomize each parameter individually

    – added a quarter-render-size option in the Interactive Renderer

    – Removed the Shading-tab and all the options for Blur-Shading, Distance-Color-Shading and Pseudo3D-Shading.
    – the popular blur-shading was re-introduced as new option under the “DOF / Bokeh” – tab as “Post blur”
    – distance-color-shading was removed completely, if you liked it, please keep an old version
    – Pseudo3D-shading is obsolete due to new 3d rendering

    – removed the rarely used brightness-slider in the main editor
    – removed the rarely used Chaotica-bridge

    – recreated the SystemInfo window and added a function to clear the cache (which hold resources like fonts, meshes, …
    in order to speed up future calculations)
    – new “Transfer to Interactive Renderer”-button in the main editor
    – removed the MutaGen-button in the main editor

    – added two new parameters to the “subflame_wf” variation: “colorscale_z” (adds depth to the outer flame according
    to the color-information of the inner flame) and “use_colors” (use the computed color-information of the inner
    flame as color of the outer flame)
    – the “subflame_wf”-variation also respect hidden samples now and can recover iteration after receiving
    invalid results (e. g. division by zero)

    – added new parameters “axis”, “centre_x”, “centre_y” and “centre_y” to the “pre_wave3D_wf”-variation
    – added experimental “direct_color”-parameter to the “truchet”-variation

    – new “MobiusN”-variation by eralex

    – replaced the link to variation-guide, hosted by user FractalGee, which seems to be permanently off, by a link to
    the variations-list supplied by Don Town

    – 3 new SINEPOW-filter-kernels (with predefined power-levels)

    – the “Rnd”-button now can also operate on newly created flames

    – refined the default resolution- and quality-profiles

    – improved the speed of the MutaGen

    – changed the layout of the sub-tabs “DoF” and “Solid rendering”

    – slightly shorter startup time due to the use of more simple random-flames-generator at startup

    – support for loading and saving Fusion-compatible *.spl-files in the motion-curve-editor

    – moved the “Rnd”-button at a new “Misc”-tab

    Have fun!

  • JWildfire 2.60 release: the HUGE update :-)

    Just released JWildfire V2.60, which is a really HUGE update. This time, it took 7 BETA-versions until completion, thanks to the guys at the forums for suggestions and testing :-).

    Here are the update-notes, please read them carefully 🙂

    Major changes:

    • New progressive preview, which allows progressive rendering while editing.
      While it needs much CPU-power it is a great new way to explore interesting spots inside your fractals, it is especially of great use in combination with the “Fine Edit”-option.
      It also allows you browse random-flames or flames generated by scripts at higher quality because the quality increases while you are watching at the fractal.
    • Any variation may be now be easily toggled to be pre_/normal/post_ – variation. This feature uses minimal changes in the user-interface and it does not break anything, e. g. all scripts should be remain intact without any further change
    • Separate (and resizable) window for editing scripts with a more advanced editor with basic syntax-highlighting
    • Some new random-generators, including the “Spirals3D”-generator which generates cool 3D-flames (i. e. flames with affine3D-transforms, not just the usual z-translation-stuff)

    Complete list of changes:

    • New progressive preview, which allows progressive rendering while editing.
      While it needs much CPU-power it is a great new way to explore interesting spots inside your fractals, it is especially of great use in combination
      with the “Fine Edit”-option.
      It also allows you browse random-flames or flames generated by scripts at higher quality because the quality increases while you are watching at
      the fractal.There is a new button to toggle progressive-preview in the main-editor (you may switch between classic preview and progressive preview at any time),
      and there is a new option in the Preferences to specify the initial state of this button (tinaEditorProgressivePreview).
      So, if you machine is too slow, you may just permanently disable it and use the default preview which was also slightly improved.There are new options tinaEditorProgressivePreviewMaxRenderTime and tinaEditorProgressivePreviewMaxRenderQuality in the Preferences to control the render-time of progressive preview.
    • any variation may be now be easily toggled to be pre_/normal/post_ – variation. This feature uses minimal changes in the user-interface
      and it will not break anything, e. g. all scripts should be remain intact without any further change
    • added the possiblity to change the position of variations inside a transform
    • New “Low priority”-option in the the launcher. This options is only available under Windows and enabled by default. It should cause a general smoother behaviour of the software.
    • providing a more advanced editor with basic syntax-highlighting for editing scripts and custom variations (thanks CozyG for the java8-related fix)
    • separate (and resizable) window for editing scripts
    • new “Batch Renderer”-button which quicksaves the current flame and sends it together with size/quality information to the batch-renderer
    • new “post_axis_symmetry_wf”-variation
    • new “post_point_symmetry_wf”-variation
    • new “mobius_strip” by CozyG
    • removed the confusing “H”-Button from the main-editor in order to free space, cleaned up the main toolbar
    • adjustment to brightness-calculation when using post-symmetry
    • rearranged some buttons so that it is unlikely to press the MutaGen-button by wanting to press Undo (important because the MutaGen currently can not cancelled)
    • new “Reset”- and “Reset All”-buttons on the Xaos-tab
    • Optimization of preview-rendering: do not re-render flame after switching “triangles”
    • Optimization of preview-rendering: do not re-render flame after switching editor modes
    • new “Spirals”-random-flame-generator which can generate awesome results, thanks Tate27kh from dA for the inspiration!
    • new “Ghosts”-random-flame-generator
    • new “Spirals3D”-random-flame-generator (which utilizes the “Spirals”-generator)
    • improved the “Brokat”-random-flame-generator (uses the ability to switch variation-types, see below)
    • improved the “Simple Tiling”-random-flame-generator
    • reimplemented the “Brokat3D”-random-flame-generator to generate more visually appealing results
    • reimplemented the “Gnarl3D”-random-flame-generator to generate more visually appealing results
    • new Option “tinaAdvancedCodeEditor” in the Prefs to turn off the advanced code-editor. May not work on all systems/may not look good on all themes, especially the true dark ones.
    • the Script-From-Flame-Generator also supports flames with 3D-affine transforms
    • the Script-From-Flame-Generator also respects the new variation-priority
    • created a v6 of the Custom_Variation_Loader_GH-script by CozyG, which now used the new Prefs-option for the path and included this version as standard script
    • new property tinaCustomVariationsPath in the Prefs to specify the path for external custom_variations (used by the Custom_Variation_Loader_GH script by CozyG).
    • modifications to ScriptParamsDialog and ScriptParamsForm to keep script params modal dialog centered on JWildfire main frame.
    • added use of tinaAdvancedCodeEditorFontSize and tinaAdvancedCodeEditorColorFix to ResourceDialog.
    • performance-improvement of the MutaGen
    • fixed some zoom-calculation-bug when zooming with the mouse-wheel
    • fixed some problem with parameter-handling in the “trade”-variation
    • moved the gradient-editor-button to the gradient-tab
    • removed the outdated start_windows.bat from the distribution (Windows-users should use JWildfire.exe instead to properly start the application)
    • updated the Win64-distribution to java8

    Just click the “Random flames” button to start playing around and have fun 🙂

  • JWildfire 2.57 release: IR reloaded

    Just released JWildfire V2.57.

    This version comes with some important optimizations and fixes, especially to the Interactive Renderer (IR):

    • it should be much faster now
    • the final images created by the IR should be the same like the images created by the static renderer at the same quality (there were always differences until now, because those two renderers work differently)
    • saving an image while rendering should be much faster and never lead to freezes, because the rendering is paused automatically while saving

    Complete list of changes:

    • Major speedup in the interactive renderer
    • Tonemapping in the interactive renderer should now be exactly the same as in the fixed renderer (i.e., the final images should be the same when the quality is the same)
    • while saving an image the rendering is paused in order to avoid to too heavy load or even freezes of the java-process
    • fixed the behaviour of the main progress-bar (was sometimes not updated)
    • Windows-Launcher:  fixed the problem with paths which contain spaces (i.e. you can now have the JWildfire-folder at any local folder, e.g. at “C:\Program Files” etc.)
    • added some Author-informations to the JWildfire.exe-file, otherwise some virus-scanner seems to be too nervous about the file 😉
    • slightly increased the default image-quality
    • improved the “Black&White”-random-flame-generator
    • Problem fixed regarding parameter handling in the variations “trade”, “w”, “x”, “y” and “z”
    • the native plugins for the Chaotica-bridge are available as external download-packages now

    Just click the “Random flames” button to start playing around and have fun 🙂

  • JWildfire 2.56 release: improved render-quality

    Just released JWildfire V2.56.

    This version comes with the following major new features:

    • improved render quality: spatial oversampling and a few of other option to significantly improve render-quality (see the official Wiki for details: http://wiki.jwildfire.org/index.php?title=Manual_RenderQualityFlameFractals)
    • visualisation of filter-kernels to make it more transparent how filtering works and how different settings work
    • reduced memory-usage (needs about 50% of memory with identical settings as before)
    • simplified install: no more installer, just unzip, additional package for Windows 64 Bit with pre-installed Java and Leap-motion-dll’s

    Complete list of changes:

    •  new spatial-oversampling-option for improved render-quality. The default value is 2, this may be set in the Preferences
    • visualisation of filter-kernels for better understanding/easier customizing of the spatial filtering process, both a nice-looking 3d-mode and a fast 2d-mode are available
    • new sample-jittering- and color-oversampling-option for improved render-quality. The default value is off, this may be set in the Preferences.
    • new post-noise-filtering-option for redusing noise of the final noise by using an adaptive gaussian filter. The default value is off, this may be set in the Preferences.
    • added a brief description of all of this options in the official Wiki: http://wiki.jwildfire.org/index.php?title=Manual_RenderQualityFlameFractals
    • changed the memory management/layout of the iteration buffer (rendering should now take significantly less memory, and initialisation of rendering runs substantly faster, comes to a cost of only slightly degraded render time)
    • the final image-generating-process now works fully multi-threaded and should be faster
    • added a new experimental option “Opacity” to control the opacity of the foreground when rendering an image with background (often those renders caused the loss of too many details)
    • new “Pseudo3D”-random-flame-generator
    • improved the “Xenomorph”-random-flame-generator
    •  improved the “Cross”-random-flame-generator
    • some more useful statistics in the interactive renderer, e.g. absolute render-speed-indicator to make it easier to compare different settings (render speed means the quality level the renderer can reach in one hour)
    • the windows-launcher (JWildfire.exe) should now be much smarter to find a valid Java-install
    • completely removed the izpack-installer (until now there were always two files: a *.zip for users who just wanted to unzip, or an izpack-based installer which caused too many problems)
    • there are now two packages available: platform-independant without jdk and any dll’s, and windows64 with jdk and certain dll’s
      – removed the applet from the distribution
    • the Chaotica-integration is now disabled by default (in order to hide the export-button which may occupy important space for some users)
    • changed the animation-playback in the main-editor to full-window-size
    • made the detached renderer and the interactive renderer to behave more smooth
    • progressbar-update should be much smoother now, i.e. use less ressources
    • negative “perspective”-values are allowed now (again)
    • when using post-symmetry, the maximum of symmetry-order of point-symmetry was increased from 18 to 36
    • new ouputchannel to change param-values of plugins via the Leap Motion controller
    • added a new option tinaIntegrationChaoticaAnimationExport to the preferences. This option controls if the flames which are exchanged over the Chaotica-bridge are animated flames or static flames. In case you export them as static flames and have not a Studio licence for Chaotica you may render in higher resolutions.
    • fixed a bug in the crop-like variations
    • fixed a bug regarding autoimatically saving the current flame in the iteractive renderer
    • some refactoring of the structure synthesizer
    • completely removed all experimental opencl-code

    Just click the “Random flames” button to start playing around and have fun 🙂

  • JWildfire 2.56 BETA 3 release: memory-usage reduced

    Released the BETA 3 which was optimized regarding the usage of RAM:

    • default rendering should now use substantly less memory (should be about 50% of usage of previous versions)
    • the initialization of render-buffers should be insanely fast in comparison to earlier versions (does only matter having very large renders, but then it really matters)
    • animation-playback in main-window was changed to full-size


  • JWildfire 2.56 BETA 2 release: performance improved

    Released the BETA 2 which adresses several performance issues:

    • default rendering is faster now
    • rendering in the interactive renderer/detached view is substantly faster
    • render-display-update in the interactive renderer/detached view is changed to non-buffered by default (you may change this in the Preferences, property tinaOptimizedRenderingIR)
    • faster and smoother update of the progress-bar while rendering


  • JWildfire 2.56 BETA release

    Hi all,
    in the last weeks I was working on some major changes which I should have done much earlier, but never found the time before: increasing the render-quality! The new version actually works quiet good, but there were so many changes under the hood that I decided to release a BETA-version to receive your feedback before the final release.


    So what has changed?

    The previously used cheap antialiasing-mode was completely removed.

    To increase image quality and reduce noise there are now the following options (at the Antialiasing/Filter-tab):

    • spatial oversampling
    • apply one of 14 supplied filtering kernels (depending on the fractal, to increase sharpness or reduce noise)
    • in order to help you to choose the right filter, there is a visualisation of the filter-kernel, either in flat or 3d-mode. As a rule of thumb: sharpening filters have negative parts (indicated red in 2d-mode)
    • color oversampling
    • sample jittering
    • post noise reduction

    I will describe those options later at the official Wiki, just have fun to play around with them.


    You will notice that the renderer appears to be slower. But, it isn’t, in fact it is faster. It just renders at spatial-oversampling-level of 2 per default (i. e. internally rendering an image which is larger by factor 4 in size).

    So you should now get better quality in nearly the same time, maybe in some more time. But, more importantly, there is no need to render at insane quality levels to render an image in decent quality.


    You may change all the new default settings in the Preferences.


    Any feedback is welcome