Home

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!

– fixed a bug regarding calculating the offset in tone-mapping (causing the final image shifted under certain circumstances)
– fixed a bug regarding mouse-sync while dragging triangles or control-points with mouse
– minor improvement of the smoothness of the realtime-display
– minor optimization to the renderer
– minor fix regarding caching of render-buffer
– new variations by Whittaker Courtney:
– tile_reverse
– sqrt_acoth
– sqrt_acosh
– sqrt_asech
– sqrt_atanh
– sqrt_asinh
– sqrt_acosech

Please re-download and re-install V4.00 in order to get updated version.

• 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
• reduced 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 by 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

Flamelet is a very creative app for generating fractal art in a playful way. It does this by implementing the fractal-flame-algorithm, originally invented by Scott Draves, in a very versatile and efficient way.

There is literally an endless number of possibilities, and you never will have seen all.

Flamelet was designed from ground up for mobile devices, is easy to learn, but hard to master. This makes it an app, which has the potential to never become boring.

Flamelet gives you the freedom, either to create your own art from scratch, or to generate random flames and modify them.

There are numerous flame-generators included, all of them with the potential to generate endless beauty.

Speaking about art, the app can render your creations in a very decent quality, directly on the device, without any additional costs.

Unlike to those fractal-zooming/scrolling-apps, Flamelet allows you to actually create fractal art. Either from scratch or by just modifying already created art with your fingertips.
Both, a playful and an exact approach are supported: you may just drag around controls or enter exact numerical values.
Of course, many combinations of formulas are already well-known, but you can try out your own ideas or just play around to find out new combinations.

 

Official site: flamelet.io/

Flamelet at the App Store: itunes.apple.com/app/id1387331406

Latest Galleries..

Created with Flamelet & Frozio App – IoS

The free update to version 1.10 is now available on the App Store.

This versions supports now 3D-flames, while 2D-flames are rendered with the same efficiency as before.

Complete list of changes:

• 3d-flames (iterating points with three coordinates (x,y,z) instead only two (x,y))
• four new random flame generators (for generating 3d-flames)

New variations

• ztranslate, zscale, zextrude, zcolorshift, scale3D, zcone, zclear, zblur
• affine2d, affine3d
• cylinder3D
• curl3D
• flower
• flux
• twoface
• escher
• julia3D, julia3Dz
• mobius
• mobiq
• pointgrid3D
• wave3D
• spherical3D

Improved variations:

• bokeh (3d support)
• dinissurface

Improvements/bug fixes

• improved add transform-window
• increased (doubled) the time for a long-press
• fixed a bug causing the app to terminate after you double-tapped in the main editor view, when a color transform was selected
• fixed a bug causing buttons displayed at the wrong position in the “render/images” section
• improved the code regarding image-sharing to Facebook
• internal optimizations to the renderer
• some more resolutions added to the render module
• new camera section in the editor, some options in the editor-popup removed
• slightly improved undo
• updated the reference manual