#+$ Winfract (Fractint for Windows) 

Copyright (C) 1990-2006 The Stone Soup Group.

Winfract (Fractint for Windows) may be freely copied and distributed, but may not be sold.

Help Topics
	What's New?
	File Menu
	Fractals Menu
	View Menu
	Colors Menu
	Help Menu
	Fractal Formula Selection
	Zooming in on an Image
	Mandelbrot/Julia Toggling
	Color-Cycling
	Fractint-Style Help and Prompts
	Coordinate Box options
	Limitations in Winfract
	Distribution Policy, Contacting the Authors, The Book
	A list of Winfract and Fractint Authors
	
#$+K 
What's New in this Release?

This release of Winfract is essentially the same as the version 18.2 but with the following enhancements:

- All fractal types from Fractint 20.4 (with the exception of the 'julia_inverse' fractal type, which requires some extra logic we haven't yet added to Winfract) have been incorporated into this version of Winfract.

- The File Open, File SaveAs, and File Print options now use the new Windows-style "common dialog boxes", with the extra capabilities provided by those routines.   This is particularly handy if you're using Windows-for-Workgroups or Windows NT, 2000, XP with their networking options.

#$+K 
Fractint-Style Help and Prompts

Fractint's hypertext-like online help (all 350+ screens' worth!) is available at the push of a button (specifically, the Control-F1 button - the F1 button brings up this Winfract-specific help system).  Note that Fractint's online help is just that - Fractint-specific online help.  While much of that help is common to both Fractint and Winfract, some of it (the sections on printing, the palette editor, and the 'V(iew)' options come to mind right away) describe items that have nothing to do with the Winfract environment.  Also, Fractint's online help is not context-sensitive at the moment - you always start at Fractint's initial help index screen when you press Control-F1.

Many Fractint-style hot-keys are also available.  Depending on the status of the "Hot-key Actions" option (found in the "Options" menuitem), these hot-keys will either take you directly to the appropriate Winfract menu or to a text-based prompting screen directly from Fractint.  Note that some functions (printing and selecting video modes are prime examples) are so different between the DOS and Windows environments that you will be taken to a Windows-style menu even if you've selected Fractint-style prompts.

The Fractint-style "Hot-Keys" and their actions are listed below.  Items marked with a "*" are not connected to a Fractint-style prompting screen and will always take you directly to a Windows-style equivalent.

 T	Select Fractal Type
 S	Save Fractal Image *
 P	Print Fractal Image *
 R	Restore Fractal Image
 3	3D Restore
 O	3D Overlay
 X	Basic Options
 Y	Extended Doodads
 Z	Fractal Parameters
 I	3D Parameters
 A	Starfields
 @	Select Parameter file and item
 B	Save Parameter item
 L	Load Color-Map
 W	Write (save) Color-Map *
 DEL	Select Image Size *
 INS	Reset All Options
 TAB	Status display

In addition to the above, Winfract also responds to many of the Fractint-style color-cycling hot-keys:  'C', '+', '-', '<', '>', the four cursor keys, SPACE, and ENTER.  Unlike Fractint, you don't have to enter "color-cycling mode" to use these keys - Color-Cycling mode and the main image mode are one and the same.
 
Many of Fractint's prompting screens have also been incorporated into Winfract.  Note that some of these screens list options that aren't connected to anything in the Winfract environment (the sound options on the 'X' screen come to mind).  However, those of you who are used to Fractint's prompting screens may find this option more comfortable than the Windows menus.  Currently, these Fractint-style prompting screens are only selectable using the Hot-Keys (using the Windows menu-bars always gives you Windows-style entry screens), and then only if you have chosen "Fractint-style Prompts" as your "Hot-Key Options" default. 

#$+K 
Limitations in Winfract 

Fractint for Windows is (and will continue to be) a "port" of Fractint for DOS to the Windows environment, retaining the Fractint for DOS fractal and GIF engines, but replacing its front-end and graphics interface with a Windows engine.  As such, its fractal engine will always "trail" that of Fractint for DOS (although hopefully not by much - the two 17.1 versions were uploaded within hours of each other), and the user interface will tend to do the same except where the Windows version adds functionality simply by virtue of the Windows interface.

There are three main causes behind the various limitations of this program.  For future brevity, these causes are tagged FFD (problems related to the fact that much of the code is and will continue to be from Fractint For Dos), WLIM (limitations caused by Windows, or some Windows video/printer drivers that aren't limitations under MS-DOS), and NYI (Not Yet Implemented - hey, we're working on it!).  We used to hide behind a fourth excuse - calling ourselves novice Windows programmers and using the "what can you expect?" claim - but folks quit believing that one.  FFD and WLIM limitations are probably permanent - hopefully NYI problems are less so.

At any rate, the major limitations of Winfract continue to be:

- You can run only one "instance" of Fractint for Windows.  FFD: Fractint for DOS is riddled with initialized FAR data ("char far myvalue = 0;"), and the Windows SDK silently but firmly tags any program containing code like that as a single-instance program.

- Palette support is limited.   WLIM: The "stock" VGA driver supplied with Win 3.0 doesn't support palette-modification by applications at all (most third-party 256-color SuperVGA drivers do, though).  "Plasma Clouds" look Godawful using anything less than a 256-color Windows driver.  Color-cycling is limited to video drivers which support palette-manipulation (and, for 16-color drivers, color-cycling affects the background windows as well).  Note that 16-bit and 24-bit "true color" Windows video drivers don't *have* a palette to manipulate, so we can't color-cycle them.

- Fractint for Windows is not as "background process" friendly as it should be when it updates the screen image - if it is updating a large image in its entirety, it can grab the machine for seconds at a time.  FFD  and WLIM -  Windows only gives other programs a shot at the CPU when the currently active program volunteers to give up control, and the fractal engine that Winfract is based on only gives us the opportunity to do that when it calls the routine that checks the keyboard - an event that may happen only once a second or so. 

#$+K
File Menu 

File Open loads either Fractint-for-DOS-style or "generic" GIF files.  Note that the correct palette isn't completely displayed on the screen.  Windows "reserves" twenty palette values for its own use, and "adjusts" Fractint's images accordingly - and for 16-color drivers like the VGA driver supplied with Windows that don't support palette-manipulation by applications programs, cheerfully ignores our attempts at palette-manipulation.  If the restored image is resumable, the image will resume calculating as soon as it is loaded.

File Save saves your current image (by default, as a GIF (version 89a) file, compatible with Fractint-for-DOS, your favorite DOS GIF viewers, and (of course) the "File Open" option, but optionally as a BMP file).  Again, the palette you see on the screen may not be the one that the program is "using" (and gets saved to the disk file).  If the saved image is resumable, the image will resume calculating as soon as it is finished saving.  Note that Winfract can only open GIF89a-format images as fractal images, and cannot open BMP-format images at all.

File 3D Open and File 3D Overlay load in your image using "3D" transformations.   The 3D Open option clears your image first and then loads the new one, while the Overlay option leaves your original image intact and adds the new image over it.

File Print does the best job it can sending the image to your printer.  The program does not "dither" for black-and-white printers - it just "candy stripes" adjacent colors the same way that Fractint-for-DOS does.

Read Batchfile and Write Batchfile load and save "batch-file" parameters of your (and others) favorite images.  As soon as you Read a batchfile image (saved as an entry in a PAR file such as FRACTINT.PAR ), Winfract will begin generating that image at whatever image size you are currently using.  The disadvantage to saving your favorite images as PARameter files rather than GIF images is that Winfract has to recreate each image every time you select it.  The advantage is that you can fit a lot more formulas on your hard disk this way, and they're a tad easier to E-mail to your friends!

File Copy to Clipboard copies the currently-displayed image to the Windows clipboard (in "Device-Independent Bitmap" format) where your other Windows programs can collect it.  Note that, for 256-color video drivers and 256-color images, the colors in the clipboard won't visibly match the colors in Winfract's window until you change your "focus" to the clipboard's window.  That's because Winfract has warned the Clipboard that it is reserving the right to color-cycle its colors, so the Clipboard is just using Windows' default 20 colors to display its colors while Winfract has control of the screen.

GIF and "Graphics Interchange Format" are trademarks of CompuServe Incorporated, an H&R Block Company. 

#$+K 
Fractals Options

Fractal Formula brings up a dialog box letting you select from any of approximately 80 fractal types.  See the Fractal Formula Selection for formula details.

Fractal Params brings up a "Fractal Parameters" menu that lets you select any modifiable parameters in your fractal type as well as the specific area you may want to zoom in on.

Basic Options  brings up a "Basic Options" menu that lets you select any of what we consider the "basic" (mostly because we added them first) fractal options - various generation algorithms (single/dual pass, solid-guessing, boundary tracing, tesseral),  inside and outside coloring schemes, maximum iterations,  Biomorph and Decomposition options, etc .

Extended Options brings up an "Extended Options" menu that lets you select any of what we consider to be "extended" (because we didn't think of them until later) fractal options, including Inversion and Continuous Potential.

3D Params brings up a "3D Parameters" menu that lets you select any modifiable 3D parameters in your fractal type.

Reset all Options resets all fractal-related options to the default state they were in when Winfract was first started.

Once you have selected any of these options, Winfract will clear the image and regenerate it using the new options you have given it.

#$+K 
View Options

Image Settings The Image Settings option lets you select either a pre-defined image size, or make up your own (up to an internal limit of 2048x2048) and select a two-color, 16-color, or 256-color image.  Those of you with 24-bit color video cards will have to hold yourself back to 256-color images for the moment - the 256-color limit is one of the penalties of using the fractal engine from Fractint. 

If your image size is larger than your window, you can use the scroll bars in the window to scroll around your image. 

If you have selected the "Window Sizing" option (see below), your image window will automatically re-size to the image size you have just selected.

Zoom In, Zoom Out, and Zoom Bar toggles select which of three zooming options you want to use.  For details, see the help section on Zooming in on an Image.

Coordinate Box toggles the display of an optional "Coordinate Box" displaying information about the pixel directly underneath your mouse pointer.  See the help section under Coordinate Box for details.

Window Sizing toggles the "Window Sizing" option, in which the scroll-bars are eliminated and the image window is automatically sized to the size of your fractal image.

Pixel-By-Pixel Update toggles the "Pixel-By-Pixel Update" option, in which Winfract's normal method of updating its image in periodic chunks is changed to a "display every pixel as it is changed" strategy.  This approach is extremely slow (Windows' overhead takes a heavy toll on programs that update their images this way), but it lets you see how Winfract is actually generating its images - try this using the Boundary Trace and Tesseral image-generation methods.

HotKey Actions toggles whether the various "hot-keys" Winfract is sensitive to take you to the same Windows-style menus accessed through the Windows menubar or to "Fractint-style" prompting screens.  See the help section on Fractint-Style Help and Prompts for details.
 
Status Brings up a Status messagebox displaying the status of your current image (which formula you are using, its parameters and screen corners, and whether or not it's still being generated or has finished).  If the image is still being generated, Winfract continues with it when you press the "OK" button. 

#$+K 
Color Options

Load Color-Map and Write Color-Map load and save external color-maps in the same manner as Fractint-for-DOS (within Windows' limitations).

Color-Cycling brings up a Color_Cycling Dialog box.  See the Help section on Color_Cycling for details.

#$+K 
Help Options

Index brings up this help system.  So does pressing the F1 key.

Using Help brings up the standard Windows "help on Help" system.

Fractint Help brings up Fractint-style help screens (all 350+ of them!)  So does pressing the Control-F1 key.  See the Help section on Fractint-Style Help and Prompts for details.

About Winfract brings up a standard "About Box".

#$+K
Fractal Formula Selection 

Using the Options Formula option, you can select any of over 90 fractal types (virtually every fractal type that is available in version 20.4 of Fractint-for-DOS).   After selecting a fractal type, a dialogue box pops up and prompts you for any formula parameters and the screen corners (all with reasonable default values).

All fractal types from Fractint 20.4 (with the exception of the 'julia_inverse' fractal type, which requires some extra logic we haven't yet added to Winfract) have been incorporated into this version of Winfract.

The list of Fractal types and their formulas include:

ant
    Generalized Ant Automaton as described in the July 1994 Scientific
    American. Some ants wander around the screen. A rule string (the first
    parameter) determines the ant's direction. When the type 1 ant leaves a
    cell of color k, it turns right if the kth symbol in the first parameter
    is a 1, or left otherwise. Then the color in the old cell is incremented.
    The 2nd parameter is a maximum iteration to guarantee that the fractal
    will terminate. The 3rd parameter is the number of ants. The 4th is the
    ant type 1 or 2. The 5th parameter determines if the ants wrap the screen
    or stop at the edge.  The 6th parameter is a random seed. You can slow
    down the ants to see them better using the <p> screen Orbit Delay.

barnsleyj1
      z(0) = pixel;
      if real(z) >= 0
        z(n+1) = (z-1)*c
      else
         z(n+1) = (z+1)*c
    Two parameters: real and imaginary parts of c

barnsleyj2
      z(0) = pixel;
      if real(z(n)) * imag(c) + real(c) * imag(z((n)) >= 0
         z(n+1) = (z(n)-1)*c
      else
         z(n+1) = (z(n)+1)*c
    Two parameters: real and imaginary parts of c

barnsleyj3
      z(0) = pixel;
      if real(z(n) > 0 then z(n+1) = (real(z(n))^2 - imag(z(n))^2 - 1)
         + i * (2*real(z((n)) * imag(z((n))) else
      z(n+1) = (real(z(n))^2 - imag(z(n))^2 - 1 + real(c) * real(z(n))
             + i * (2*real(z((n)) * imag(z((n)) + imag(c) * real(z(n))
    Two parameters: real and imaginary parts of c.

barnsleym1
      z(0) = c = pixel;
      if real(z) >= 0 then
        z(n+1) = (z-1)*c
      else z(n+1) = (z+1)*c.
    Parameters are perturbations of z(0)

barnsleym2
      z(0) = c = pixel;
      if real(z)*imag(c) + real(c)*imag(z) >= 0
        z(n+1) = (z-1)*c
      else
        z(n+1) = (z+1)*c
    Parameters are perturbations of z(0)

barnsleym3
      z(0) = c = pixel;
      if real(z(n) > 0 then z(n+1) = (real(z(n))^2 - imag(z(n))^2 - 1)
         + i * (2*real(z((n)) * imag(z((n))) else
      z(n+1) = (real(z(n))^2 - imag(z(n))^2 - 1 + real(c) * real(z(n))
         + i * (2*real(z((n)) * imag(z((n)) + imag(c) * real(z(n))
    Parameters are perturbations of z(0)

bifurcation
    Pictorial representation of a population growth model.
      Let P = new population, p = oldpopulation, r = growth rate
      The model is: P = p + r*fn(p)*(1-fn(p)).
    Three parameters: Filter Cycles, Seed Population, and Function.

bif+sinpi
    Bifurcation variation: model is: P = p + r*fn(PI*p).
    Three parameters: Filter Cycles, Seed Population, and Function.

bif=sinpi
    Bifurcation variation: model is: P = r*fn(PI*p).
    Three parameters: Filter Cycles, Seed Population, and Function.

biflambda
    Bifurcation variation: model is: P = r*fn(p)*(1-fn(p)).
    Three parameters: Filter Cycles, Seed Population, and Function.

bifstewart
    Bifurcation variation: model is: P = (r*fn(p)*fn(p)) - 1.
    Three parameters: Filter Cycles, Seed Population, and Function.

bifmay
    Bifurcation variation: model is: P = r*p / ((1+p)^beta).
    Three parameters: Filter Cycles, Seed Population, and Beta.

cellular
    One-dimensional cellular automata or line automata.  The type of CA
    is given by kr, where k is the number of different states of the
    automata and r is the radius of the neighborhood.  The next generation
    is determined by the sum of the neighborhood and the specified rule.
    Four parameters: Initial String, Rule, Type, and Starting Row Number.
    For Type = 21, 31, 41, 51, 61, 22, 32, 42, 23, 33, 24, 25, 26, 27
        Rule =  4,  7, 10, 13, 16,  6, 11, 16,  8, 15, 10, 12, 14, 16 digits

chip
    Chip attractor from Michael Peters - orbit in two dimensions.
      z(0) = y(0) = 0;
      x(n+1) = y(n) - sign(x(n)) * cos(sqr(ln(abs(b*x(n)-c))))
                                 * arctan(sqr(ln(abs(c*x(n)-b))))
      y(n+1) = a - x(n)
    Parameters are a, b, and c.

Circle
    Circle pattern by John Connett
      x + iy = pixel
      z = a*(x^2 + y^2)
      c = integer part of z
      color = c modulo(number of colors)

cmplxmarksjul
    A generalization of the marksjulia fractal.
      z(0) = pixel;
      z(n+1) = c^(exp-1)*z(n)^2 + c.
    Four parameters: real and imaginary parts of c,
    and real and imaginary parts of exponent.

cmplxmarksmand
    A generalization of the marksmandel fractal.
      z(0) = c = pixel;
      z(n+1) = c^(exp-1)*z(n)^2 + c.
    Four parameters: real and imaginary parts of perturbation
    of z(0), and real and imaginary parts of exponent.

complexnewton, complexbasin
    Newton fractal types extended to complex degrees. Complexnewton
    colors pixels according to the number of iterations required to
    escape to a root. Complexbasin colors pixels according to which
    root captures the orbit. The equation is based on the newton
    formula for solving the equation z^p = r
      z(0) = pixel;
      z(n+1) = ((p - 1) * z(n)^p + r)/(p * z(n)^(p - 1)).
    Four parameters: real & imaginary parts of degree p and root r.

diffusion
    Diffusion Limited Aggregation.  Randomly moving points
    accumulate.  Three parameters: border width (default 10), type,
    and color change rate.

dynamic
    Time-discrete dynamic system.
      x(0) = y(0) = start position.
      y(n+1) = y(n) + f( x(n) )
      x(n+1) = x(n) - f( y(n) )
      f(k) = sin(k + a*fn1(b*k))
    For implicit Euler approximation: x(n+1) = x(n) - f( y(n+1) )
    Five parameters: start position step, dt, a, b, and the function fn1.

escher_julia
    Escher-like tiling of Julia sets from The Science of Fractal Images
      z(0) = pixel
      z(n+1) = z(n)^2 + (0, 0i)
    The target set is a second, scaled, Julia set:
      T = [ z: | (z * 15.0)^2 + c | < BAILOUT ]
    Two parameters: real and imaginary parts of c
    Iteration count and bailout size apply to both Julia sets.

fn+fn(pix)
      c = z(0) = pixel;
      z(n+1) = fn1(z) + p*fn2(c)
    Six parameters: real and imaginary parts of the perturbation
    of z(0) and factor p, and the functions fn1, and fn2.

fn(z*z)
      z(0) = pixel;
      z(n+1) = fn(z(n)*z(n))
    One parameter: the function fn.

fn*fn
      z(0) = pixel; z(n+1) = fn1(n)*fn2(n)
    Two parameters: the functions fn1 and fn2.

fn*z+z
      z(0) = pixel; z(n+1) = p1*fn(z(n))*z(n) + p2*z(n)
    Five parameters: the real and imaginary components of
    p1 and p2, and the function fn.

fn+fn
      z(0) = pixel;
      z(n+1) = p1*fn1(z(n))+p2*fn2(z(n))
    Six parameters: The real and imaginary components of
    p1 and p2, and the functions fn1 and fn2.

formula
    Formula interpreter - write your own formulas as text files!

frothybasin
    Pixel color is determined by which attractor captures the orbit.  The
    shade of color is determined by the number of iterations required to
    capture the orbit.
      Z(0) = pixel;  Z(n+1) = Z(n)^2 - C*conj(Z(n))
      where C = 1 + A*i, critical value of A = 1.028713768218725...

gingerbread
    Orbit in two dimensions defined by:
      x(n+1) = 1 - y(n) + |x(n)|
      y(n+1) = x(n)
    Two parameters: initial values of x(0) and y(0).

halley
      Halley map for the function: F = z(z^a - 1) = 0
      z(0) = pixel;
      z(n+1) = z(n) - R * F / [F' - (F" * F / 2 * F')]
      bailout when: abs(mod(z(n+1)) - mod(z(n)) < epsilon
    Four parameters: order a, real part of R, epsilon,
       and imaginary part of R.

henon
    Orbit in two dimensions defined by:
      x(n+1) = 1 + y(n) - a*x(n)*x(n)
      y(n+1) = b*x(n)
    Two parameters: a and b

Hopalong
    Hopalong attractor by Barry Martin - orbit in two dimensions.
      z(0) = y(0) = 0;
      x(n+1) = y(n) - sign(x(n))*sqrt(abs(b*x(n)-c))
      y(n+1) = a - x(n)
    Parameters are a, b, and c.

hypercomplex
    HyperComplex Mandelbrot set.
      h(0)   = (0,0,0,0)
      h(n+1) = fn(h(n)) + C.
      where "fn" is sin, cos, log, sqr etc.
    Two parameters: cj, ck
    C = (xpixel,ypixel,cj,ck)

hypercomplexj
    HyperComplex Julia set.
      h(0)   = (xpixel,ypixel,zj,zk)
      h(n+1) = fn(h(n)) + C.
      where "fn" is sin, cos, log, sqr etc.
    Six parameters: c1, ci, cj, ck
    C = (c1,ci,cj,ck)

icon, icon3d
    Orbit in three dimensions defined by:
      p = lambda + alpha * magnitude + beta * (x(n)*zreal - y(n)*zimag)
      x(n+1) = p * x(n) + gamma * zreal - omega * y(n)
      y(n+1) = p * y(n) - gamma * zimag + omega * x(n)
      (3D version uses magnitude for z)
      Parameters:  Lambda, Alpha, Beta, Gamma, Omega, and Degree

IFS
    Barnsley IFS (Iterated Function System) fractals. Apply
    contractive affine mappings.

julfn+exp
    A generalized Clifford Pickover fractal.
      z(0) = pixel;
      z(n+1) = fn(z(n)) + e^z(n) + c.
    Three parameters: real & imaginary parts of c, and fn

julfn+zsqrd
      z(0) = pixel;
      z(n+1) = fn(z(n)) + z(n)^2 + c
    Three parameters: real & imaginary parts of c, and fn

julia
    Classic Julia set fractal.
      z(0) = pixel; z(n+1) = z(n)^2 + c.
    Two parameters: real and imaginary parts of c.

julia(fn||fn)
      z(0) = pixel;
      if modulus(z(n)) < shift value, then
         z(n+1) = fn1(z(n)) + c,
      else
         z(n+1) = fn2(z(n)) + c.
    Five parameters: real, imag portions of c, shift value, fn1, fn2.

julia4
    Fourth-power Julia set fractals, a special case
    of julzpower kept for speed.
      z(0) = pixel;
      z(n+1) = z(n)^4 + c.
    Two parameters: real and imaginary parts of c.

julibrot
    'Julibrot' 4-dimensional fractals.

julzpower
      z(0) = pixel;
      z(n+1) = z(n)^m + c.
    Three parameters: real & imaginary parts of c, exponent m

julzzpwr
      z(0) = pixel;
      z(n+1) = z(n)^z(n) + z(n)^m + c.
    Three parameters: real & imaginary parts of c, exponent m

kamtorus, kamtorus3d
    Series of orbits superimposed.
    3d version has 'orbit' the z dimension.
      x(0) = y(0) = orbit/3;
      x(n+1) = x(n)*cos(a) + (x(n)*x(n)-y(n))*sin(a)
      y(n+1) = x(n)*sin(a) - (x(n)*x(n)-y(n))*cos(a)
    After each orbit, 'orbit' is incremented by a step size.
    Parameters: a, step size, stop value for 'orbit', and
    points per orbit.

lambda
    Classic Lambda fractal. 'Julia' variant of Mandellambda.
      z(0) = pixel;
      z(n+1) = lambda*z(n)*(1 - z(n)).
    Two parameters: real and imaginary parts of lambda.

lambdafn
      z(0) = pixel;
      z(n+1) = lambda * fn(z(n)).
    Three parameters: real, imag portions of lambda, and fn

lambda(fn||fn)
      z(0) = pixel;
      if modulus(z(n)) < shift value, then
         z(n+1) = lambda * fn1(z(n)),
      else
         z(n+1) = lambda * fn2(z(n)).
    Five parameters: real, imag portions of lambda, shift value, fn1, fn2

latoocarfian
       Orbit in two dimensions defined by:
       x(n+1) = fn1 (y(n) * b) + c * fn2(x(n) * b)
       y(n+1) = fn3 (x(n) * a) + d * fn4(y(n) * a)
       Parameters:  a, b, c, d fn1..4 (all sin=original)

lorenz, lorenz3d
    Lorenz two lobe attractor - orbit in three dimensions.
    In 2d the x and y components are projected to form the image.
      z(0) = y(0) = z(0) = 1;
      x(n+1) = x(n) + (-a*x(n)*dt) + (   a*y(n)*dt)
      y(n+1) = y(n) + ( b*x(n)*dt) - (     y(n)*dt) - (z(n)*x(n)*dt)
      z(n+1) = z(n) + (-c*z(n)*dt) + (x(n)*y(n)*dt)
    Parameters are dt, a, b, and c.

lorenz3d1
    Lorenz one lobe attractor, 3D orbit (Rick Miranda and Emily Stone)
      z(0) = y(0) = z(0) = 1; norm = sqrt(x(n)^2 + y(n)^2)
      x(n+1) = x(n) + (-a*dt-dt)*x(n) + (a*dt-b*dt)*y(n)
         + (dt-a*dt)*norm + y(n)*dt*z(n)
      y(n+1) = y(n) + (b*dt-a*dt)*x(n) - (a*dt+dt)*y(n)
         + (b*dt+a*dt)*norm - x(n)*dt*z(n) - norm*z(n)*dt
      z(n+1) = z(n) +(y(n)*dt/2) - c*dt*z(n)
    Parameters are dt, a, b, and c.

lorenz3d3
    Lorenz three lobe attractor, 3D orbit (Rick Miranda and Emily Stone)
      z(0) = y(0) = z(0) = 1; norm = sqrt(x(n)^2 + y(n)^2)
      x(n+1) = x(n) +(-(a*dt+dt)*x(n) + (a*dt-b*dt+z(n)*dt)*y(n))/3
          + ((dt-a*dt)*(x(n)^2-y(n)^2)
          + 2*(b*dt+a*dt-z(n)*dt)*x(n)*y(n))/(3*norm)
      y(n+1) = y(n) +((b*dt-a*dt-z(n)*dt)*x(n) - (a*dt+dt)*y(n))/3
          + (2*(a*dt-dt)*x(n)*y(n)
          + (b*dt+a*dt-z(n)*dt)*(x(n)^2-y(n)^2))/(3*norm)
      z(n+1) = z(n) +(3*x(n)*dt*x(n)*y(n)-y(n)*dt*y(n)^2)/2 - c*dt*z(n)
    Parameters are dt, a, b, and c.

lorenz3d4
    Lorenz four lobe attractor, 3D orbit (Rick Miranda and Emily Stone)
      z(0) = y(0) = z(0) = 1;
      x(n+1) = x(n) +(-a*dt*x(n)^3
         + (2*a*dt+b*dt-z(n)*dt)*x(n)^2*y(n) + (a*dt-2*dt)*x(n)*y(n)^2
         + (z(n)*dt-b*dt)*y(n)^3) / (2 * (x(n)^2+y(n)^2))
      y(n+1) = y(n) +((b*dt-z(n)*dt)*x(n)^3 + (a*dt-2*dt)*x(n)^2*y(n)
         + (-2*a*dt-b*dt+z(n)*dt)*x(n)*y(n)^2
         - a*dt*y(n)^3) / (2 * (x(n)^2+y(n)^2))
      z(n+1) = z(n) +(2*x(n)*dt*x(n)^2*y(n) - 2*x(n)*dt*y(n)^3 - c*dt*z(n))
    Parameters are dt, a, b, and c.

lsystem
    Using a turtle-graphics control language and starting with
    an initial axiom string, carries out string substitutions the
    specified number of times (the order), and plots the result.

lyapunov
    Derived from the Bifurcation fractal, the Lyapunov plots the Lyapunov
    Exponent for a population model where the Growth parameter varies between
    two values in a periodic manner.

magnet1j
      z(0) = pixel;
                [  z(n)^2 + (c-1)  ] 2
      z(n+1) =  | ---------------- |
                [  2*z(n) + (c-2)  ]
    Parameters: the real and imaginary parts of c

magnet1m
      z(0) = 0; c = pixel;
                [  z(n)^2 + (c-1)  ] 2
      z(n+1) =  | ---------------- |
                [  2*z(n) + (c-2)  ]
    Parameters: the real & imaginary parts of perturbation of z(0)

magnet2j
      z(0) = pixel;
                [  z(n)^3 + 3*(C-1)*z(n) + (C-1)*(C-2)         ] 2
      z(n+1) =  | -------------------------------------------- |
                [  3*(z(n)^2) + 3*(C-2)*z(n) + (C-1)*(C-2) + 1 ]
    Parameters: the real and imaginary parts of c

magnet2m
      z(0) = 0; c = pixel;
                [  z(n)^3 + 3*(C-1)*z(n) + (C-1)*(C-2)         ] 2
      z(n+1) =  | -------------------------------------------- |
                [  3*(z(n)^2) + 3*(C-2)*z(n) + (C-1)*(C-2) + 1 ]
    Parameters: the real and imaginary parts of perturbation of z(0)

mandel
    Classic Mandelbrot set fractal.
      z(0) = c = pixel;
      z(n+1) = z(n)^2 + c.
    Two parameters: real & imaginary perturbations of z(0)

mandel(fn||fn)
      c = pixel;
      z(0) = p1
      if modulus(z(n)) < shift value, then
         z(n+1) = fn1(z(n)) + c,
      else
         z(n+1) = fn2(z(n)) + c.
    Five parameters: real, imaginary portions of p1, shift value,
                     fn1 and fn2.

mandelbrotmix4
    From a Jim Muth favorite FOTD formula
      a=real(p1), b=imag(p1), d=real(p2), f=imag(p2),
      g=1/f, h=1/d, j=1/(f-b), z=(-a*b*g*h)^j,
      k=real(p3)+1, l=imag(p3)+100, c=fn1(pixel):
      z=k*((a*(z^b))+(d*(z^f)))+c
    Parameters: see above, sixth parameter used for bailout

mandelcloud
    Displays orbits of Mandelbrot set:
      z(0) = c = pixel;
      z(n+1) = z(n)^2 + c.
    One parameter: number of intervals

mandel4
    Special case of mandelzpower kept for speed.
      z(0) = c = pixel;
      z(n+1) = z(n)^4 + c.
    Parameters: real & imaginary perturbations of z(0)

mandelfn
      z(0) = c = pixel;
      z(n+1) = c*fn(z(n)).
    Parameters: real & imaginary perturbations of z(0), and fn

manlam(fn||fn)
      c = pixel;
      z(0) = p1
      if modulus(z(n)) < shift value, then
         z(n+1) = fn1(z(n)) * c, else
         z(n+1) = fn2(z(n)) * c.
    Five parameters: real, imaginary parts of p1, shift value, fn1, fn2.

Martin
    Attractor fractal by Barry Martin - orbit in two dimensions.
      z(0) = y(0) = 0;
      x(n+1) = y(n) - sin(x(n))
      y(n+1) = a - x(n)
    Parameter is a (try a value near pi)

mandellambda
      z(0) = .5; lambda = pixel;
      z(n+1) = lambda*z(n)*(1 - z(n)).
    Parameters: real & imaginary perturbations of z(0)

mandphoenix
    z(0) = c = pixel, y(0) = 0;
    For degree = 0:
      z(n+1) = z(n)^2 + c.x + c.y*y(n), y(n+1) = z(n)
    For degree >= 2:
      z(n+1) = z(n)^degree + c.x*z(n)^(degree-1) + c.y*y(n)
      y(n+1) = z(n)
    For degree <= -3:
      z(n+1) = z(n)^|degree| + c.x*z(n)^(|degree|-2) + c.y*y(n)
      y(n+1) = z(n)
    Three parameters: real & imaginary perturbations of z(0), and degree.

mandphoenixclx
    z(0) = c = pixel, y(0) = 0;
    For degree = 0:
      z(n+1) = z(n)^2 + c + p2*y(n), y(n+1) = z(n)
    For degree >= 2:
      z(n+1) = z(n)^degree + c*z(n)^(degree-1) + p2*y(n), y(n+1) = z(n)
    For degree <= -3:
      z(n+1) = z(n)^|degree| + c*z(n)^(|degree|-2) + p2*y(n), y(n+1) = z(n)
    Five parameters: real & imaginary perturbations of z(0), real &
      imaginary parts of p2, and degree.

manfn+exp
    'Mandelbrot-Equivalent' for the julfn+exp fractal.
      z(0) = c = pixel;
      z(n+1) = fn(z(n)) + e^z(n) + C.
    Parameters: real & imaginary perturbations of z(0), and fn

manfn+zsqrd
    'Mandelbrot-Equivalent' for the Julfn+zsqrd fractal.
      z(0) = c = pixel;
      z(n+1) = fn(z(n)) + z(n)^2 + c.
    Parameters: real & imaginary perturbations of z(0), and fn

manowar
      c = z1(0) = z(0) = pixel;
      z(n+1) = z(n)^2 + z1(n) + c;
      z1(n+1) = z(n);
    Parameters: real & imaginary perturbations of z(0)

manowarj
      z1(0) = z(0) = pixel;
      z(n+1) = z(n)^2 + z1(n) + c;
      z1(n+1) = z(n);
    Parameters: real & imaginary parts of c

manzpower
    'Mandelbrot-Equivalent' for julzpower.
      z(0) = c = pixel;
      z(n+1) = z(n)^exp + c; try exp = e = 2.71828...
    Parameters: real & imaginary perturbations of z(0), real &
    imaginary parts of exponent exp.

manzzpwr
    'Mandelbrot-Equivalent' for the julzzpwr fractal.
      z(0) = c = pixel
      z(n+1) = z(n)^z(n) + z(n)^exp + C.
    Parameters: real & imaginary perturbations of z(0), and exponent

marksjulia
    A variant of the julia-lambda fractal.
      z(0) = pixel;
      z(n+1) = c^(exp-1)*z(n)^2 + c.
    Parameters: real & imaginary parts of c, and exponent

marksmandel
    A variant of the mandel-lambda fractal.
      z(0) = c = pixel;
      z(n+1) = c^(exp-1)*z(n)^2 + c.
    Parameters: real & imaginary parts of perturbations of z(0),
    and exponent

marksmandelpwr
    The marksmandelpwr formula type generalized (it previously
    had fn=sqr hard coded).
      z(0) = pixel, c = z(0) ^ (z(0) - 1):
      z(n+1) = c * fn(z(n)) + pixel,
    Parameters: real and imaginary perturbations of z(0), and fn

newtbasin
    Based on the Newton formula for finding the roots of z^p - 1.
    Pixels are colored according to which root captures the orbit.
      z(0) = pixel;
      z(n+1) = ((p-1)*z(n)^p + 1)/(p*z(n)^(p - 1)).
    Two parameters: the polynomial degree p, and a flag to turn
    on color stripes to show alternate iterations.

newton
    Based on the Newton formula for finding the roots of z^p - 1.
    Pixels are colored according to the iteration when the orbit
    is captured by a root.
      z(0) = pixel;
      z(n+1) = ((p-1)*z(n)^p + 1)/(p*z(n)^(p - 1)).
    One parameter: the polynomial degree p.

phoenix
    z(0) = pixel, y(0) = 0;
    For degree = 0: z(n+1) = z(n)^2 + p1.x + p2.x*y(n), y(n+1) = z(n)
    For degree >= 2:
     z(n+1) = z(n)^degree + p1.x*z(n)^(degree-1) + p2.x*y(n), y(n+1) = z(n)
    For degree <= -3:
     z(n+1) = z(n)^|degree| + p1.x*z(n)^(|degree|-2)
            + p2.x*y(n), y(n+1) = z(n)
    Three parameters: real parts of p1 & p2, and degree.

phoenixcplx
    z(0) = pixel, y(0) = 0;
    For degree = 0: z(n+1) = z(n)^2 + p1 + p2*y(n), y(n+1) = z(n)
    For degree >= 2:
      z(n+1) = z(n)^degree + p1*z(n)^(degree-1) + p2*y(n), y(n+1) = z(n)
    For degree <= -3:
      z(n+1) = z(n)^|degree| + p1*z(n)^(|degree|-2) + p2*y(n), y(n+1) = z(n)
    Five parameters: real & imaginary parts of p1 & p2, and degree.

pickover
    Orbit in three dimensions defined by:
      x(n+1) = sin(a*y(n)) - z(n)*cos(b*x(n))
      y(n+1) = z(n)*sin(c*x(n)) - cos(d*y(n))
      z(n+1) = sin(x(n))
    Parameters: a, b, c, and d.

plasma
    Random, cloud-like formations.  Requires 4 or more colors.
    A recursive algorithm repeatedly subdivides the screen and
    colors pixels according to an average of surrounding pixels
    and a random color, less random as the grid size decreases.
    Four parameters: 'graininess' (0, 0.125 to 100, default = 2),
    old/new algorithm, seed value used, 16-bit out output selection.

popcorn
    The orbits in 2D are plotted superimposed:
      x(0) = xpixel, y(0) = ypixel;
      x(n+1) = x(n) - real(h * fn1( y(n) + fn2(C * y(n) ))
                    - imag(h * fn3( x(n) + fn4(C * x(n) ))
      y(n+1) = y(n) - real(h * fn3( x(n) + fn4(C * x(n) ))
                    - imag(h * fn1( y(n) + fn2(C * y(n) ))
    Parameters: step size h, C, functions fn1..4 (original: sin,tan,sin,tan).

popcornjul
    Julia using the generalized Pickover Popcorn formula:
      x(0) = xpixel, y(0) = ypixel;
      x(n+1) = x(n) - real(h * fn1( y(n) + fn2(C * y(n) ))
                    - imag(h * fn3( x(n) + fn4(C * x(n) ))
      y(n+1) = y(n) - real(h * fn3( x(n) + fn4(C * x(n) ))
                    - imag(h * fn1( y(n) + fn2(C * y(n) ))
    Parameters: step size h, C, functions fn1..4 (original: sin,tan,sin,tan).

quadruptwo
    Quadruptwo attractor from Michael Peters - orbit in two dimensions.
      z(0) = y(0) = 0;
      x(n+1) = y(n) - sign(x(n)) * sin(ln(abs(b*x(n)-c)))
                                 * arctan(sqr(ln(abs(c*x(n)-b))))
      y(n+1) = a - x(n)
    Parameters are a, b, and c.

quatjul
    Quaternion Julia set.
      q(0)   = (xpixel,ypixel,zj,zk)
      q(n+1) = q(n)*q(n) + c.
    Four parameters: c, ci, cj, ck
    c = (c1,ci,cj,ck)

quat
    Quaternion Mandelbrot set.
      q(0)   = (0,0,0,0)
      q(n+1) = q(n)*q(n) + c.
    Two parameters: cj,ck
    c = (xpixel,ypixel,cj,ck)

rossler3D
    Orbit in three dimensions defined by:
      x(0) = y(0) = z(0) = 1;
      x(n+1) = x(n) - y(n)*dt -   z(n)*dt
      y(n+1) = y(n) + x(n)*dt + a*y(n)*dt
      z(n+1) = z(n) + b*dt + x(n)*z(n)*dt - c*z(n)*dt
    Parameters are dt, a, b, and c.

sierpinski
    Sierpinski gasket - Julia set producing a 'Swiss cheese triangle'
      z(n+1) = (2*x,2*y-1) if y > .5;
          else (2*x-1,2*y) if x > .5;
          else (2*x,2*y)
    No parameters.

spider
      c(0) = z(0) = pixel;
      z(n+1) = z(n)^2 + c(n);
      c(n+1) = c(n)/2 + z(n+1)
    Parameters: real & imaginary perturbation of z(0)

sqr(1/fn)
      z(0) = pixel;
      z(n+1) = (1/fn(z(n))^2
    One parameter: the function fn.

sqr(fn)
      z(0) = pixel;
      z(n+1) = fn(z(n))^2
    One parameter: the function fn.

test
    'test' point letting us (and you!) easily add fractal types via
    the c module testpt.c.  Default set up is a mandelbrot fractal.
    Four parameters: user hooks (not used by default testpt.c).

tetrate
      z(0) = c = pixel;
      z(n+1) = c^z(n)
    Parameters: real & imaginary perturbation of z(0)

threeply
    Threeply attractor by Michael Peters - orbit in two dimensions.
      z(0) = y(0) = 0;
      x(n+1) = y(n) - sign(x(n)) * (abs(sin(x(n))*cos(b)
                                    +c-x(n)*sin(a+b+c)))
      y(n+1) = a - x(n)
    Parameters are a, b, and c.

tim's_error
    A serendipitous coding error in marksmandelpwr brings to life
    an ancient pterodactyl!  (Try setting fn to sqr.)
      z(0) = pixel, c = z(0) ^ (z(0) - 1):
      tmp = fn(z(n))
      real(tmp) = real(tmp) * real(c) - imag(tmp) * imag(c);
      imag(tmp) = real(tmp) * imag(c) - imag(tmp) * real(c);
      z(n+1) = tmp + pixel;
    Parameters: real & imaginary perturbations of z(0) and function fn

unity
      z(0) = pixel;
      x = real(z(n)), y = imag(z(n))
      One = x^2 + y^2;
      y = (2 - One) * x;
      x = (2 - One) * y;
      z(n+1) = x + i*y
    No parameters.

volterra-lotka
    Volterra-Lotka fractal from The Beauty of Fractals
      x(0) = xpixel, y(0) = ypixel;
      dx/dt =  x - xy = f(x,y)
      dy/dt = -y + xy = g(x,y)
      x(new) = x + h/2 * [ f(x,y) + f[x + pf(x,y), y + pg(x,y)] ]
      y(new) = y + h/2 * [ g(x,y) + g[x + pf(x,y), y + pg(x,y)] ]
    Two parameters: h and p
    Recommended: zmag or bof60 inside coloring options

#$+K
Zooming in on an Image

There are two different methods of generating and using "Zoom-Boxes".  Which method you use depends on which of the "Zoom Box" checkboxes you have selected using the "Views" menuitem.  If you've never selected any of these checkboxes, the "Zoom In" option is in effect.

If you have the "Zoom In Box" or "Zoom Out Box" options enabled, Winfract's zoom box is activated in the following fashion:

With the "Zoom In Box" option activated, move your mouse pointer to the center of the area you wish to zoom in on.  Press and hold down the left mouse button as you move the mouse away from that center point.  A "Zoom Box" will be displayed, changing in size as you move the mouse.  When you have the zoom box the size you want, let go of the left mouse button.
If you want to adjust the location of the zoom box at this point, move your mouse pointer inside the zoom box, press and hold down the left mouse button again, and move the mouse.  The zoom box follows the mouse pointer until you let go of the left mouse button.
To activate the zoom, double-click the left mouse button with the mouse pointer inside the zoom box.  To disable the zoom box instead (say, you changed your mind, or the box isn't really the right size), double-click on the left mouse button with the mouse pointer positioned somewhere outside of the zoom box (pressing the ESCAPE key gets rid of the zoom box, too).

"Zoom Out" works just like "Zoom In", except that you will be zooming out - the zoom box is actually showing you where on the new image your current image will display.

If you have enabled the "Zoom-Bar" option, a vertical Zoom-Bar scroll-bar is displayed in addition to your fractal image.  The Zoom-Bar defaults to the mid-position, in which your zoom box exactly covers the area of your fractal image.  Moving the scroll-button up shrinks your zoom box (and makes it visible on the fractal image).  You can them move the zoom box around by moving your cursor inside the zoom box and then holding down your left mouse-button and moving the cursor and zoom box as a single unit.  Double-clicking the left mouse button will cause your image to be redrawn using your current zoom box coordinates.

You can also "Zoom Out" by moving the Zoom-Bar scroll-bar below the midpoint.  When you do this, the zoom box that is displayed is actually showing you where (and how small) your currently displayed image would be if you double-clicked the left mouse button at that point.  Moving the zoom box and double-clicking to perform the zoom is done the same way as when you are "zooming in".

#$+K 
Mandelbrot/Julia Toggling

You can switch from a "Mandelbrot Set" image to its "Julia Set" at the location of the mouse cursor by clicking on the right mouse button.  When the corresponding "Julia Set" image is on the screen, click the right mouse button again to get the "Mandelbrot Set" image back.  The terms "Mandelbrot Set" and "Julia Set" are in quotes because many fractal types (mandel4 and julia4, for instance) have this "Mandelbrot Set"/"Julia Set" relationship.   

#$+K
Color Cycling 

You start and stop Color-cycling mode using the Color-Cycling menu.  This menu also lets you determine the direction of the cycling (the designations "in" and "out" were arbitrarily picked based on how the effect looked on a single Mandelbrot image), whether to just rotate the existing colors or generate new ones randomly, and (for random color-generation) whether the colors are to change with a low, medium, or high frequency. 

You can also use the following "Hot-keys" for color-cycling 
  spacebar - toggles color-cycling on and off 
  '<', '>' - shifts the palette "in" or "out" one color
  left, right arrows - turn on color-cycling and set the "direction" 
  up, down arrows - speed up or slow down the color-cycling speed
  ENTER - initiate random color-cycling with all new colors 
  (Note that Windows takes a second or so to "fire up" color-cycling,   so be patient when you press one of these keys.) 

Sorry, but at the current time color-cycling is restricted to display devices whose Windows drivers are capable of palette manipulation - and the "stock" VGA driver distributed with Win 3.x doesn't have it!  In fact, at the moment the only Windows video drivers we've ever seen capable of palette manipulation have been 256-color drivers.   If Winfract ever does find itself running with a palette-based 16-color video driver (it's theoretically possible), it will color-cycle only when its window has the input focus (temporarily converting the remainder of your Windows screen to black-and-white), and return to the "stock" palette values when it loses this focus.   

#$+K

Distribution Policy, Contacting the Authors, The Book 
 
The Stone Soup Group is a loosely associated group of fanatic programmers.   Winfract (Fractint for Windows) like Fractint for DOS, is copyrighted freeware. Our motto is simple: Don't want money. Got money. Want admiration.  This means we encourage prolific use and distribution of Winfract not for money, but for the pleasure of knowing you enjoy it.  So play with it, change it, learn from the source code, put the fractals in your artwork, whatever.  But don't sell it or bundle it with your commercial product without permission.  That is illegal. 

Conditions on use: 

Winfract (Fractint for Windows) like Fractint for DOS, is copyrighted freeware.  As such, it may be freely copied and distributed but may not be sold.  Winfract may be distributed by shareware and freeware distributors and a nominal distribution fee may be charged for media and handling.  Winfract may also be distributed on networks and BBSs.  Winfract may be used personally or in a business - if you can do your job better by using Winfract, or using images from it, that's great!  Winfract may not be given away with commercial products without explicit permission from the Stone Soup Group.

There is no warranty of Winfract's suitability for any purpose, nor any acceptance of liability, express or implied.   

Contacting the Authors

Communication between the authors for development of the next version of Fractint takes place in the fractint mailing list.

Program Updates

New versions of FRACTINT are uploaded to the Fractint developer's web site at www.fractint.org, and make their way to other systems from that point.  FRACTINT is available as two self-extracting archive files - FRAINT.EXE (executable & documentation) and FRASRC.EXE (source code).

The latest developer's version can also be found at www.fractint.org.

Many other sites tend to carry these files shortly after their initial release (although sometimes using different naming conventions).  Look for frainnn.zip (executable package) and frasrnnn.zip (source), where nnn is the release number. Major releases with two digit numbers have names such as fraintnn.zip and frasrcnn.zip.

On the Internet, try the Noel Giffin's Spanky Fractal Database. Using a Web browser, go to: http://spanky.triumf.ca/pub/fractals/programs/ibmpc/frainxxx.zip where xxx is the release number.

Via FTP, login to spanky.triumf.ca as ANONYMOUS, and change directories to [pub.fractals.programs.ibmpc], then download frainxxx.zip. (The directory syntax is in VAX format.)

The X Windows port of Fractint was written by Ken Shirriff and is available via FTP from http://spanky.triumf.ca/pub/fractals/programs/unix/XFRACTxxx.zip where xxx is the Xfractint release number.  Developer's versions of Xfractint are available at the Fractint developer's web site.

#$+K
A list of Winfract and Fractint Authors 

Winfract (Fractint for Windows) was originally ported from Fractint-for-DOS by Bert Tyler.  This is the first Windows program that Bert ever wrote,which goes a long way towards explaining a lot of the bugs.  Bert's task was made a lot easier by Pieter Branderhorst, who separated the MSDOS-specific code from Fractint-for-DOS's fractal generator modules, making a Windows port of the package possible.  Mark Peterson helped track down and eliminate a lot of the bugs that were in the original program, and has since added several new options which take advantage of the capabilities of the Windows environment.

The Winfract source lay dormant for many years, and was finally brought up to the current version of Fractint-for-DOS by Jonathan Osuch.

Fractint for Windows is based heavily on (and uses the fractal generator engines straight out of) Fractint-for-DOS.  A partial list of the authors of Fractint-for-DOS, taken from Fractint version 20.5, includes: 

------------------  Primary Authors (this changes over time)  ----------------- 
Timothy Wegner	twegner AT fractint.org
Jonathan Osuch	josuch AT fractint.org
                 ---------  Contributing Authors ---------- 

 Michael Abrash		360x480x256, 320x400x256 VGA video modes
 Rees Acheson		(Author of MandelB) pentium speedups
 Joseph Albrecht	Tandy video, CGA video speedup
 Kevin Allen		Finite attractor, bifurcation engine
 Humberto Baptista	passes=d, latoocarfian type
 Steve Bennett		restore-from-disk logic
 Rob Beyer		Barnsley IFS, Lorenz fractals
 Francois Blais		Lyapunov Fractals, LYAPUNOV.MAP
 Scott D. Boyd		Xfractint user interface cleanup
 Dennis Bragg		DXF Raytracing output option
 Juan J. Buhler		Diffusion options, inverse Julia type
 Mike Burkey		376x564x256, 400x564x256, and 832x612x256 VGA video modes
 Robin Bussell		Fractal browser and evolver, past primary author
 John Bridges		superVGA support, 360x480x256 mode
 Fulvio Cappelli		ants options and speedup
 Charlie Chernohorsky	Virtual VESA screen sizes & speedup
 Brian Corbino		Tandy 1000 640x200x16 video mode
 Lee Crocker		Fast Newton, Inversion, Decomposition..
 Monte Davis		Documentation
 Paul De Leeuw		RDS (Random Dot Stereogram) Feature
 Jean-Pierre Demailly	Xfractint truecolor
 Chuck Ebbert		cmprsd & sqrt logmap, fpu speedups, fast parser
 Dan Farmer		orbits enhancements
 Richard Finegold	8/16/../256-Way Decomposition option
 Frank Fussenegger	Mandelbrot speedups
 Sylvie Gallet		Formula and math wizard
 Mike Gelvin		Mandelbrot speedups
 Luciano Genero	ants options and speedup
 Lawrence Gozum	Tseng 640x400x256 Video Mode
 David Guenther	Boundary Tracing algorithm
 Jay Hill			Windows notes
 Mike Kaufman		mouse support, other features
 Norman Hills		Ranges option
 Richard Hughes	"inside=", "outside=" coloring options
 Bill Jemison		orbitsave=sound option
 Damien M. Jones	Windows notes, web hosting
 Wesley Loewer		Arbitrary precision, past primary author
 Adrian Mariano		Diffusion & L-Systems
 Charles Marslett	VESA video and IIT math chip support
 George Martin		Formula parser, past primary author
 Andrew McCarthy	European keyboard support
 Joe McLain		TARGA Support, color-map files
 Bob Montgomery	(Author of VPIC) Fast text I/O routines
 Bret Mulvey		plasma clouds
 Roy Murphy		Lyapunov Fractals
 Ethan Nagel		Palette editor, integrated help/doc system
 Yavuz Onder		Postscript printer driver
 Kyle Powell		8514/A Support
 Mark Peterson		Parser, julibrot, past primary author
 Marc Reinig		Lots of 3D options
 Pieter Branderhorst	Solid guessing, menus, past primary author
 Michael Sargent	Volterra-Lotka, escher_julia fractals
 Matt Saucier		Printer Support
 Herb Savage		'inside=bof60', 'inside=bof61' options
 Ken Shirriff		Quaternions, CA, Xfractint port
 Lee Skinner		Tetrate fractal types and more
 Michael Snyder		julia inverse and Julia-In-A-Window using MIIM
 Dean Souleles		Hercules Support
 Kurt Sowa		Color Printer Support
 Hugh Steele		cyclerange feature
 Iain Stirling		Inside=fmod and outside=fmod
 John Swenson		Postscript printer features
 Chris Taylor		Floating&Fixed-point algorithm speedups, Tesseral Option
 Scott Taylor		PostScript, Kam Torus, many fn types.
 Rich Thomson		Xfractint truecolor support, mailing list
 Bill Townsend		Mandelbrot Speedups
 Bert Tyler		Original Fractint/Fract386 Author 
 Paul Varner		Extended Memory support for Disk Video
 Dave Warker		Integer Mandelbrot Fractals concept
 Aaron Williams		Register-compatible 8514/A code
 Phil Wilson		Distance Estimator, Bifurcation fractals
 Nicholas Wilt		Lsystem speedups
 Richard Wilton		Tweaked VGA Video modes