diff --git a/.gitignore b/.gitignore
index c1e0dafa8..0a087e31f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -19,3 +19,4 @@ rdoc
 pkg
 
 ## PROJECT::SPECIFIC
+dist
diff --git a/README.txt b/README.txt
index 1f96188ff..10f35e8b2 100644
--- a/README.txt
+++ b/README.txt
@@ -20,10 +20,10 @@ It can:
  * re-enact command line interactions
  * call up a menu of sections/slides at any time to jump around
  * execute javascript or ruby live and display results
+ * do simple transitions (instant, fade, slide in)
 
 It might will can:
 
- * do simple transitions (instant, fade, slide in)
  * show a timer - elapsed / remaining
  * perform simple animations of images moving between keyframes
  * show syncronized, hidden notes on another browser (like an iphone)
@@ -68,7 +68,7 @@ the following contents:
 
   # My Presentation #
 
-  !SLIDE bullets incremental
+  !SLIDE bullets incremental transition=fade
 
   # Bullet Points #
 
@@ -76,10 +76,10 @@ the following contents:
   * second point
   * third point
 
-That represents two slides, one with just a large title and one with three
-bullets that are incrementally updated when the slide is shown. In order for
-ShowOff to see those slides, your showoff.json file needs to look something
-like this:
+That represents two slides, the first contains just a large title, and the
+second is faded into view showing the title and three bullets that are then
+incrementally shown. In order for ShowOff to see those slides, your 
+showoff.json file needs to look something like this:
 
   [
     {"section":"one"}
@@ -109,6 +109,43 @@ Some useful styles for each slide are:
 
 Check out the example directory included to see examples of most of these.
 
+Transitions can be supplied through the use of transition=tname on the !SLIDE
+definition, where tname is one of the following supported transitions:
+
+ * blindX
+ * blindY
+ * blindZ
+ * cover
+ * curtainX
+ * curtainY
+ * fade
+ * fadeZoom
+ * growX
+ * growY
+ * none (this is the default)
+ * scrollUp
+ * scrollDown
+ * scrollLeft
+ * scrollRight
+ * scrollHorz
+ * scrollVert
+ * shuffle
+ * slideX
+ * slideY
+ * toss
+ * turnUp
+ * turnDown
+ * turnLeft
+ * turnRight
+ * uncover
+ * wipe
+ * zoom
+
+The transitions are provided by jQuery Cycle plugin. See
+http://www.malsup.com/jquery/cycle/browser.html to view the effects and 
+http://www.malsup.com/jquery/cycle/adv2.html for how to add
+custom effects.
+
 You can manage the presentation with the following keys:
 
  * space, cursor right: next slide
diff --git a/TODO.txt b/TODO.txt
index aab2433f1..2cbbc15b4 100644
--- a/TODO.txt
+++ b/TODO.txt
@@ -1,19 +1,12 @@
 TODO
 =================
 
-- static output
-  - single html file
-  - pdf
-- showoff.json in each subdir
+- can have showoff.json in each subdir
 - showoff add
   - add new slide/section
   - add slides of images directory (refactor script/import_images.rb)
 - simple highlighting (highlight region of slide / click to highlight)
-- simple transitions
 - presenter tools
-  - show/hide timer
-  - warning when time is up or pace is too slow
-    - part of plugin system of things that can be running outside of slideshow
   - notes view (quick polling)
 - audience interface
   - slide download / git clone
diff --git a/example/one/octocat.png b/example/one/octocat.png
new file mode 100644
index 000000000..b321b3dc6
Binary files /dev/null and b/example/one/octocat.png differ
diff --git a/example/one/slidesA.md b/example/one/slidesA.md
index 366743f12..f0da64582 100644
--- a/example/one/slidesA.md
+++ b/example/one/slidesA.md
@@ -2,7 +2,7 @@
 
 # First Slide #
 
-!SLIDE bullets incremental
+!SLIDE bullets incremental transition=fade
 
 # Second Slide #
 
@@ -11,3 +11,7 @@
 * a third thing
 * a fourth thing
 * a fifth thing
+
+!SLIDE center transition=scrollUp
+
+![octocat](octocat.png)
diff --git a/lib/showoff.rb b/lib/showoff.rb
index f17a611b2..58273cb6f 100644
--- a/lib/showoff.rb
+++ b/lib/showoff.rb
@@ -46,7 +46,7 @@ def js_files
       Dir.glob("#{options.pres_dir}/*.js").map { |path| File.basename(path) }
     end
 
-    def process_markdown(name, content, wrap = false)
+    def process_markdown(name, content)
       slides = content.split(/^!SLIDE/)
       slides.delete('')
       final = ''
@@ -55,21 +55,30 @@ def process_markdown(name, content, wrap = false)
       end
       slides.each do |slide|
         md = ''
+        # extract content classes
         lines = slide.split("\n")
-        classes = lines.shift
+        content_classes = lines.shift.split
         slide = lines.join("\n")
-        md += '<div class="' + wrap + '">' if wrap
+        # add content class too
+        content_classes.unshift "content"
+        # extract transition, defaulting to none
+        transition = 'none'
+        content_classes.delete_if { |x| x =~ /^transition=(.+)/ && transition = $1 }
+        puts "classes: #{content_classes.inspect}"
+        puts "transition: #{transition}"
+        # create html
+        md += "<div class=\"slide\" data-transition=\"#{transition}\">"
         if seq
-          md += "<div class=\"slide #{classes}\" ref=\"#{name}/#{seq.to_s}\">\n"
+          md += "<div class=\"#{content_classes.join(' ')}\" ref=\"#{name}/#{seq.to_s}\">\n"
           seq += 1
         else
-          md += "<div class=\"slide #{classes}\" ref=\"#{name}\">\n"
+          md += "<div class=\"#{content_classes.join(' ')}\" ref=\"#{name}\">\n"
         end
         sl = Markdown.new(slide).to_html 
         sl = update_image_paths(name, sl)
         md += sl
         md += "</div>\n"
-        md += "</div>\n" if wrap
+        md += "</div>\n"
         final += update_commandline_code(md)
       end
       final
@@ -118,7 +127,7 @@ def update_commandline_code(slide)
       html.root.to_s
     end
     
-    def get_slides_html(wrap = false)
+    def get_slides_html
       index = File.join(options.pres_dir, 'showoff.json')
       files = []
       if File.exists?(index)
@@ -132,7 +141,7 @@ def get_slides_html(wrap = false)
         data = ''
         files.each do |f|
           fname = f.gsub(options.pres_dir + '/', '').gsub('.md', '')
-          data += process_markdown(fname, File.read(f), wrap)
+          data += process_markdown(fname, File.read(f))
         end
       end
       data
@@ -183,12 +192,12 @@ def inline_js(jses, pre = nil)
   end
 
   get '/onepage' do
-    @slides = get_slides_html('preso')
+    @slides = get_slides_html
     erb :onepage
   end
 
   get '/pdf' do
-    @slides = get_slides_html('preso')
+    @slides = get_slides_html
     @no_js = true
     html = erb :onepage
     p = Princely.new
diff --git a/public/css/onepage.css b/public/css/onepage.css
index f708dcd2e..fda119662 100644
--- a/public/css/onepage.css
+++ b/public/css/onepage.css
@@ -1,4 +1,4 @@
-.preso { 
+.slide {
     margin: 10px;
     padding: 0;
     width: 1020px;
diff --git a/public/css/pdf.css b/public/css/pdf.css
index f79fc6705..ea1989b88 100644
--- a/public/css/pdf.css
+++ b/public/css/pdf.css
@@ -1,4 +1,4 @@
-.preso { 
+.slide {
     margin: 0;
     padding: 0;
     width: 100%;
diff --git a/public/css/reset.css b/public/css/reset.css
new file mode 100644
index 000000000..1c85489d6
--- /dev/null
+++ b/public/css/reset.css
@@ -0,0 +1,53 @@
+/* http://meyerweb.com/eric/tools/css/reset/ */
+/* v1.0 | 20080212 */
+
+html, body, div, span, applet, object, iframe,
+h1, h2, h3, h4, h5, h6, p, blockquote, pre,
+a, abbr, acronym, address, big, cite, code,
+del, dfn, em, font, img, ins, kbd, q, s, samp,
+small, strike, strong, sub, sup, tt, var,
+b, u, i, center,
+dl, dt, dd, ol, ul, li,
+fieldset, form, label, legend,
+table, caption, tbody, tfoot, thead, tr, th, td {
+	margin: 0;
+	padding: 0;
+	border: 0;
+	outline: 0;
+	font-size: 100%;
+	vertical-align: baseline;
+	background: transparent;
+}
+body {
+	line-height: 1;
+}
+ol, ul {
+	list-style: none;
+}
+blockquote, q {
+	quotes: none;
+}
+blockquote:before, blockquote:after,
+q:before, q:after {
+	content: '';
+	content: none;
+}
+
+/* remember to define focus styles! */
+:focus {
+	outline: 0;
+}
+
+/* remember to highlight inserts somehow! */
+ins {
+	text-decoration: none;
+}
+del {
+	text-decoration: line-through;
+}
+
+/* tables still need 'cellspacing="0"' in the markup */
+table {
+	border-collapse: collapse;
+	border-spacing: 0;
+}
diff --git a/public/css/showoff.css b/public/css/showoff.css
index 7cd2cbbe1..e71d73d57 100644
--- a/public/css/showoff.css
+++ b/public/css/showoff.css
@@ -1,33 +1,25 @@
 body {
     font-family: "Gill Sans", Helvetica, Arial, sans-serif;
-    padding: 0;
-    margin: 0;
-    border: 0;
 }
 
-#preso { 
-    margin: 0;
-    padding: 0;
+#preso, .slide {
+    background: #fff;
     width: 1020px;
     height: 740px;
-    margin-left:auto; 
+    margin-left:auto;
     margin-right:auto;
     overflow:hidden;
 }
-#footer { 
+
+#footer {
     background: #eee;
-    margin: 0;
     padding: 2px;
     width: 1010px;
     height: 20px;
-    margin-left:auto; 
+    margin-left:auto;
     margin-right:auto;
 }
 
-.slide {
-    border: 1px solid #fff;
-}
-
 .center img {
     display:block;
     margin-left:auto;
@@ -35,13 +27,7 @@ body {
 }
 
 .bullets ul {
-    display: block;
-    height: 600px;
     font-size: 3em;
-    list-style: none;
-    margin-left: 0;
-    padding-left: 1em;
-    text-indent: -1em;
 }
 .bullets ul li {
     text-align: center;
@@ -49,13 +35,7 @@ body {
 }
 
 .smbullets ul {
-    display: block;
-    height: 600px;
     font-size: 2em;
-    list-style: none;
-    margin-left: 0;
-    padding-left: 1em;
-    text-indent: -1em;
 }
 .smbullets ul li {
     text-align: center;
@@ -102,9 +82,14 @@ h1 { font-size: 5em; font-weight: normal; text-align: center;}
 h2 { font-size: 3em; font-weight: normal; text-align: center; }
 h3 { font-size: 2em; font-weight: normal; text-align: center; }
 
+h1, h2, h3 {
+  margin: 0.5em 0;
+}
+
 pre { margin-left: 40px; font-size: 2.8em; }
 
 .hidden { position:absolute; top:0; left:-9999px; width:1px; height:1px; overflow:hidden; }
+.offscreen { position:absolute; top:0; left:-9999px; overflow:hidden; }
 #debugInfo { margin-left: 30px; }
 
 #help {
@@ -112,6 +97,7 @@ pre { margin-left: 40px; font-size: 2.8em; }
     position: absolute;
     right: 80px;
     display: none;
+    z-index: 2147483647; //max, see http://www.puidokas.com/max-z-index/
 }
 #help table tr td.key {
     text-align: right;
@@ -120,6 +106,10 @@ pre { margin-left: 40px; font-size: 2.8em; }
     font-weight: bold;
 }
 
+.fg-menu-container {
+    z-index: 2147483647; //max, see http://www.puidokas.com/max-z-index/
+}
+
 .fg-button { clear:left; margin:0 4px 40px 20px; padding: .4em 1em; text-decoration:none !important; cursor:pointer; position: relative; text-align: center; zoom: 1; }
 .fg-button .ui-icon { position: absolute; top: 50%; margin-top: -8px; left: 50%; margin-left: -8px; }
 a.fg-button { float:left; }
@@ -190,7 +180,7 @@ a.fg-button { float:left; }
 .code .vi { color: #008080 } /* Name.Variable.Instance */
 .code .il { color: #009999 } /* Literal.Number.Integer.Long */
 
-.results { 
+.results {
   background-color:#002200;
   color:#00AA00;
   font-size:2em;
diff --git a/public/js/jquery.batchImageLoad.js b/public/js/jquery.batchImageLoad.js
new file mode 100644
index 000000000..2d4f3debe
--- /dev/null
+++ b/public/js/jquery.batchImageLoad.js
@@ -0,0 +1,56 @@
+/**
+ *  Plugin which is applied on a list of img objects and calls
+ *  the specified callback function, only when all of them are loaded (or errored).
+ *  @author:  H. Yankov (hristo.yankov at gmail dot com)
+ *  @version: 1.0.0 (Feb/22/2010)
+ *	http://yankov.us
+ */
+
+(function($) {
+$.fn.batchImageLoad = function(options) {
+	var images = $(this);
+	var originalTotalImagesCount = images.size();
+	var totalImagesCount = originalTotalImagesCount;
+	var elementsLoaded = 0;
+
+	// Init
+	$.fn.batchImageLoad.defaults = {
+		loadingCompleteCallback: null,
+		imageLoadedCallback: null
+	}
+  var opts = $.extend({}, $.fn.batchImageLoad.defaults, options);
+
+	// Start
+	images.each(function() {
+		// The image has already been loaded (cached)
+		if ($(this)[0].complete) {
+			totalImagesCount--;
+			if (opts.imageLoadedCallback) opts.imageLoadedCallback(elementsLoaded, originalTotalImagesCount);
+		// The image is loading, so attach the listener
+		} else {
+			$(this).load(function() {
+				elementsLoaded++;
+
+				if (opts.imageLoadedCallback) opts.imageLoadedCallback(elementsLoaded, originalTotalImagesCount);
+
+				// An image has been loaded
+				if (elementsLoaded >= totalImagesCount)
+					if (opts.loadingCompleteCallback) opts.loadingCompleteCallback();
+			});
+			$(this).error(function() {
+				elementsLoaded++;
+
+				if (opts.imageLoadedCallback) opts.imageLoadedCallback(elementsLoaded, originalTotalImagesCount);
+
+				// The image has errored
+				if (elementsLoaded >= totalImagesCount)
+					if (opts.loadingCompleteCallback) opts.loadingCompleteCallback();
+			});
+		}
+	});
+
+	// There are no unloaded images
+	if (totalImagesCount <= 0)
+		if (opts.loadingCompleteCallback) opts.loadingCompleteCallback();
+};
+})(jQuery);
\ No newline at end of file
diff --git a/public/js/jquery.cycle.all.js b/public/js/jquery.cycle.all.js
new file mode 100644
index 000000000..1d8441af9
--- /dev/null
+++ b/public/js/jquery.cycle.all.js
@@ -0,0 +1,1284 @@
+/*!
+ * jQuery Cycle Plugin (with Transition Definitions)
+ * Examples and documentation at: http://jquery.malsup.com/cycle/
+ * Copyright (c) 2007-2010 M. Alsup
+ * Version: 2.80 (05-MAR-2010)
+ * Dual licensed under the MIT and GPL licenses:
+ * http://www.opensource.org/licenses/mit-license.php
+ * http://www.gnu.org/licenses/gpl.html
+ * Requires: jQuery v1.2.6 or later
+ */
+;(function($) {
+
+var ver = '2.80';
+
+// if $.support is not defined (pre jQuery 1.3) add what I need
+if ($.support == undefined) {
+	$.support = {
+		opacity: !($.browser.msie)
+	};
+}
+
+function debug(s) {
+	if ($.fn.cycle.debug)
+		log(s);
+}
+function log() {
+	if (window.console && window.console.log)
+		window.console.log('[cycle] ' + Array.prototype.join.call(arguments,' '));
+};
+
+// the options arg can be...
+//   a number  - indicates an immediate transition should occur to the given slide index
+//   a string  - 'pause', 'resume', 'toggle', 'next', 'prev', 'stop', 'destroy' or the name of a transition effect (ie, 'fade', 'zoom', etc)
+//   an object - properties to control the slideshow
+//
+// the arg2 arg can be...
+//   the name of an fx (only used in conjunction with a numeric value for 'options')
+//   the value true (only used in first arg == 'resume') and indicates
+//	 that the resume should occur immediately (not wait for next timeout)
+
+$.fn.cycle = function(options, arg2) {
+	var o = { s: this.selector, c: this.context };
+
+	// in 1.3+ we can fix mistakes with the ready state
+	if (this.length === 0 && options != 'stop') {
+		if (!$.isReady && o.s) {
+			log('DOM not ready, queuing slideshow');
+			$(function() {
+				$(o.s,o.c).cycle(options,arg2);
+			});
+			return this;
+		}
+		// is your DOM ready?  http://docs.jquery.com/Tutorials:Introducing_$(document).ready()
+		log('terminating; zero elements found by selector' + ($.isReady ? '' : ' (DOM not ready)'));
+		return this;
+	}
+
+	// iterate the matched nodeset
+	return this.each(function() {
+		var opts = handleArguments(this, options, arg2);
+		if (opts === false)
+			return;
+
+		opts.updateActivePagerLink = opts.updateActivePagerLink || $.fn.cycle.updateActivePagerLink;
+
+		// stop existing slideshow for this container (if there is one)
+		if (this.cycleTimeout)
+			clearTimeout(this.cycleTimeout);
+		this.cycleTimeout = this.cyclePause = 0;
+
+		var $cont = $(this);
+		var $slides = opts.slideExpr ? $(opts.slideExpr, this) : $cont.children();
+		var els = $slides.get();
+		if (els.length < 2) {
+			log('terminating; too few slides: ' + els.length);
+			return;
+		}
+
+		var opts2 = buildOptions($cont, $slides, els, opts, o);
+		if (opts2 === false)
+			return;
+
+		var startTime = opts2.continuous ? 10 : getTimeout(opts2.currSlide, opts2.nextSlide, opts2, !opts2.rev);
+
+		// if it's an auto slideshow, kick it off
+		if (startTime) {
+			startTime += (opts2.delay || 0);
+			if (startTime < 10)
+				startTime = 10;
+			debug('first timeout: ' + startTime);
+			this.cycleTimeout = setTimeout(function(){go(els,opts2,0,!opts2.rev)}, startTime);
+		}
+	});
+};
+
+// process the args that were passed to the plugin fn
+function handleArguments(cont, options, arg2) {
+	if (cont.cycleStop == undefined)
+		cont.cycleStop = 0;
+	if (options === undefined || options === null)
+		options = {};
+	if (options.constructor == String) {
+		switch(options) {
+		case 'destroy':
+		case 'stop':
+			var opts = $(cont).data('cycle.opts');
+			if (!opts)
+				return false;
+			cont.cycleStop++; // callbacks look for change
+			if (cont.cycleTimeout)
+				clearTimeout(cont.cycleTimeout);
+			cont.cycleTimeout = 0;
+			$(cont).removeData('cycle.opts');
+			if (options == 'destroy')
+				destroy(opts);
+			return false;
+		case 'toggle':
+			cont.cyclePause = (cont.cyclePause === 1) ? 0 : 1;
+			return false;
+		case 'pause':
+			cont.cyclePause = 1;
+			return false;
+		case 'resume':
+			cont.cyclePause = 0;
+			if (arg2 === true) { // resume now!
+				options = $(cont).data('cycle.opts');
+				if (!options) {
+					log('options not found, can not resume');
+					return false;
+				}
+				if (cont.cycleTimeout) {
+					clearTimeout(cont.cycleTimeout);
+					cont.cycleTimeout = 0;
+				}
+				go(options.elements, options, 1, 1);
+			}
+			return false;
+		case 'prev':
+		case 'next':
+			var opts = $(cont).data('cycle.opts');
+			if (!opts) {
+				log('options not found, "prev/next" ignored');
+				return false;
+			}
+			$.fn.cycle[options](opts);
+			return false;
+		default:
+			options = { fx: options };
+		};
+		return options;
+	}
+	else if (options.constructor == Number) {
+		// go to the requested slide
+		var num = options;
+		options = $(cont).data('cycle.opts');
+		if (!options) {
+			log('options not found, can not advance slide');
+			return false;
+		}
+		if (num < 0 || num >= options.elements.length) {
+			log('invalid slide index: ' + num);
+			return false;
+		}
+		options.nextSlide = num;
+		if (cont.cycleTimeout) {
+			clearTimeout(cont.cycleTimeout);
+			cont.cycleTimeout = 0;
+		}
+		if (typeof arg2 == 'string')
+			options.oneTimeFx = arg2;
+		go(options.elements, options, 1, num >= options.currSlide);
+		return false;
+	}
+	return options;
+};
+
+function removeFilter(el, opts) {
+	if (!$.support.opacity && opts.cleartype && el.style.filter) {
+		try { el.style.removeAttribute('filter'); }
+		catch(smother) {} // handle old opera versions
+	}
+};
+
+// unbind event handlers
+function destroy(opts) {
+	if (opts.next)
+		$(opts.next).unbind(opts.prevNextEvent);
+	if (opts.prev)
+		$(opts.prev).unbind(opts.prevNextEvent);
+
+	if (opts.pager || opts.pagerAnchorBuilder)
+		$.each(opts.pagerAnchors || [], function() {
+			this.unbind().remove();
+		});
+	opts.pagerAnchors = null;
+	if (opts.destroy) // callback
+		opts.destroy(opts);
+};
+
+// one-time initialization
+function buildOptions($cont, $slides, els, options, o) {
+	// support metadata plugin (v1.0 and v2.0)
+	var opts = $.extend({}, $.fn.cycle.defaults, options || {}, $.metadata ? $cont.metadata() : $.meta ? $cont.data() : {});
+	if (opts.autostop)
+		opts.countdown = opts.autostopCount || els.length;
+
+	var cont = $cont[0];
+	$cont.data('cycle.opts', opts);
+	opts.$cont = $cont;
+	opts.stopCount = cont.cycleStop;
+	opts.elements = els;
+	opts.before = opts.before ? [opts.before] : [];
+	opts.after = opts.after ? [opts.after] : [];
+	opts.after.unshift(function(){ opts.busy=0; });
+
+	// push some after callbacks
+	if (!$.support.opacity && opts.cleartype)
+		opts.after.push(function() { removeFilter(this, opts); });
+	if (opts.continuous)
+		opts.after.push(function() { go(els,opts,0,!opts.rev); });
+
+	saveOriginalOpts(opts);
+
+	// clearType corrections
+	if (!$.support.opacity && opts.cleartype && !opts.cleartypeNoBg)
+		clearTypeFix($slides);
+
+	// container requires non-static position so that slides can be position within
+	if ($cont.css('position') == 'static')
+		$cont.css('position', 'relative');
+	if (opts.width)
+		$cont.width(opts.width);
+	if (opts.height && opts.height != 'auto')
+		$cont.height(opts.height);
+
+	if (opts.startingSlide)
+		opts.startingSlide = parseInt(opts.startingSlide);
+
+	// if random, mix up the slide array
+	if (opts.random) {
+		opts.randomMap = [];
+		for (var i = 0; i < els.length; i++)
+			opts.randomMap.push(i);
+		opts.randomMap.sort(function(a,b) {return Math.random() - 0.5;});
+		opts.randomIndex = 1;
+		opts.startingSlide = opts.randomMap[1];
+	}
+	else if (opts.startingSlide >= els.length)
+		opts.startingSlide = 0; // catch bogus input
+	opts.currSlide = opts.startingSlide || 0;
+	var first = opts.startingSlide;
+
+	// set position and zIndex on all the slides
+	$slides.css({position: 'absolute', top:0, left:0}).hide().each(function(i) {
+		var z = first ? i >= first ? els.length - (i-first) : first-i : els.length-i;
+		$(this).css('z-index', z)
+	});
+
+	// make sure first slide is visible
+	$(els[first]).css('opacity',1).show(); // opacity bit needed to handle restart use case
+	removeFilter(els[first], opts);
+
+	// stretch slides
+	if (opts.fit && opts.width)
+		$slides.width(opts.width);
+	if (opts.fit && opts.height && opts.height != 'auto')
+		$slides.height(opts.height);
+
+	// stretch container
+	var reshape = opts.containerResize && !$cont.innerHeight();
+	if (reshape) { // do this only if container has no size http://tinyurl.com/da2oa9
+		var maxw = 0, maxh = 0;
+		for(var j=0; j < els.length; j++) {
+			var $e = $(els[j]), e = $e[0], w = $e.outerWidth(), h = $e.outerHeight();
+			if (!w) w = e.offsetWidth || e.width || $e.attr('width')
+			if (!h) h = e.offsetHeight || e.height || $e.attr('height');
+			maxw = w > maxw ? w : maxw;
+			maxh = h > maxh ? h : maxh;
+		}
+		if (maxw > 0 && maxh > 0)
+			$cont.css({width:maxw+'px',height:maxh+'px'});
+	}
+
+	if (opts.pause)
+		$cont.hover(function(){this.cyclePause++;},function(){this.cyclePause--;});
+
+	if (supportMultiTransitions(opts) === false)
+		return false;
+
+	// apparently a lot of people use image slideshows without height/width attributes on the images.
+	// Cycle 2.50+ requires the sizing info for every slide; this block tries to deal with that.
+	var requeue = false;
+	options.requeueAttempts = options.requeueAttempts || 0;
+	$slides.each(function() {
+		// try to get height/width of each slide
+		var $el = $(this);
+		this.cycleH = (opts.fit && opts.height) ? opts.height : ($el.height() || this.offsetHeight || this.height || $el.attr('height') || 0);
+		this.cycleW = (opts.fit && opts.width) ? opts.width : ($el.width() || this.offsetWidth || this.width || $el.attr('width') || 0);
+
+		if ( $el.is('img') ) {
+			// sigh..  sniffing, hacking, shrugging...  this crappy hack tries to account for what browsers do when
+			// an image is being downloaded and the markup did not include sizing info (height/width attributes);
+			// there seems to be some "default" sizes used in this situation
+			var loadingIE	= ($.browser.msie  && this.cycleW == 28 && this.cycleH == 30 && !this.complete);
+			var loadingFF	= ($.browser.mozilla && this.cycleW == 34 && this.cycleH == 19 && !this.complete);
+			var loadingOp	= ($.browser.opera && ((this.cycleW == 42 && this.cycleH == 19) || (this.cycleW == 37 && this.cycleH == 17)) && !this.complete);
+			var loadingOther = (this.cycleH == 0 && this.cycleW == 0 && !this.complete);
+			// don't requeue for images that are still loading but have a valid size
+			if (loadingIE || loadingFF || loadingOp || loadingOther) {
+				if (o.s && opts.requeueOnImageNotLoaded && ++options.requeueAttempts < 100) { // track retry count so we don't loop forever
+					log(options.requeueAttempts,' - img slide not loaded, requeuing slideshow: ', this.src, this.cycleW, this.cycleH);
+					setTimeout(function() {$(o.s,o.c).cycle(options)}, opts.requeueTimeout);
+					requeue = true;
+					return false; // break each loop
+				}
+				else {
+					log('could not determine size of image: '+this.src, this.cycleW, this.cycleH);
+				}
+			}
+		}
+		return true;
+	});
+
+	if (requeue)
+		return false;
+
+	opts.cssBefore = opts.cssBefore || {};
+	opts.animIn = opts.animIn || {};
+	opts.animOut = opts.animOut || {};
+
+	$slides.not(':eq('+first+')').css(opts.cssBefore);
+	if (opts.cssFirst)
+		$($slides[first]).css(opts.cssFirst);
+
+	if (opts.timeout) {
+		opts.timeout = parseInt(opts.timeout);
+		// ensure that timeout and speed settings are sane
+		if (opts.speed.constructor == String)
+			opts.speed = $.fx.speeds[opts.speed] || parseInt(opts.speed);
+		if (!opts.sync)
+			opts.speed = opts.speed / 2;
+		while((opts.timeout - opts.speed) < 250) // sanitize timeout
+			opts.timeout += opts.speed;
+	}
+	if (opts.easing)
+		opts.easeIn = opts.easeOut = opts.easing;
+	if (!opts.speedIn)
+		opts.speedIn = opts.speed;
+	if (!opts.speedOut)
+		opts.speedOut = opts.speed;
+
+	opts.slideCount = els.length;
+	opts.currSlide = opts.lastSlide = first;
+	if (opts.random) {
+		if (++opts.randomIndex == els.length)
+			opts.randomIndex = 0;
+		opts.nextSlide = opts.randomMap[opts.randomIndex];
+	}
+	else
+		opts.nextSlide = opts.startingSlide >= (els.length-1) ? 0 : opts.startingSlide+1;
+
+	// run transition init fn
+	if (!opts.multiFx) {
+		var init = $.fn.cycle.transitions[opts.fx];
+		if ($.isFunction(init))
+			init($cont, $slides, opts);
+		else if (opts.fx != 'custom' && !opts.multiFx) {
+			log('unknown transition: ' + opts.fx,'; slideshow terminating');
+			return false;
+		}
+	}
+
+	// fire artificial events
+	var e0 = $slides[first];
+	if (opts.before.length)
+		opts.before[0].apply(e0, [e0, e0, opts, true]);
+	if (opts.after.length > 1)
+		opts.after[1].apply(e0, [e0, e0, opts, true]);
+
+	if (opts.next)
+		$(opts.next).bind(opts.prevNextEvent,function(){return advance(opts,opts.rev?-1:1)});
+	if (opts.prev)
+		$(opts.prev).bind(opts.prevNextEvent,function(){return advance(opts,opts.rev?1:-1)});
+	if (opts.pager || opts.pagerAnchorBuilder)
+		buildPager(els,opts);
+
+	exposeAddSlide(opts, els);
+
+	return opts;
+};
+
+// save off original opts so we can restore after clearing state
+function saveOriginalOpts(opts) {
+	opts.original = { before: [], after: [] };
+	opts.original.cssBefore = $.extend({}, opts.cssBefore);
+	opts.original.cssAfter  = $.extend({}, opts.cssAfter);
+	opts.original.animIn	= $.extend({}, opts.animIn);
+	opts.original.animOut   = $.extend({}, opts.animOut);
+	$.each(opts.before, function() { opts.original.before.push(this); });
+	$.each(opts.after,  function() { opts.original.after.push(this); });
+};
+
+function supportMultiTransitions(opts) {
+	var i, tx, txs = $.fn.cycle.transitions;
+	// look for multiple effects
+	if (opts.fx.indexOf(',') > 0) {
+		opts.multiFx = true;
+		opts.fxs = opts.fx.replace(/\s*/g,'').split(',');
+		// discard any bogus effect names
+		for (i=0; i < opts.fxs.length; i++) {
+			var fx = opts.fxs[i];
+			tx = txs[fx];
+			if (!tx || !txs.hasOwnProperty(fx) || !$.isFunction(tx)) {
+				log('discarding unknown transition: ',fx);
+				opts.fxs.splice(i,1);
+				i--;
+			}
+		}
+		// if we have an empty list then we threw everything away!
+		if (!opts.fxs.length) {
+			log('No valid transitions named; slideshow terminating.');
+			return false;
+		}
+	}
+	else if (opts.fx == 'all') {  // auto-gen the list of transitions
+		opts.multiFx = true;
+		opts.fxs = [];
+		for (p in txs) {
+			tx = txs[p];
+			if (txs.hasOwnProperty(p) && $.isFunction(tx))
+				opts.fxs.push(p);
+		}
+	}
+	if (opts.multiFx && opts.randomizeEffects) {
+		// munge the fxs array to make effect selection random
+		var r1 = Math.floor(Math.random() * 20) + 30;
+		for (i = 0; i < r1; i++) {
+			var r2 = Math.floor(Math.random() * opts.fxs.length);
+			opts.fxs.push(opts.fxs.splice(r2,1)[0]);
+		}
+		debug('randomized fx sequence: ',opts.fxs);
+	}
+	return true;
+};
+
+// provide a mechanism for adding slides after the slideshow has started
+function exposeAddSlide(opts, els) {
+	opts.addSlide = function(newSlide, prepend) {
+		var $s = $(newSlide), s = $s[0];
+		if (!opts.autostopCount)
+			opts.countdown++;
+		els[prepend?'unshift':'push'](s);
+		if (opts.els)
+			opts.els[prepend?'unshift':'push'](s); // shuffle needs this
+		opts.slideCount = els.length;
+
+		$s.css('position','absolute');
+		$s[prepend?'prependTo':'appendTo'](opts.$cont);
+
+		if (prepend) {
+			opts.currSlide++;
+			opts.nextSlide++;
+		}
+
+		if (!$.support.opacity && opts.cleartype && !opts.cleartypeNoBg)
+			clearTypeFix($s);
+
+		if (opts.fit && opts.width)
+			$s.width(opts.width);
+		if (opts.fit && opts.height && opts.height != 'auto')
+			$slides.height(opts.height);
+		s.cycleH = (opts.fit && opts.height) ? opts.height : $s.height();
+		s.cycleW = (opts.fit && opts.width) ? opts.width : $s.width();
+
+		$s.css(opts.cssBefore);
+
+		if (opts.pager || opts.pagerAnchorBuilder)
+			$.fn.cycle.createPagerAnchor(els.length-1, s, $(opts.pager), els, opts);
+
+		if ($.isFunction(opts.onAddSlide))
+			opts.onAddSlide($s);
+		else
+			$s.hide(); // default behavior
+	};
+}
+
+// reset internal state; we do this on every pass in order to support multiple effects
+$.fn.cycle.resetState = function(opts, fx) {
+	fx = fx || opts.fx;
+	opts.before = []; opts.after = [];
+	opts.cssBefore = $.extend({}, opts.original.cssBefore);
+	opts.cssAfter  = $.extend({}, opts.original.cssAfter);
+	opts.animIn	= $.extend({}, opts.original.animIn);
+	opts.animOut   = $.extend({}, opts.original.animOut);
+	opts.fxFn = null;
+	$.each(opts.original.before, function() { opts.before.push(this); });
+	$.each(opts.original.after,  function() { opts.after.push(this); });
+
+	// re-init
+	var init = $.fn.cycle.transitions[fx];
+	if ($.isFunction(init))
+		init(opts.$cont, $(opts.elements), opts);
+};
+
+// this is the main engine fn, it handles the timeouts, callbacks and slide index mgmt
+function go(els, opts, manual, fwd) {
+	// opts.busy is true if we're in the middle of an animation
+	if (manual && opts.busy && opts.manualTrump) {
+		// let manual transitions requests trump active ones
+		$(els).stop(true,true);
+		opts.busy = false;
+	}
+	// don't begin another timeout-based transition if there is one active
+	if (opts.busy)
+		return;
+
+	var p = opts.$cont[0], curr = els[opts.currSlide], next = els[opts.nextSlide];
+
+	// stop cycling if we have an outstanding stop request
+	if (p.cycleStop != opts.stopCount || p.cycleTimeout === 0 && !manual)
+		return;
+
+	// check to see if we should stop cycling based on autostop options
+	if (!manual && !p.cyclePause &&
+		((opts.autostop && (--opts.countdown <= 0)) ||
+		(opts.nowrap && !opts.random && opts.nextSlide < opts.currSlide))) {
+		if (opts.end)
+			opts.end(opts);
+		return;
+	}
+
+	// if slideshow is paused, only transition on a manual trigger
+	if ((manual || !p.cyclePause) && (opts.nextSlide != opts.currSlide)) {
+		var fx = opts.fx;
+		// keep trying to get the slide size if we don't have it yet
+		curr.cycleH = curr.cycleH || $(curr).height();
+		curr.cycleW = curr.cycleW || $(curr).width();
+		next.cycleH = next.cycleH || $(next).height();
+		next.cycleW = next.cycleW || $(next).width();
+
+		// support multiple transition types
+		if (opts.multiFx) {
+			if (opts.lastFx == undefined || ++opts.lastFx >= opts.fxs.length)
+				opts.lastFx = 0;
+			fx = opts.fxs[opts.lastFx];
+			opts.currFx = fx;
+		}
+
+		// one-time fx overrides apply to:  $('div').cycle(3,'zoom');
+		if (opts.oneTimeFx) {
+			fx = opts.oneTimeFx;
+			opts.oneTimeFx = null;
+		}
+
+		$.fn.cycle.resetState(opts, fx);
+
+		// run the before callbacks
+		if (opts.before.length)
+			$.each(opts.before, function(i,o) {
+				if (p.cycleStop != opts.stopCount) return;
+				o.apply(next, [curr, next, opts, fwd]);
+			});
+
+		// stage the after callacks
+		var after = function() {
+			$.each(opts.after, function(i,o) {
+				if (p.cycleStop != opts.stopCount) return;
+				o.apply(next, [curr, next, opts, fwd]);
+			});
+		};
+
+		// get ready to perform the transition
+		opts.busy = 1;
+		if (opts.fxFn) // fx function provided?
+			opts.fxFn(curr, next, opts, after, fwd);
+		else if ($.isFunction($.fn.cycle[opts.fx])) // fx plugin ?
+			$.fn.cycle[opts.fx](curr, next, opts, after);
+		else
+			$.fn.cycle.custom(curr, next, opts, after, manual && opts.fastOnEvent);
+
+		// calculate the next slide
+		opts.lastSlide = opts.currSlide;
+		if (opts.random) {
+			opts.currSlide = opts.nextSlide;
+			if (++opts.randomIndex == els.length)
+				opts.randomIndex = 0;
+			opts.nextSlide = opts.randomMap[opts.randomIndex];
+		}
+		else { // sequence
+			var roll = (opts.nextSlide + 1) == els.length;
+			opts.nextSlide = roll ? 0 : opts.nextSlide+1;
+			opts.currSlide = roll ? els.length-1 : opts.nextSlide-1;
+		}
+
+		if (opts.pager)
+			opts.updateActivePagerLink(opts.pager, opts.currSlide, opts.activePagerClass);
+	}
+
+	// stage the next transition
+	var ms = 0;
+	if (opts.timeout && !opts.continuous)
+		ms = getTimeout(curr, next, opts, fwd);
+	else if (opts.continuous && p.cyclePause) // continuous shows work off an after callback, not this timer logic
+		ms = 10;
+	if (ms > 0)
+		p.cycleTimeout = setTimeout(function(){ go(els, opts, 0, !opts.rev) }, ms);
+};
+
+// invoked after transition
+$.fn.cycle.updateActivePagerLink = function(pager, currSlide, clsName) {
+	$(pager).each(function() {
+		$(this).find('a').removeClass(clsName).filter('a:eq('+currSlide+')').addClass(clsName);
+	});
+};
+
+// calculate timeout value for current transition
+function getTimeout(curr, next, opts, fwd) {
+	if (opts.timeoutFn) {
+		// call user provided calc fn
+		var t = opts.timeoutFn(curr,next,opts,fwd);
+		while ((t - opts.speed) < 250) // sanitize timeout
+			t += opts.speed;
+		debug('calculated timeout: ' + t + '; speed: ' + opts.speed);
+		if (t !== false)
+			return t;
+	}
+	return opts.timeout;
+};
+
+// expose next/prev function, caller must pass in state
+$.fn.cycle.next = function(opts) { advance(opts, opts.rev?-1:1); };
+$.fn.cycle.prev = function(opts) { advance(opts, opts.rev?1:-1);};
+
+// advance slide forward or back
+function advance(opts, val) {
+	var els = opts.elements;
+	var p = opts.$cont[0], timeout = p.cycleTimeout;
+	if (timeout) {
+		clearTimeout(timeout);
+		p.cycleTimeout = 0;
+	}
+	if (opts.random && val < 0) {
+		// move back to the previously display slide
+		opts.randomIndex--;
+		if (--opts.randomIndex == -2)
+			opts.randomIndex = els.length-2;
+		else if (opts.randomIndex == -1)
+			opts.randomIndex = els.length-1;
+		opts.nextSlide = opts.randomMap[opts.randomIndex];
+	}
+	else if (opts.random) {
+		opts.nextSlide = opts.randomMap[opts.randomIndex];
+	}
+	else {
+		opts.nextSlide = opts.currSlide + val;
+		if (opts.nextSlide < 0) {
+			if (opts.nowrap) return false;
+			opts.nextSlide = els.length - 1;
+		}
+		else if (opts.nextSlide >= els.length) {
+			if (opts.nowrap) return false;
+			opts.nextSlide = 0;
+		}
+	}
+
+	if ($.isFunction(opts.prevNextClick))
+		opts.prevNextClick(val > 0, opts.nextSlide, els[opts.nextSlide]);
+	go(els, opts, 1, val>=0);
+	return false;
+};
+
+function buildPager(els, opts) {
+	var $p = $(opts.pager);
+	$.each(els, function(i,o) {
+		$.fn.cycle.createPagerAnchor(i,o,$p,els,opts);
+	});
+	opts.updateActivePagerLink(opts.pager, opts.startingSlide, opts.activePagerClass);
+};
+
+$.fn.cycle.createPagerAnchor = function(i, el, $p, els, opts) {
+	var a;
+	if ($.isFunction(opts.pagerAnchorBuilder))
+		a = opts.pagerAnchorBuilder(i,el);
+	else
+		a = '<a href="#">'+(i+1)+'</a>';
+
+	if (!a)
+		return;
+	var $a = $(a);
+	// don't reparent if anchor is in the dom
+	if ($a.parents('body').length === 0) {
+		var arr = [];
+		if ($p.length > 1) {
+			$p.each(function() {
+				var $clone = $a.clone(true);
+				$(this).append($clone);
+				arr.push($clone[0]);
+			});
+			$a = $(arr);
+		}
+		else {
+			$a.appendTo($p);
+		}
+	}
+
+	opts.pagerAnchors =  opts.pagerAnchors || [];
+	opts.pagerAnchors.push($a);
+	$a.bind(opts.pagerEvent, function(e) {
+		e.preventDefault();
+		opts.nextSlide = i;
+		var p = opts.$cont[0], timeout = p.cycleTimeout;
+		if (timeout) {
+			clearTimeout(timeout);
+			p.cycleTimeout = 0;
+		}
+		if ($.isFunction(opts.pagerClick))
+			opts.pagerClick(opts.nextSlide, els[opts.nextSlide]);
+		go(els,opts,1,opts.currSlide < i); // trigger the trans
+//		return false;
+	});
+
+	if ( ! /^click/.test(opts.pagerEvent) && !opts.allowPagerClickBubble)
+		$a.bind('click.cycle', function(){return false;}); // supress click
+
+	if (opts.pauseOnPagerHover)
+		$a.hover(function() { opts.$cont[0].cyclePause++; }, function() { opts.$cont[0].cyclePause--; } );
+};
+
+// helper fn to calculate the number of slides between the current and the next
+$.fn.cycle.hopsFromLast = function(opts, fwd) {
+	var hops, l = opts.lastSlide, c = opts.currSlide;
+	if (fwd)
+		hops = c > l ? c - l : opts.slideCount - l;
+	else
+		hops = c < l ? l - c : l + opts.slideCount - c;
+	return hops;
+};
+
+// fix clearType problems in ie6 by setting an explicit bg color
+// (otherwise text slides look horrible during a fade transition)
+function clearTypeFix($slides) {
+	function hex(s) {
+		s = parseInt(s).toString(16);
+		return s.length < 2 ? '0'+s : s;
+	};
+	function getBg(e) {
+		for ( ; e && e.nodeName.toLowerCase() != 'html'; e = e.parentNode) {
+			var v = $.css(e,'background-color');
+			if (v.indexOf('rgb') >= 0 ) {
+				var rgb = v.match(/\d+/g);
+				return '#'+ hex(rgb[0]) + hex(rgb[1]) + hex(rgb[2]);
+			}
+			if (v && v != 'transparent')
+				return v;
+		}
+		return '#ffffff';
+	};
+	$slides.each(function() { $(this).css('background-color', getBg(this)); });
+};
+
+// reset common props before the next transition
+$.fn.cycle.commonReset = function(curr,next,opts,w,h,rev) {
+	$(opts.elements).not(curr).hide();
+	opts.cssBefore.opacity = 1;
+	opts.cssBefore.display = 'block';
+	if (w !== false && next.cycleW > 0)
+		opts.cssBefore.width = next.cycleW;
+	if (h !== false && next.cycleH > 0)
+		opts.cssBefore.height = next.cycleH;
+	opts.cssAfter = opts.cssAfter || {};
+	opts.cssAfter.display = 'none';
+	$(curr).css('zIndex',opts.slideCount + (rev === true ? 1 : 0));
+	$(next).css('zIndex',opts.slideCount + (rev === true ? 0 : 1));
+};
+
+// the actual fn for effecting a transition
+$.fn.cycle.custom = function(curr, next, opts, cb, speedOverride) {
+	var $l = $(curr), $n = $(next);
+	var speedIn = opts.speedIn, speedOut = opts.speedOut, easeIn = opts.easeIn, easeOut = opts.easeOut;
+	$n.css(opts.cssBefore);
+	if (speedOverride) {
+		if (typeof speedOverride == 'number')
+			speedIn = speedOut = speedOverride;
+		else
+			speedIn = speedOut = 1;
+		easeIn = easeOut = null;
+	}
+	var fn = function() {$n.animate(opts.animIn, speedIn, easeIn, cb)};
+	$l.animate(opts.animOut, speedOut, easeOut, function() {
+		if (opts.cssAfter) $l.css(opts.cssAfter);
+		if (!opts.sync) fn();
+	});
+	if (opts.sync) fn();
+};
+
+// transition definitions - only fade is defined here, transition pack defines the rest
+$.fn.cycle.transitions = {
+	fade: function($cont, $slides, opts) {
+		$slides.not(':eq('+opts.currSlide+')').css('opacity',0);
+		opts.before.push(function(curr,next,opts) {
+			$.fn.cycle.commonReset(curr,next,opts);
+			opts.cssBefore.opacity = 0;
+		});
+		opts.animIn	   = { opacity: 1 };
+		opts.animOut   = { opacity: 0 };
+		opts.cssBefore = { top: 0, left: 0 };
+	}
+};
+
+$.fn.cycle.ver = function() { return ver; };
+
+// override these globally if you like (they are all optional)
+$.fn.cycle.defaults = {
+	fx:			  'fade', // name of transition effect (or comma separated names, ex: fade,scrollUp,shuffle)
+	timeout:	   4000,  // milliseconds between slide transitions (0 to disable auto advance)
+	timeoutFn:     null,  // callback for determining per-slide timeout value:  function(currSlideElement, nextSlideElement, options, forwardFlag)
+	continuous:	   0,	  // true to start next transition immediately after current one completes
+	speed:		   1000,  // speed of the transition (any valid fx speed value)
+	speedIn:	   null,  // speed of the 'in' transition
+	speedOut:	   null,  // speed of the 'out' transition
+	next:		   null,  // selector for element to use as click trigger for next slide
+	prev:		   null,  // selector for element to use as click trigger for previous slide
+	prevNextClick: null,  // callback fn for prev/next clicks:	function(isNext, zeroBasedSlideIndex, slideElement)
+	prevNextEvent:'click.cycle',// event which drives the manual transition to the previous or next slide
+	pager:		   null,  // selector for element to use as pager container
+	pagerClick:	   null,  // callback fn for pager clicks:	function(zeroBasedSlideIndex, slideElement)
+	pagerEvent:	  'click.cycle', // name of event which drives the pager navigation
+	allowPagerClickBubble: false, // allows or prevents click event on pager anchors from bubbling
+	pagerAnchorBuilder: null, // callback fn for building anchor links:  function(index, DOMelement)
+	before:		   null,  // transition callback (scope set to element to be shown):	 function(currSlideElement, nextSlideElement, options, forwardFlag)
+	after:		   null,  // transition callback (scope set to element that was shown):  function(currSlideElement, nextSlideElement, options, forwardFlag)
+	end:		   null,  // callback invoked when the slideshow terminates (use with autostop or nowrap options): function(options)
+	easing:		   null,  // easing method for both in and out transitions
+	easeIn:		   null,  // easing for "in" transition
+	easeOut:	   null,  // easing for "out" transition
+	shuffle:	   null,  // coords for shuffle animation, ex: { top:15, left: 200 }
+	animIn:		   null,  // properties that define how the slide animates in
+	animOut:	   null,  // properties that define how the slide animates out
+	cssBefore:	   null,  // properties that define the initial state of the slide before transitioning in
+	cssAfter:	   null,  // properties that defined the state of the slide after transitioning out
+	fxFn:		   null,  // function used to control the transition: function(currSlideElement, nextSlideElement, options, afterCalback, forwardFlag)
+	height:		  'auto', // container height
+	startingSlide: 0,	  // zero-based index of the first slide to be displayed
+	sync:		   1,	  // true if in/out transitions should occur simultaneously
+	random:		   0,	  // true for random, false for sequence (not applicable to shuffle fx)
+	fit:		   0,	  // force slides to fit container
+	containerResize: 1,	  // resize container to fit largest slide
+	pause:		   0,	  // true to enable "pause on hover"
+	pauseOnPagerHover: 0, // true to pause when hovering over pager link
+	autostop:	   0,	  // true to end slideshow after X transitions (where X == slide count)
+	autostopCount: 0,	  // number of transitions (optionally used with autostop to define X)
+	delay:		   0,	  // additional delay (in ms) for first transition (hint: can be negative)
+	slideExpr:	   null,  // expression for selecting slides (if something other than all children is required)
+	cleartype:	   !$.support.opacity,  // true if clearType corrections should be applied (for IE)
+	cleartypeNoBg: false, // set to true to disable extra cleartype fixing (leave false to force background color setting on slides)
+	nowrap:		   0,	  // true to prevent slideshow from wrapping
+	fastOnEvent:   0,	  // force fast transitions when triggered manually (via pager or prev/next); value == time in ms
+	randomizeEffects: 1,  // valid when multiple effects are used; true to make the effect sequence random
+	rev:		   0,	 // causes animations to transition in reverse
+	manualTrump:   true,  // causes manual transition to stop an active transition instead of being ignored
+	requeueOnImageNotLoaded: true, // requeue the slideshow if any image slides are not yet loaded
+	requeueTimeout: 250,  // ms delay for requeue
+	activePagerClass: 'activeSlide', // class name used for the active pager link
+	updateActivePagerLink: null // callback fn invoked to update the active pager link (adds/removes activePagerClass style)
+};
+
+})(jQuery);
+
+
+/*!
+ * jQuery Cycle Plugin Transition Definitions
+ * This script is a plugin for the jQuery Cycle Plugin
+ * Examples and documentation at: http://malsup.com/jquery/cycle/
+ * Copyright (c) 2007-2008 M. Alsup
+ * Version:	 2.72
+ * Dual licensed under the MIT and GPL licenses:
+ * http://www.opensource.org/licenses/mit-license.php
+ * http://www.gnu.org/licenses/gpl.html
+ */
+(function($) {
+
+//
+// These functions define one-time slide initialization for the named
+// transitions. To save file size feel free to remove any of these that you
+// don't need.
+//
+$.fn.cycle.transitions.none = function($cont, $slides, opts) {
+	opts.fxFn = function(curr,next,opts,after){
+		opts.cssBefore = { top: 0, left: 0 };
+		$.fn.cycle.commonReset(curr,next,opts);
+		$(next).css(opts.cssBefore);
+		$(next).show();
+		$(curr).hide();
+		if (opts.cssAfter) $(curr).css(opts.cssAfter);
+		after();
+	};
+}
+
+// scrollUp/Down/Left/Right
+$.fn.cycle.transitions.scrollUp = function($cont, $slides, opts) {
+	$cont.css('overflow','hidden');
+	opts.before.push($.fn.cycle.commonReset);
+	var h = $cont.height();
+	opts.cssBefore ={ top: h, left: 0 };
+	opts.cssFirst = { top: 0 };
+	opts.animIn	  = { top: 0 };
+	opts.animOut  = { top: -h };
+};
+$.fn.cycle.transitions.scrollDown = function($cont, $slides, opts) {
+	$cont.css('overflow','hidden');
+	opts.before.push($.fn.cycle.commonReset);
+	var h = $cont.height();
+	opts.cssFirst = { top: 0 };
+	opts.cssBefore= { top: -h, left: 0 };
+	opts.animIn	  = { top: 0 };
+	opts.animOut  = { top: h };
+};
+$.fn.cycle.transitions.scrollLeft = function($cont, $slides, opts) {
+	$cont.css('overflow','hidden');
+	opts.before.push($.fn.cycle.commonReset);
+	var w = $cont.width();
+	opts.cssFirst = { left: 0 };
+	opts.cssBefore= { left: w, top: 0 };
+	opts.animIn	  = { left: 0 };
+	opts.animOut  = { left: 0-w };
+};
+$.fn.cycle.transitions.scrollRight = function($cont, $slides, opts) {
+	$cont.css('overflow','hidden');
+	opts.before.push($.fn.cycle.commonReset);
+	var w = $cont.width();
+	opts.cssFirst = { left: 0 };
+	opts.cssBefore= { left: -w, top: 0 };
+	opts.animIn	  = { left: 0 };
+	opts.animOut  = { left: w };
+};
+$.fn.cycle.transitions.scrollHorz = function($cont, $slides, opts) {
+	$cont.css('overflow','hidden').width();
+	opts.before.push(function(curr, next, opts, fwd) {
+		$.fn.cycle.commonReset(curr,next,opts);
+		opts.cssBefore.left = fwd ? (next.cycleW-1) : (1-next.cycleW);
+		opts.animOut.left = fwd ? -curr.cycleW : curr.cycleW;
+	});
+	opts.cssFirst = { left: 0 };
+	opts.cssBefore= { top: 0 };
+	opts.animIn   = { left: 0 };
+	opts.animOut  = { top: 0 };
+};
+$.fn.cycle.transitions.scrollVert = function($cont, $slides, opts) {
+	$cont.css('overflow','hidden');
+	opts.before.push(function(curr, next, opts, fwd) {
+		$.fn.cycle.commonReset(curr,next,opts);
+		opts.cssBefore.top = fwd ? (1-next.cycleH) : (next.cycleH-1);
+		opts.animOut.top = fwd ? curr.cycleH : -curr.cycleH;
+	});
+	opts.cssFirst = { top: 0 };
+	opts.cssBefore= { left: 0 };
+	opts.animIn   = { top: 0 };
+	opts.animOut  = { left: 0 };
+};
+
+// slideX/slideY
+$.fn.cycle.transitions.slideX = function($cont, $slides, opts) {
+	opts.before.push(function(curr, next, opts) {
+		$(opts.elements).not(curr).hide();
+		$.fn.cycle.commonReset(curr,next,opts,false,true);
+		opts.animIn.width = next.cycleW;
+	});
+	opts.cssBefore = { left: 0, top: 0, width: 0 };
+	opts.animIn	 = { width: 'show' };
+	opts.animOut = { width: 0 };
+};
+$.fn.cycle.transitions.slideY = function($cont, $slides, opts) {
+	opts.before.push(function(curr, next, opts) {
+		$(opts.elements).not(curr).hide();
+		$.fn.cycle.commonReset(curr,next,opts,true,false);
+		opts.animIn.height = next.cycleH;
+	});
+	opts.cssBefore = { left: 0, top: 0, height: 0 };
+	opts.animIn	 = { height: 'show' };
+	opts.animOut = { height: 0 };
+};
+
+// shuffle
+$.fn.cycle.transitions.shuffle = function($cont, $slides, opts) {
+	var i, w = $cont.css('overflow', 'visible').width();
+	$slides.css({left: 0, top: 0});
+	opts.before.push(function(curr,next,opts) {
+		$.fn.cycle.commonReset(curr,next,opts,true,true,true);
+	});
+	// only adjust speed once!
+	if (!opts.speedAdjusted) {
+		opts.speed = opts.speed / 2; // shuffle has 2 transitions
+		opts.speedAdjusted = true;
+	}
+	opts.random = 0;
+	opts.shuffle = opts.shuffle || {left:-w, top:15};
+	opts.els = [];
+	for (i=0; i < $slides.length; i++)
+		opts.els.push($slides[i]);
+
+	for (i=0; i < opts.currSlide; i++)
+		opts.els.push(opts.els.shift());
+
+	// custom transition fn (hat tip to Benjamin Sterling for this bit of sweetness!)
+	opts.fxFn = function(curr, next, opts, cb, fwd) {
+		var $el = fwd ? $(curr) : $(next);
+		$(next).css(opts.cssBefore);
+		var count = opts.slideCount;
+		$el.animate(opts.shuffle, opts.speedIn, opts.easeIn, function() {
+			var hops = $.fn.cycle.hopsFromLast(opts, fwd);
+			for (var k=0; k < hops; k++)
+				fwd ? opts.els.push(opts.els.shift()) : opts.els.unshift(opts.els.pop());
+			if (fwd) {
+				for (var i=0, len=opts.els.length; i < len; i++)
+					$(opts.els[i]).css('z-index', len-i+count);
+			}
+			else {
+				var z = $(curr).css('z-index');
+				$el.css('z-index', parseInt(z)+1+count);
+			}
+			$el.animate({left:0, top:0}, opts.speedOut, opts.easeOut, function() {
+				$(fwd ? this : curr).hide();
+				if (cb) cb();
+			});
+		});
+	};
+	opts.cssBefore = { display: 'block', opacity: 1, top: 0, left: 0 };
+};
+
+// turnUp/Down/Left/Right
+$.fn.cycle.transitions.turnUp = function($cont, $slides, opts) {
+	opts.before.push(function(curr, next, opts) {
+		$.fn.cycle.commonReset(curr,next,opts,true,false);
+		opts.cssBefore.top = next.cycleH;
+		opts.animIn.height = next.cycleH;
+	});
+	opts.cssFirst  = { top: 0 };
+	opts.cssBefore = { left: 0, height: 0 };
+	opts.animIn	   = { top: 0 };
+	opts.animOut   = { height: 0 };
+};
+$.fn.cycle.transitions.turnDown = function($cont, $slides, opts) {
+	opts.before.push(function(curr, next, opts) {
+		$.fn.cycle.commonReset(curr,next,opts,true,false);
+		opts.animIn.height = next.cycleH;
+		opts.animOut.top   = curr.cycleH;
+	});
+	opts.cssFirst  = { top: 0 };
+	opts.cssBefore = { left: 0, top: 0, height: 0 };
+	opts.animOut   = { height: 0 };
+};
+$.fn.cycle.transitions.turnLeft = function($cont, $slides, opts) {
+	opts.before.push(function(curr, next, opts) {
+		$.fn.cycle.commonReset(curr,next,opts,false,true);
+		opts.cssBefore.left = next.cycleW;
+		opts.animIn.width = next.cycleW;
+	});
+	opts.cssBefore = { top: 0, width: 0  };
+	opts.animIn	   = { left: 0 };
+	opts.animOut   = { width: 0 };
+};
+$.fn.cycle.transitions.turnRight = function($cont, $slides, opts) {
+	opts.before.push(function(curr, next, opts) {
+		$.fn.cycle.commonReset(curr,next,opts,false,true);
+		opts.animIn.width = next.cycleW;
+		opts.animOut.left = curr.cycleW;
+	});
+	opts.cssBefore = { top: 0, left: 0, width: 0 };
+	opts.animIn	   = { left: 0 };
+	opts.animOut   = { width: 0 };
+};
+
+// zoom
+$.fn.cycle.transitions.zoom = function($cont, $slides, opts) {
+	opts.before.push(function(curr, next, opts) {
+		$.fn.cycle.commonReset(curr,next,opts,false,false,true);
+		opts.cssBefore.top = next.cycleH/2;
+		opts.cssBefore.left = next.cycleW/2;
+		opts.animIn	   = { top: 0, left: 0, width: next.cycleW, height: next.cycleH };
+		opts.animOut   = { width: 0, height: 0, top: curr.cycleH/2, left: curr.cycleW/2 };
+	});
+	opts.cssFirst = { top:0, left: 0 };
+	opts.cssBefore = { width: 0, height: 0 };
+};
+
+// fadeZoom
+$.fn.cycle.transitions.fadeZoom = function($cont, $slides, opts) {
+	opts.before.push(function(curr, next, opts) {
+		$.fn.cycle.commonReset(curr,next,opts,false,false);
+		opts.cssBefore.left = next.cycleW/2;
+		opts.cssBefore.top = next.cycleH/2;
+		opts.animIn	= { top: 0, left: 0, width: next.cycleW, height: next.cycleH };
+	});
+	opts.cssBefore = { width: 0, height: 0 };
+	opts.animOut  = { opacity: 0 };
+};
+
+// blindX
+$.fn.cycle.transitions.blindX = function($cont, $slides, opts) {
+	var w = $cont.css('overflow','hidden').width();
+	opts.before.push(function(curr, next, opts) {
+		$.fn.cycle.commonReset(curr,next,opts);
+		opts.animIn.width = next.cycleW;
+		opts.animOut.left   = curr.cycleW;
+	});
+	opts.cssBefore = { left: w, top: 0 };
+	opts.animIn = { left: 0 };
+	opts.animOut  = { left: w };
+};
+// blindY
+$.fn.cycle.transitions.blindY = function($cont, $slides, opts) {
+	var h = $cont.css('overflow','hidden').height();
+	opts.before.push(function(curr, next, opts) {
+		$.fn.cycle.commonReset(curr,next,opts);
+		opts.animIn.height = next.cycleH;
+		opts.animOut.top   = curr.cycleH;
+	});
+	opts.cssBefore = { top: h, left: 0 };
+	opts.animIn = { top: 0 };
+	opts.animOut  = { top: h };
+};
+// blindZ
+$.fn.cycle.transitions.blindZ = function($cont, $slides, opts) {
+	var h = $cont.css('overflow','hidden').height();
+	var w = $cont.width();
+	opts.before.push(function(curr, next, opts) {
+		$.fn.cycle.commonReset(curr,next,opts);
+		opts.animIn.height = next.cycleH;
+		opts.animOut.top   = curr.cycleH;
+	});
+	opts.cssBefore = { top: h, left: w };
+	opts.animIn = { top: 0, left: 0 };
+	opts.animOut  = { top: h, left: w };
+};
+
+// growX - grow horizontally from centered 0 width
+$.fn.cycle.transitions.growX = function($cont, $slides, opts) {
+	opts.before.push(function(curr, next, opts) {
+		$.fn.cycle.commonReset(curr,next,opts,false,true);
+		opts.cssBefore.left = this.cycleW/2;
+		opts.animIn = { left: 0, width: this.cycleW };
+		opts.animOut = { left: 0 };
+	});
+	opts.cssBefore = { width: 0, top: 0 };
+};
+// growY - grow vertically from centered 0 height
+$.fn.cycle.transitions.growY = function($cont, $slides, opts) {
+	opts.before.push(function(curr, next, opts) {
+		$.fn.cycle.commonReset(curr,next,opts,true,false);
+		opts.cssBefore.top = this.cycleH/2;
+		opts.animIn = { top: 0, height: this.cycleH };
+		opts.animOut = { top: 0 };
+	});
+	opts.cssBefore = { height: 0, left: 0 };
+};
+
+// curtainX - squeeze in both edges horizontally
+$.fn.cycle.transitions.curtainX = function($cont, $slides, opts) {
+	opts.before.push(function(curr, next, opts) {
+		$.fn.cycle.commonReset(curr,next,opts,false,true,true);
+		opts.cssBefore.left = next.cycleW/2;
+		opts.animIn = { left: 0, width: this.cycleW };
+		opts.animOut = { left: curr.cycleW/2, width: 0 };
+	});
+	opts.cssBefore = { top: 0, width: 0 };
+};
+// curtainY - squeeze in both edges vertically
+$.fn.cycle.transitions.curtainY = function($cont, $slides, opts) {
+	opts.before.push(function(curr, next, opts) {
+		$.fn.cycle.commonReset(curr,next,opts,true,false,true);
+		opts.cssBefore.top = next.cycleH/2;
+		opts.animIn = { top: 0, height: next.cycleH };
+		opts.animOut = { top: curr.cycleH/2, height: 0 };
+	});
+	opts.cssBefore = { left: 0, height: 0 };
+};
+
+// cover - curr slide covered by next slide
+$.fn.cycle.transitions.cover = function($cont, $slides, opts) {
+	var d = opts.direction || 'left';
+	var w = $cont.css('overflow','hidden').width();
+	var h = $cont.height();
+	opts.before.push(function(curr, next, opts) {
+		$.fn.cycle.commonReset(curr,next,opts);
+		if (d == 'right')
+			opts.cssBefore.left = -w;
+		else if (d == 'up')
+			opts.cssBefore.top = h;
+		else if (d == 'down')
+			opts.cssBefore.top = -h;
+		else
+			opts.cssBefore.left = w;
+	});
+	opts.animIn = { left: 0, top: 0};
+	opts.animOut = { opacity: 1 };
+	opts.cssBefore = { top: 0, left: 0 };
+};
+
+// uncover - curr slide moves off next slide
+$.fn.cycle.transitions.uncover = function($cont, $slides, opts) {
+	var d = opts.direction || 'left';
+	var w = $cont.css('overflow','hidden').width();
+	var h = $cont.height();
+	opts.before.push(function(curr, next, opts) {
+		$.fn.cycle.commonReset(curr,next,opts,true,true,true);
+		if (d == 'right')
+			opts.animOut.left = w;
+		else if (d == 'up')
+			opts.animOut.top = -h;
+		else if (d == 'down')
+			opts.animOut.top = h;
+		else
+			opts.animOut.left = -w;
+	});
+	opts.animIn = { left: 0, top: 0 };
+	opts.animOut = { opacity: 1 };
+	opts.cssBefore = { top: 0, left: 0 };
+};
+
+// toss - move top slide and fade away
+$.fn.cycle.transitions.toss = function($cont, $slides, opts) {
+	var w = $cont.css('overflow','visible').width();
+	var h = $cont.height();
+	opts.before.push(function(curr, next, opts) {
+		$.fn.cycle.commonReset(curr,next,opts,true,true,true);
+		// provide default toss settings if animOut not provided
+		if (!opts.animOut.left && !opts.animOut.top)
+			opts.animOut = { left: w*2, top: -h/2, opacity: 0 };
+		else
+			opts.animOut.opacity = 0;
+	});
+	opts.cssBefore = { left: 0, top: 0 };
+	opts.animIn = { left: 0 };
+};
+
+// wipe - clip animation
+$.fn.cycle.transitions.wipe = function($cont, $slides, opts) {
+	var w = $cont.css('overflow','hidden').width();
+	var h = $cont.height();
+	opts.cssBefore = opts.cssBefore || {};
+	var clip;
+	if (opts.clip) {
+		if (/l2r/.test(opts.clip))
+			clip = 'rect(0px 0px '+h+'px 0px)';
+		else if (/r2l/.test(opts.clip))
+			clip = 'rect(0px '+w+'px '+h+'px '+w+'px)';
+		else if (/t2b/.test(opts.clip))
+			clip = 'rect(0px '+w+'px 0px 0px)';
+		else if (/b2t/.test(opts.clip))
+			clip = 'rect('+h+'px '+w+'px '+h+'px 0px)';
+		else if (/zoom/.test(opts.clip)) {
+			var top = parseInt(h/2);
+			var left = parseInt(w/2);
+			clip = 'rect('+top+'px '+left+'px '+top+'px '+left+'px)';
+		}
+	}
+
+	opts.cssBefore.clip = opts.cssBefore.clip || clip || 'rect(0px 0px 0px 0px)';
+
+	var d = opts.cssBefore.clip.match(/(\d+)/g);
+	var t = parseInt(d[0]), r = parseInt(d[1]), b = parseInt(d[2]), l = parseInt(d[3]);
+
+	opts.before.push(function(curr, next, opts) {
+		if (curr == next) return;
+		var $curr = $(curr), $next = $(next);
+		$.fn.cycle.commonReset(curr,next,opts,true,true,false);
+		opts.cssAfter.display = 'block';
+
+		var step = 1, count = parseInt((opts.speedIn / 13)) - 1;
+		(function f() {
+			var tt = t ? t - parseInt(step * (t/count)) : 0;
+			var ll = l ? l - parseInt(step * (l/count)) : 0;
+			var bb = b < h ? b + parseInt(step * ((h-b)/count || 1)) : h;
+			var rr = r < w ? r + parseInt(step * ((w-r)/count || 1)) : w;
+			$next.css({ clip: 'rect('+tt+'px '+rr+'px '+bb+'px '+ll+'px)' });
+			(step++ <= count) ? setTimeout(f, 13) : $curr.css('display', 'none');
+		})();
+	});
+	opts.cssBefore = { display: 'block', opacity: 1, top: 0, left: 0 };
+	opts.animIn	   = { left: 0 };
+	opts.animOut   = { left: 0 };
+};
+
+})(jQuery);
diff --git a/public/js/onepage.js b/public/js/onepage.js
index 4382219ef..c1f3ad606 100644
--- a/public/js/onepage.js
+++ b/public/js/onepage.js
@@ -1,10 +1,5 @@
 function setupOnePage() {
   sh_highlightDocument('/js/sh_lang/', '.min.js')
   
-  $(".preso > .slide").each(function(s, elem) {
-    var slide_height = $(elem).height()
-    var mar_top = (0.5 * parseFloat($(elem).parent().height())) - (0.5 * parseFloat(slide_height))
-    $(elem).css('margin-top', mar_top)
-  })
-  
+  centerSlides($("#slides > .slide"))
 }
\ No newline at end of file
diff --git a/public/js/showoff.js b/public/js/showoff.js
index a99ade3b8..f96b62d63 100644
--- a/public/js/showoff.js
+++ b/public/js/showoff.js
@@ -4,6 +4,7 @@ var preso_started = false
 var slidenum = 0
 var slideTotal = 0
 var slides
+var currentSlide
 var totalslides = 0
 var slidesLoaded = false
 var incrSteps = 0
@@ -31,20 +32,56 @@ function setupPreso() {
 }
 
 function loadSlides() {
-  $('#slides').hide();
+  //load slides offscreen, wait for images and then initialize
   $("#slides").load("/slides", false, function(){
-    slides = $('#slides > .slide')
-    slideTotal = slides.size()
-    setupMenu()
-    if (slidesLoaded) {
-      showSlide()
-      alert('slides loaded')
-    } else {
-      showFirstSlide()
-      slidesLoaded = true
-    }
-    sh_highlightDocument('/js/sh_lang/', '.min.js')
-   })
+    $("#slides img").batchImageLoad({
+			loadingCompleteCallback: initializePresentation
+		})
+  })
+}
+
+function initializePresentation() {
+  //center slides offscreen
+  centerSlides($('#slides > .slide'))
+
+  //copy into presentation area
+  $("#preso").empty()
+  $('#slides > .slide').appendTo($("#preso"))
+
+  //populate vars
+  slides = $('#preso > .slide')
+  slideTotal = slides.size()
+
+  //setup manual jquery cycle
+  $('#preso').cycle({
+    timeout: 0
+  })
+
+  setupMenu()
+  if (slidesLoaded) {
+    showSlide()
+    alert('slides loaded')
+  } else {
+    showFirstSlide()
+    slidesLoaded = true
+  }
+  sh_highlightDocument('/js/sh_lang/', '.min.js')
+}
+
+function centerSlides(slides) {
+  slides.each(function(s, slide) {
+    centerSlide(slide)
+  })
+}
+
+function centerSlide(slide) {
+  var slide_content = $(slide).children(".content").first()
+  var height = slide_content.height()
+  var mar_top = (0.5 * parseFloat($(slide).height())) - (0.5 * parseFloat(height))
+  if (mar_top < 0) {
+    mar_top = 0
+  }
+  slide_content.css('margin-top', mar_top)
 }
 
 function setupMenu() {
@@ -52,16 +89,17 @@ function setupMenu() {
 
   var currSlide = 0
   var menu = new ListMenu()
-  
+
   slides.each(function(s, elem) {
-    shortTxt = $(elem).text().substr(0, 20)
-    path = $(elem).attr('ref').split('/')
+    content = $(elem).children(".content")
+    shortTxt = $(content).text().substr(0, 20)
+    path = $(content).attr('ref').split('/')
     currSlide += 1
     menu.addItem(path, shortTxt, currSlide)
   })
 
   $('#navigation').html(menu.getList())
-  $('#navmenu').menu({ 
+  $('#navmenu').menu({
     content: $('#navigation').html(),
     flyOut: true
   });
@@ -91,18 +129,13 @@ function showSlide(back_step) {
     return
   }
 
-  // TODO: calculate and set the height margins on slide load, not here
-
-  $("#preso").html(slides.eq(slidenum).clone())
-  if ($("#preso > .slide").is('.full-screen')) {
-    $("#preso").css('margin', 0);
-  } else {
-    curr_slide = $("#preso > .slide")
-    var slide_height = curr_slide.height()
-    var mar_top = (0.5 * parseFloat($("#preso").height())) - (0.5 * parseFloat(slide_height))
-    $("#preso").css('margin', "0 auto");
-    $("#preso > .slide").css('margin-top', mar_top)
+  currentSlide = slides.eq(slidenum)
+  var transition = currentSlide.attr('data-transition')
+  if (back_step) {
+    transition = 'none'
   }
+  $('#preso').cycle(slidenum, transition)
+
   percent = getSlidePercent()
   $("#slideInfo").text((slidenum + 1) + '/' + slideTotal + '  - ' + percent + '%')
 
@@ -127,11 +160,11 @@ function determineIncremental()
 {
   incrCurr = 0
   incrCode = false
-  incrElem = $("#preso > .incremental > ul > li")
+  incrElem = currentSlide.find(".incremental > ul > li")
   incrSteps = incrElem.size()
   if(incrSteps == 0) {
     // also look for commandline
-    incrElem = $("#preso > .incremental > pre > code > code")
+    incrElem = currentSlide.find(".incremental > pre > code > code")
     incrSteps = incrElem.size()
     incrCode = true
   }
@@ -162,7 +195,7 @@ function doDebugStuff()
     $('#debugInfo').show()
     debug('debug mode on')
   } else {
-    $('#debugInfo').hide()    
+    $('#debugInfo').hide()
   }
 }
 
@@ -259,7 +292,7 @@ function ListMenu(s)
       }
       newMenu.append(domItem)
     }
-    return newMenu      
+    return newMenu
   }
 }
 
@@ -271,7 +304,7 @@ function ListMenuItem(t, s)
 }
 
 var removeResults = function() {
-  $('.results').remove();	
+  $('.results').remove();
 };
 
 var print = function(text) {
diff --git a/showoff.gemspec b/showoff.gemspec
index 50c5e532d..aeee7336f 100644
--- a/showoff.gemspec
+++ b/showoff.gemspec
@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
   s.name              = "showoff"
-  s.version           = "0.1.0"
-  s.date              = "2010-01-26"
+  s.version           = "0.1.1"
+  s.date              = "2010-03-15"
   s.summary           = "The best damn presentation software a developer could ever love."
   s.homepage          = "http://github.com/schacon/showoff"
   s.email             = "schacon@gmail.com"
diff --git a/views/index.erb b/views/index.erb
index 207ba843b..d3d13f4d5 100644
--- a/views/index.erb
+++ b/views/index.erb
@@ -7,9 +7,12 @@
 
 	<title>Presentation</title>
 
+	<link rel="stylesheet" href="css/reset.css" type="text/css"/>
 	<link rel="stylesheet" href="css/showoff.css" type="text/css"/>
 
 	<script type="text/javascript" src="/js/jquery-1.4.min.js"></script>
+	<script type="text/javascript" src="/js/jquery.cycle.all.js"></script>
+	<script type="text/javascript" src="/js/jquery.batchImageLoad.js"></script>
 	<script type="text/javascript" src="/js/jquery-print.js"></script>	
   <script type="text/javascript" src="/js/fg.menu.js"></script> 
 	<script type="text/javascript" src="/js/showoff.js"></script>
@@ -30,8 +33,8 @@
   <% end %>
 
   <script type="text/javascript">
-  $(function(){
-    setupPreso()
+  $(document).ready(function() {
+    setupPreso();
   });
   </script>
 </head>
@@ -59,7 +62,7 @@
   <span id="debugInfo"></span>
 </div>
 
-<div id="slides"></div>
+<div id="slides" class="offscreen"></div>
 
 </body>
 </html>
diff --git a/views/onepage.erb b/views/onepage.erb
index d76cbd60a..28430cbc8 100644
--- a/views/onepage.erb
+++ b/views/onepage.erb
@@ -12,7 +12,7 @@
   <% else %>
     <%= inline_css(['onepage.css'], 'public/css') %>
   <% end %>
-  <%= inline_css(['showoff.css', 'theme/ui.all.css', 'sh_style.css'], 'public/css') %>
+  <%= inline_css(['reset.css', 'showoff.css', 'theme/ui.all.css', 'sh_style.css'], 'public/css') %>
   <% css_files.each do |css_file| %>
     <%= inline_css(css_file) %>
   <% end %>
@@ -20,7 +20,7 @@
   <% if !@no_js %>
     <%= inline_js(['jquery-1.4.min.js', 'jquery-print.js', 'showoff.js', 'onepage.js', 'sh_main.min.js'], 'public/js') %>
     <script type="text/javascript">
-    $(function(){
+    $(document).ready(function() {
       setupOnePage()
     });
     </script>