#+$ Fractint for Windows (Winfract) 

Copyright (C) 1990, 91 The Stone Soup Group.  Fractint for Windows may be freely copied and distributed, but may not be sold.

Help Topics
	New Features in this Version
	Bugs and Limitations in this Version
	File Menu
	Fractal Formula Selection
	Image Sizing and Color selection
	Coordinate Box options
	Zooming in on an Image, Mandelbrot/Julia Toggling
	Options and Doodads
	Color-Cycling
	Getting a Status Report
	Distribution Policy and Procedures, Contacting the Authors
	A list of Fractint Authors
	
#$+K 
New Features in this Version 

The internal Fractal engine in this release is from Fractint 16.0.  (Note that many of the other options introduced in Fractint 16.0, such as its new "demo mode", are not included in this release of Winfract.)

When generated using a Windows video driver capable of 256 simultaneous colors, Plasma Clouds now use only 236 of those colors, leaving 20 colors untouched to avoid conflict with the 20 palette entries reserved by Windows.  No more "black holes" in your plasma clouds.

The Color-Cycling option is grayed out and non-selectable if your Windows video driver does not support palettes (and most 16-color Windows video drivers don't).  

The Status! option has been moved from the top of the main menu bar into the "Options" menu.

The following New Features are all from Mark Peterson:

Window Sizing option - when selected, causes Winfract's window to automatically resize to the size of the fractal image.

Coordinate Box option - when selected, causes a Coordinate box to display, showing the position of the cursor in Rectangular, Polar, or Pixel coordinates.

Zoom Bar - when selected, causes Winfract to switch to an alternate method of generating a Zoom-box, using a "Zoom-bar" to select the size of the Zoom-box (the Zoom-box is moved around by moving the cursor to a position inside the Zoom-box, holding down the left mouse-button, and moving the cursor and the Zoom-box together).

SSTOOLS.INI updating - Winfract now automatically updates your SSTOOLS.INI file (creating a new one if none currently exists) with a special [winfract] section that contains the status of Winfract when you exited the program.  When first firing up, Winfract reads this file to determine its start-up options. 

When Running Iconized,  the Winfract icon is now replaced by an iconized version of the current fractal image.  A quick glace at the Icon will now let you know approximately what Winfract is doing.

#$+K 
Bugs and Limitations in this Version 

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 development will always "trail" that of Fractint for DOS, except where the Windows version adds functionality simply by virtue of the Windows interface.    

There are four main causes behind the various bugs and limitations in 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 drivers that aren't limitations under MS-DOS), NWP (a Novice Windows Programmer  write the original program, and he often had no idea what he was doing), and NYI (Not Yet Implemented - hey, we're working on it!).  FFD and WLIM limitations are probably permanent - hopefully NWP and NYI problems are less so. 

- 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.  NWP - we're making attempts to update the screen in periodic "chunks", but we need to improve some more in this area. 

- You cannot "abort" the File Print operations (File Save and File Open can be aborted simply by selecting another option).   NWP, NYI: We're performing the entire print operation with a single 'StretchDIBits()' call.  For now, just fire up a print operation, sit back, and wait for the results.  Also, don't expect to run a background process (like a file transfer) while Fractint is printing.  Finally, the File Print option only works on images up to 800x600 on my 386 with 6MB of RAM and LaserJet II, for some reason.  

- There are lots of places where this program doesn't thoroughly check that Windows-specific procedures that it invokes ran correctly, and it crashes on occasion because of that.  NWP, NYI: Basically, if we haven't hit a particular bug yet, we haven't adjusted the program to look for it.  

- Lots of little doodads aren't in this version yet.   NYI. 

- There are *far* too many places in this document that say "Read Fractint-for-DOS's FRACTINT.DOC file for an explanation".   NYI. 

#$+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" the first twenty palettes 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 (a feature added with version 14.0 of FFD and version 1.2 of FFW), the image will resume calculating as soon as it is loaded.  

File Save saves your current image as a GIF (version 89a) file, compatible with Fractint-for-DOS, your favorite DOS GIF viewers, and (of course) the "File Open" option.  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 (a feature added with version 14.0 of FFD and version 1.2 of FFW), the image will resume calculating as soon as it is finished saving.  

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.  For a full explanation of the zillion or so 3D parameters, read Fractint-for-DOS's FRACTINT.DOC file.   

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 Color-Map and Write Color-Map load and save external color-maps in the same manner as Fractint-for-DOS (within Windows' limitations).  

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
Fractal Formula Selection 

Using the Options Formula option, you can select any of over 60 fractal types (every fractal type that is available in version 16.0 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).  

A brief list of Fractal types (and their formulas) included in this release (Note: this list is from Fractint 15.0, and doesn't include those fractals new to 16.0): 

mandel     = 'Classic' Mandelbrot fractals using 32-bit integer math for speed.
             z(0) = 0; z(n+1) = z(n)^2 + C, where C = Xcoord + i * Ycoord.
             Two optional params: real and imaginary pertibations of z(0).
julia      = 'Classic' Julia set fractals using 32-bit integer math for speed.
             z(0) = Xcoord + i * Ycoord; z(n+1) = z(n)^2 + C.
             Two params required: real and imaginary parts of C.
newton,    = Newton Domains-of-attraction (only the coloring schemes are
newtbasin    different).  First param:  the power (from 3 to 10) of the eqn.
             If param=4, the eqn is z(n+1) = (3*z(n)^4+1)/(4*z(n)^3).
             Second param is flag to turn on alternating stripes in basin mode.
complexnewton, = Newton's fractal type extended to complex numbers. 
complexbasin     Calculates roots of z^a + b, where both 'a' and 'b' complex.
lambda     = Classic Lambda fractal.   z(0) = Xcoord + i * Ycoord;  
             z(n+1) = Lambda*z(n)*(1 - z(n)^2).  Two params: real, imaginary
             parts of Lambda. 'Julia' variant of Mandellambda
mandellambda= 'Mandelbrot-Equivalent' for the lambda fractal. z(0) = .5;
             lambda = Xcoord + i * Ycoord; z(n+1) = lambda*z(n)*(1 - z(n)^2).
             Parameters are pertubations of z(0).
barnsleym1 = Alternative 'Mandelbrot'. z(0) = Xcoord + i * Ycoord;
             z(n+1) = (z-1)*C if Real(z) >= 0, else = (z+1)*modulus(C)/C, 
             where C = Xcoord + i * Ycoord. Params are pertubations of z(0).
barnsleyj1 = 'Julia' corresponding to barnsleym1. z(0) = Xcoord + i * Ycoord;
             z(n+1) = (z-1)*C if Real(z) >= 0, else = (z+1)*modulus(C)/C.
             Two params required: real and imaginary parts of C.
barnsleym2 = Another alternative 'Mandelbrot'. z(0) = 0; z(n+1) = (z-1)*C
             if Real(z)*Imag(C) + real(C)*imag(z) >= 0, else z(n+1) =
             (z+1)*C, where C = Xcoord + i * Ycoord. Parameters are 
             pertubations of z(0).
barnsleyj2 = 'Julia' corresponding to barnsleym2. z(0) = Xcoord + i * Ycoord;
             z(n+1) = (z-1)*C if Real(z)*Imag(C) + real(C)*imag(z) >= 0,
             else = z(n+1) = (z+1)*C. Two params: real and imaginary parts of C.
barnsleym3,= Another Barnsley 'Mandelbrot', 'Julia' pair.
barnsleyj3   See Fractint-for-DOS's FRACTINT.DOC for details.
sierpinski = Sierpinski gasket - a Julia set that produces 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.
ifs        = Barnsley IFS Fractal (a fern unless an alternate IFS map has 
             been defined using the 'ifs=' command-line option). 
ifs3d      = Barnsley 3D IFS Fractal (a fern unless an alternate IFS map has 
             been defined using the 'ifs3d=' command-line option). 
marksmandel= A variant of the mandel-lambda fractal.  z(0) = 0;
             z(n+1) = ((Xcoord+i*Ycoord)^exp)*z(n) + (Xcoord+i*Ycoord).
             Parameters are pertubations of z(0).
marksjulia = A variant of the julia-lambda fractal. 
             z(0) = Xcoord + i * Ycoord;  z(n+1) = (z(0)^exp)*z(n) + z(0).
cmplxmarksjul, = The above two types generalized with 'exp' a complex rather
cmplxmarksmand     than a real number
julibrot   = 'Julibrot' 4-dimensional fractals.  See Fractint-for-DOS's 
             FRACTINT.DOC for an description of these fractals (and a 
             description of the prompts involved in invoking them). 
unity      = Mark Peterson's 'Unity' fractal type.  Truly Wierd - 
             See Fractint-for-DOS's FRACTINT.DOC for a full description. 
formula    = Formula interpreter - write your own formulas as text files! 
             See Fractint-for-DOS's FRACTINT.DOC for instructions on this one. 
lambdafn   = lambda-fn fractal.  z(0) = Xcoord + i * Ycoord;  z(n+1) = 
             lambda * fn(z(n)).  Two params: real, imag portions of lambda.
             'Julia' variant of Mandelfn. 'fn' is a variable function, 
             and may be one of sin, cos, sinh, cosh, exp, log, or sqr.
mandelfn =   'Mandelbrot-Equivalent' for the lambda-fn fractal.
             z(0) = Xcoord + i * Ycoord;  z(n+1) = z(0)*fn(z(n)). Parameters
             are pertubations of z(0). 'fn' is a variable function.
mandel4    = Fourth-power 'Mandelbrot' fractals using 32-bit integer math.
             z(0) = 0; z(n+1) = z(n)^4 + C, where C = Xcoord + i * Ycoord.
             Two optional params: real and imaginary parts of z(0) (if not 0).
julia4     = Fourth-power Julia set fractals using 32-bit integer math.
             z(0) = Xcoord + i * Ycoord; z(n+1) = z(n)^4 + C.
             Two params required: real and imaginary parts of C.
test       = 'test' point letting us (and you!) easily add fractal types. 
             Currently, the 'Distance Estimator' M'brot/Julia Set algorithm. 
             two optional parameters - if none given, uses the M'brot Set" 
plasma     = plasma clouds - random, cloud-like formations.  Requires four or
             more colors.  One param: 'graininess' (.5 to 50, default = 2)
julfn+zsqrd= Julia Biomorph fractal.  z(0) = Xcoord + i * Ycoord;  z(n+1) = 
             fn(z(n)) + z(n)^2 + C.  Two params: real, imag portions of C.
manfn+zsqrd= 'Mandelbrot-Equivalent' for the Julfn+zsqrd fractal.
             z(0) = Xcoord + i * Ycoord0; z(n+1) = fn(z(n)) + z(n)^2 +  
             (Xcoord + i * Ycoord). Parameters are pertubations of z(0).
manzpower  = 'Mandelbrot-Equivalent' for julzpower. z(n+1) = z(n)^m + C.
             Parameters are real and imaginary pertubations, exponent m.
julzpower  = Juliazpower fractal.  z(0) = Xcoord + i * Ycoord;  z(n+1) = 
             z(n)^m + C.  Three params: real, imag portions of C, exponent m.
manzzpwr  = 'Mandelbrot-Equivalent' for the julzzpwr fractal.  Use the 
             Space-bar to select julzzpwr fractals a/la Mandel/Julia. 
             z(n+1) = z(n)^z(n) + z(n)^m + C. Parameters are real pertubation,
             imaginary pertubation, and exponent m.
julzzpwr  =  z(0) = Xcoord + i * Ycoord;  z(n+1) = z(n)^z(n) + z(n)^m + C.
             Three params: real, imag portions C, and the exponent m.
manfn+exp = 'Mandelbrot-Equivalent' for the julfn+exp fractal.  Use the 
             Space-bar to select julfn+exp fractals a/la Mandel/Julia. 
             z(n+1) = fn(z(n)) + e^z(n) + C. Parameters are real pertubation, 
             and imaginary pertubation of z(0).
julfn+exp =  julia fn+exp fractal.  z(0) = Xcoord + i * Ycoord;  z(n+1) = 
             fn(z(n)) + e^z(n) + C.  Two params: real, imag portions C.
popcorn   =  orbits of x(n+1) = x(n) - h*sin(y(n) + tan(3*y(n)) and
             y(n+1) = y(n) - h*sin(x(n) + tan(3*x(n)) plotted for EACH 
             screen pixel and superimposed. 
popcornjul =  Julia set from popcorn formula. z(0) = Xcoord + i * Ycoord.
             Orbit calculated as in popcorn.
bifurcation = 'Bifurcation' fractal. Pictoral representation of a population
             growth model.  Let P = new population, p = oldpopulation,
             r = growth rate.   The model is: P = p +  r*p*(1-p).
biflambda =  Bifurcation variation: model is: P =      r*p*(1-p)P.
bif+sinpi =  Bifurcation variation: model is: P =  p + r*sin(PI*p).
bif=sinpi =  Vifurcation variation: model is: P =      r*sin(PI*p).
lorenz    =  Lorenz attractor - orbit in three dimensions defined by:
             xnew = x + (-a*x*dt) + (a*y*dt)
             ynew = y + (b*x*dt) - (y*dt) - (z*x*dt)
             znew = z + (-c*z*dt) + (x*y*dt)
             Parameters are dt, a, b, and c.
lorenz3d  =  3D Lorenz attractor with 3D perspective.
rossler3D =  Orbit in three dimensions defined by:
             xnew = x - y*dt -   z*dt
             ynew = y + x*dt + a*y*dt
             znew = z + b*dt + x*z*dt - c*z*dt
             Parameters are dt, a, b, and c.
henon     =  Orbit in two dimensions defined by:
             xnew = 1 + y - a*x*x
             ynew = b*x
             Parameters are a and b
pickover  =  Orbit in three dimensions defined by:
             xnew = sin(a*y) - z*cos(b*x)
             ynew = z*sin(c*x) - cos(d*y)
             znew = sin(x)
             Parameters are a, b, c, and d.
gingerbread = Orbit in two dimensions defined by:
             x <- 1 - y + |x|
             y <- x
diffusion =  Diffusion Limited Aggregation.  Randomly moving points
             accumulate.  One param:  border width (default 10)
fn(z*z)   =  z(0) = Xcoord + i * Ycoord; z(n+1) = fn(z(n)*z(n))
fn*fn     =  z(0) = Xcoord + i * Ycoord; z(n+1) = fn(n)*fn(n)
fn*z+z    =  z(0) = Xcoord + i * Ycoord; z(n+1) = p1*fn(z(n))+p2*z(n)
             Parameters are real and imaginary components of p1 and p2.
fn+fn     =  z(0) = Xcoord + i * Ycoord; z(n+1) = p1*fn1(z(n))+p2*fn2(z(n))
             Parameters are real and imaginary components of p1 and p2.
sqr(1/fn) =  z(0) = Xcoord + i * Ycoord; z(n+1) = (1/fn(z(n))*(1/fn(z(n))
sqr(fn)   =  z(0) = Xcoord + i * Ycoord; z(n+1) = fn(z(n))*fn(z(n))
spider    =  c(0) = z(0) = Xcoord + i * Ycoord; z(n+1) = z(n)*z(n) + c(n);
             c(n+1) = c(n)/2 + z(n+1)
manowar   =  c = z1(0) = z(0) = Xcoord + i*Ycoord; z(n+1) = z(n)^2 + z1(n) + c;
             z1(n+1) = z(n); 
tetrate   =  z(0) = c = Xcoord + i * Ycoord; z(n+1) = c^z(n)
kamtorus  =  series of orbits superimposed. 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. Parmeters
             are a, step size, stop value for 'orbit', and points per orbit.
kamtorus3d =  Same as kamtorus but in 3D with 'orbit' the z dimension.
magnetj1  =  z(0) = Xcoord + i * Ycoord;
                        /  z(n)^2 + (c-1) \ 
              z(n+1) = |  ---------------  | ^ 2
                        \  2*z(n) + (c-2) / 
             Parameters are real and imaginary parts of c.
magnetm1  =  'Mandelbrot' variant with c = Xcoord + i * Ycoord and z(0) = 0.
             Orbit formula same as magnetj1
             Parameters are pertubations of z(0).
magnetj2  =  z(0) = Xcoord + i * Ycoord;
                       /      z(n)^3 + 3*(C-1)*z(n) + (C-1)*(C-2)      \ 
             z(n+1) = |  --------------------------------------------   | ^ 2
                       \  3*(z(n)^2) + 3*(C-2)*z(n) + (C-1)*(C-2) - 1  / 
             Parameters are real and imaginary parts of c.
magnetm2  =  'Mandelbrot' variant with c = Xcoord + i * Ycoord and z(0) = 0.
             Orbit formula same as magnetj2
             Parameters are pertubations of z(0).

#$+K
Image Sizing and Color selection 

Using the Options Image Size option, you can 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 - sorry. 

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

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

#$+K
Zooming in on an Image, Mandelbrot/Julia Toggling 

With this release of Winfract, there are two different methods of generating and using "Zoom-Boxes".

If you do not have Mark Peterson's new "Zoom-Box" option enabled, Winfract's zoom box is activated in the same fashion as it was in earlier releases:

To zoom in on a fractal image, just move your mouse pointer to the upper-left corner of the "zoom-box" area, push and hold down the left mouse-button, move the mouse pointer to the lower-right corner of the "zoom-box" area, and let go of the mouse button.  The program will immediately begin a new image using the "zoom-box" coordinates you selected. 

As you are moving your mouse with the left-button down, the "zoom-box" area will be displayed as an X-ORed rectangle.  If you change your mind about zooming as you are moving the mouse around ("No, No, Not *There*!"), just make one of the rectangular coordinates less than five pixels across - the program will "forget" about the zoom-box if you let go of the left mouse button and that is the case. 

If the aspect ratio of your "zoom-box" is reasonably close to that of the full image size (within 33 percent or so), the program adjusts the "zoom-box" to match the aspect ratio exactly before performing the zoom. 

If you have enabled Mark Peterson's new "Zoom-Box" option, a vertical Zoom-Box scroll-bar is displayed in addition to your fractal image.  The Zoom-Box 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-box 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".

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
Options and Doodads 

You can select and of a number of options and doodads using the "Options Options-and-Doodads" menu.  The list of doodads currently includes various algorithms (single/dual pass, solid-guessing, boundary tracing), biomorphs, decomposition, inside color, outside color, maximum iterations, etc - all flagrantly stolen from Fractint-for-DOS. 

Once you select any of these options, the program will begin re-drawing your image with the new options in effect. 

#$+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. 

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.0 doesn't have it!   Also, color-cycling affects the background windows as well unless your video driver is capable of displaying 256 or more simultaneous colors.  If Windows finds itself running with a 16-color video driver, it color-cycles only when its window has the input focus, and returns to the "stock" palette values when it loses this focus.   

Winfract can now also use "Hot-keys" for color-cycling 
  spacebar - toggles color-cycling on and off 
  left, right arrows - turn on color-cycling and set the "direction" 
  ENTER - initiate random color-cycling with all new colors 
  (uhh, note that Windows takes a second or so to "fire up" color-cycling,   so be patient when you press one of these keys.  Breathe in,   breathe out, ...) 

#$+K
Getting a Status Report 

You can find out the status of your current image (which formula you are using, its parameters and screen corners, and - most important - whether or not it's still being generated or has finished) by selecting the Status option from the Options menu.  A "Pup-up" message will tell you about the status of the current image.  If the image is still being generated, the program will continue with it when you press the "OK" button. 

#$+K
Distribution Policy and Procedures, Contacting the Authors 
 
The Stone Soup Group is a loosely associated group of fanatic programmers.  See Fractint-for-DOS's FRACTINT.DOC for the story behind the 'Stone Soup' name.   Fractint for Windows, like Fractint-for-DOS, is freeware, and our "contribution policy" is the same: Don't want money. Got money. Want admiration.   

Conditions on use: 

Fractint for Windows, like Fractint-for-DOS, may be freely copied and distributed but may not be sold.   It may be used personally or in a business - if you can do your job better by using Fractint for Windows, or use images from it, that's great!   It may be given away with commercial products under the following conditions:  It must be clearly stated that Fractint for Windows does not belong to the vendor and is included as a free give-away.  It must be a complete unmodified release of Fractint, with documentation.  There is no warranty of Fractint's suitability for any purpose, nor any acceptance of liability, express or implied.   

Virtually all of the Fractint authors can be found on the Compuserve network in the COMART ('COMputer ART') forum in S 15 ('Fractals').  Fractint development occurs in the COMART forum - most of the authors have never met except there.  New members are always welcome!  Several of us can also be found on BIX in the GRAPHIC.DISP/FRACTALS area.  

New versions of Fractint-for-DOS and Fractint-for-Windows are uploaded to the Compuserve and BIX networks, and make their way to other systems from those points.  The latest version of Fractint-for-Windows can usually be found in the following locations: 

WINFRA.ZIP - (Executable/Docs)  Compuserve: COMART Lib 15 ("Fractals") 
              BIX: GRAPHIC.DISP/LISTINGS 
WINSRC.ZIP - (Complete Source)  Compuserve: COMART Lib 15 ("Fractals") 
              BIX: GRAPHIC.DISP/LISTINGS 

(What's the latest version?  Well, THIS one was, way back when we uploaded it!) 

#$+K
A list of Fractint Authors 

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 many of the new options which take advantage of the capabilities of the Windows environment.  

Fractint for Windows is based heavily on (and uses the fractal generator engines straight out of) Fractint-for-DOS.  A partial list of the authorsof Fractint-for-DOS includes: 

------------------  Primary Authors (this changes over time)  ----------------- 
Bert Tyler          - Compuserve (CIS) ID: [73477,433]   BIX ID: btyler 
Timothy Wegner      - CIS ID: [71320,675]   Internet: twegner@mwunix.mitre.org 
Mark Peterson       - CIS ID: [70441,3353] 
Pieter Branderhorst - CIS ID: [72611,2257] 
                 ---------  Contributing Authors ---------- 

Michael Abrash  - 360x480x256, 320x400x256 VGA video modes 
Joseph Albrecht - Tandy video, CGA video speedup 
Kevin Allen     - Finite attractor and bifurcation engine 
Steve Bennett   - restore-from-disk logic 
Rob Beyer       - [71021,2074] Barnsley IFS, Lorenz fractals 
Mike Burkey     - 376x564x256, 400x564x256, and 832x612x256 VGA video modes 
John Bridges    - [73307,606] superVGA support, 360x480x256 mode 
Brian Corbino   - [71611,702] Tandy 1000 640x200x16 video mode 
Lee Crocker     - [73407,2030] Fast Newton, Inversion, Decomposition.. 
Monte Davis     - [71450,3542] Documentation 
Chuck Ebbert    - [76306,1226] compressed,sqrt log palette, FPU speedups 
Richard Finegold- [76701,153] 8/16/../256-Way Decomposition option 
Mike Gelvin     - [73337,520] Mandelbrot speedups 
Lawrence Gozum  - [73437,2372] Tseng 640x400x256 Video Mode 
David Guenther  - [70531,3525] Boundary Tracing algorithm
Norman Hills   - [71621,1352] Ranges Option 
Mike Kaufman    - [kaufman@eecs.nwu.edu] mouse support, other features 
Adrian Mariano  - [theorem@blake.acs.washington.edu] Diffusion & L-Systems 
Charles Marslett - [73317,3662] VESA Video and ITT math chip support
Chris Martin    - Paintjet printer support 
Joe McLain      - [75066,1257] TARGA Support, color-map files 
Bob Montgomery  - [73357,3140] (Author of VPIC) Fast text I/O routines 
Bret Mulvey     - plasma clouds 
Ethan Nagel     - [70022,2552] Palette editor , integrated Help/Doc system
Jonathan Osuch - [73227,1432] ITT detect
Marc Reinig     - [72410,77] Lots of 3D options 
Kyle Powell     - [76704,12] 8514/A Support 
Matt Saucier    - [72371,3101] Printer Support 
Herb Savage     - [71640,455] 'inside=bof60', 'inside=bof61' options 
Lee Skinner     - Tetrate, Spider, Mandelglass fractal types and more 
Dean Souleles   - [75115,1671] Hercules Support 
Kurt Sowa       - [73467,2013] Color Printer Support 
Hugh Steele  - Cyclerange feature
Scott Taylor    - [72401,410] (DGWM18A) Postscript, KAM Torus, many fn types 
Paul Varner     - [73237,411] Floating-point fractal algorithms 
Dave Warker     - Integer Mandelbrot Fractals concept 
Phil Wilson     - [76247,3145] Distance Estimator, Bifurcation fractals 
Richard Wilton  - Tweaked VGA Video modes 
                  ... 
Byte Magazine   - Tweaked VGA Modes 
MS-Kermit       - Keyboard Routines 
PC Magazine     - Sound Routines 
PC Tech Journal - CPU, FPU Detectors