diff --git a/world/scratch/jsworld/compiled/define-effect_rkt.dep b/world/scratch/jsworld/compiled/define-effect_rkt.dep
new file mode 100644
index 0000000..9caa623
--- /dev/null
+++ b/world/scratch/jsworld/compiled/define-effect_rkt.dep
@@ -0,0 +1 @@
+("5.1.1" ("7f57f25a3f0077a7b31ba24f7b5dbfc789ba7d1e" . "ff5c04401e157808d662a002dabdfdb12aa66314") (collects #"racket" #"base.rkt") #"/home/dyoo/work/js-vm/jsworld/../lang/base.rkt" #"/home/dyoo/work/js-vm/jsworld/jsworld.rkt" (collects #"s-exp" #"lang" #"reader.rkt"))
diff --git a/world/scratch/jsworld/compiled/define-effect_rkt.zo b/world/scratch/jsworld/compiled/define-effect_rkt.zo
new file mode 100644
index 0000000..ba69883
Binary files /dev/null and b/world/scratch/jsworld/compiled/define-effect_rkt.zo differ
diff --git a/world/scratch/jsworld/compiled/jsworld_rkt.dep b/world/scratch/jsworld/compiled/jsworld_rkt.dep
new file mode 100644
index 0000000..556edb6
--- /dev/null
+++ b/world/scratch/jsworld/compiled/jsworld_rkt.dep
@@ -0,0 +1 @@
+("5.1.1" ("95136ed093c9b56fe70118d153ccf5c246e76401" . "61cbeb742f46f0d5b7bd52121d6f3b0a872cdfeb") #"/home/dyoo/work/js-vm/jsworld/../lang/js-impl/js-impl.rkt" #"/home/dyoo/work/js-vm/jsworld/../world/kernel.rkt" #"/home/dyoo/work/js-vm/jsworld/../image/image.rkt" (collects #"s-exp" #"lang" #"reader.rkt"))
diff --git a/world/scratch/jsworld/compiled/jsworld_rkt.zo b/world/scratch/jsworld/compiled/jsworld_rkt.zo
new file mode 100644
index 0000000..c18cd47
Binary files /dev/null and b/world/scratch/jsworld/compiled/jsworld_rkt.zo differ
diff --git a/world/scratch/jsworld/define-effect.rkt b/world/scratch/jsworld/define-effect.rkt
new file mode 100644
index 0000000..0b4e8f9
--- /dev/null
+++ b/world/scratch/jsworld/define-effect.rkt
@@ -0,0 +1,82 @@
+#lang s-exp "../lang/base.rkt"
+
+(require "jsworld.rkt")
+
+(require (for-syntax racket/base))
+
+(provide define-effect)
+
+(define-syntax (define-effect stx)
+  (syntax-case stx ()
+
+    [(_ name (field ...) #:impl impl)
+     (identifier? #'name)
+     (syntax/loc stx 
+       (define-effect (name #f) (field ...) #:impl impl))]
+
+    [(_ (name supertype) (field ...) #:impl impl)
+     (with-syntax ([field-count 
+                    (length (syntax->list #'(field ...)))]
+                   [struct:name 
+                    (datum->syntax #'name 
+                                   (string->symbol 
+                                    (format "struct:~a"
+                                            (syntax-e #'name))))]
+                   [make-name
+                    (datum->syntax #'name
+                                   (string->symbol
+                                    (format "make-~a"
+                                            (syntax-e #'name))))]
+                   [name? 
+                    (datum->syntax #'name 
+                                   (string->symbol 
+                                    (format "~a?"
+                                            (syntax-e #'name))))]
+                   [(field-index ...)
+                    (build-list (length (syntax->list
+                                         #'(field ...))) 
+                                (lambda (i) i))]
+                   [(accessor ...)
+                    (map (lambda (field)
+                           (datum->syntax
+                            field
+                            (string->symbol 
+                             (format "~a-~a"
+                                     (syntax-e #'name)
+                                     (syntax-e field)))))
+                         (syntax->list #'(field ...)))]
+
+                   [(mutator ...)
+                    (map (lambda (field)
+                           (datum->syntax
+                            field
+                            (string->symbol 
+                             (format "set-~a-~a!"
+                                     (syntax-e #'name)
+                                     (syntax-e field)))))
+                         (syntax->list #'(field ...)))])
+       
+       (syntax/loc stx
+         (begin (define-values (struct:name
+                                make-name
+                                name?
+                                name-accessor
+                                name-mutator)
+                  (make-effect-type 'name 
+                                    supertype
+                                    field-count
+                                    impl))
+                (begin 
+                    (define accessor 
+                      (make-struct-field-accessor
+                       name-accessor field-index 'field)) 
+                    ...)
+                
+                (begin 
+                  (define mutator 
+                    (make-struct-field-mutator 
+                     name-mutator field-index 'field)) 
+                  ...)
+                
+                )))]))                                   
+    
\ No newline at end of file
diff --git a/world/scratch/jsworld/jsworld.js b/world/scratch/jsworld/jsworld.js
new file mode 100644
index 0000000..748ee1e
--- /dev/null
+++ b/world/scratch/jsworld/jsworld.js
@@ -0,0 +1,1396 @@
+
+/************************
+ *** World Primitives ***
+ ************************/
+
+var PrimProc = types.PrimProc;
+var CasePrimitive = types.CasePrimitive;
+var makeOptionPrimitive = types.makeOptionPrimitive;
+var checkListOf = helpers.checkListOf;
+var procArityContains = helpers.procArityContains;
+var raise = helpers.raise;
+
+
+var makeCaller = function(aState) {
+    return function(operator, operands, k, callSite) {
+	interpret.call(aState, operator, operands, k, aState.onFail, callSite);
+    };
+};
+
+
+
+
+// Every world configuration function (on-tick, stop-when, ...)
+// produces a WorldConfigOption instance.
+var WorldConfigOption = function(name) {
+    this.name = name;	    
+};
+
+WorldConfigOption.prototype.configure = function(config) {
+    raise(types.incompleteExn(
+	types.exnFailContract,
+	'unimplemented WorldConfigOption',
+	[]));
+};
+
+WorldConfigOption.prototype.toDomNode = function(cache) {  
+    var div = document.createElement('div');
+    div.appendChild(document.createTextNode("(" + this.name + " ...)"));
+    return div;
+};
+
+WorldConfigOption.prototype.toWrittenString = function(cache) {
+    return "(" + this.name + " ...)";
+};
+
+WorldConfigOption.prototype.toDisplayedString = function(cache) {
+    return "(" + this.name + " ...)";
+};
+
+
+
+var isWorldConfigOption = function(x) { return x instanceof WorldConfigOption; };
+
+
+
+
+
+// convertAttribList: (listof (list string (or string boolean))) -> (hashof string string)
+var convertAttribList = function(attribList) {
+    var newList = types.EMPTY;
+    var nextElt;
+    var key, val;
+    while (!types.isEmpty(attribList)) {
+	nextElt = attribList.first();
+
+	key = nextElt.first();
+	val = nextElt.rest().first();
+
+	key = String(key);
+
+	if (types.isString(val)) {
+	    val = String(val);
+	} else if (types.isBoolean(val)) {
+	    // do nothing: the representation is the same.
+	} else if (types.isSymbol(val)) {
+	    if (String(val) === 'true') {
+		val = true;
+	    } else if (String(val) === 'false') {
+		val = false;
+	    } else {
+		val = String(val);
+	    }
+	} else {
+	    // raise error: neither string nor boolean
+	    raise(types.incompleteExn(
+		types.exnFailContract,		  
+		helpers.format(
+		    "attribute value ~s neither a string nor a boolean",
+		    [val]),
+		[]));
+	}
+	// ensure each element in the hash are primitive strings
+	newList = types.cons(types.list([key, val]),
+			     newList);
+	attribList = attribList.rest();
+    }
+    return helpers.assocListToHash(newList);
+}
+
+
+
+
+//////////////////////////////////////////////////////////////////////
+
+
+
+
+EXPORTS['key=?'] =
+    new PrimProc('key=?',
+		 2,
+		 false, false,
+		 function(key1, key2) {
+		     return (String(key1).toLowerCase() === 
+			     String(key2).toLowerCase());
+		 });
+
+
+
+
+
+var OnTickBang = function(handler, effectHandler, aDelay) {
+    WorldConfigOption.call(this, 'on-tick');
+    this.handler = handler;
+    this.effectHandler = effectHandler;
+    this.aDelay = aDelay;
+};
+
+OnTickBang.prototype = helpers.heir(WorldConfigOption.prototype);
+
+OnTickBang.prototype.configure = function(config) {
+    var newVals = { 
+	onTick: this.handler,
+	onTickEffect: this.effectHandler,
+	tickDelay: jsnums.toFixnum(jsnums.multiply(1000, this.aDelay))
+    };
+    return config.updateAll(newVals);
+};
+
+
+
+
+// The default tick delay is 28 times a second.
+var DEFAULT_TICK_DELAY = types.rational(1, 28);
+
+EXPORTS['on-tick'] =
+	new CasePrimitive(
+	    'on-tick',
+	    [new PrimProc('on-tick',
+			  1,
+			  false, false,
+			  function(f) {
+			      check(f, isFunction, "on-tick", "procedure", 1);
+			      return new OnTickBang(f,
+						    new PrimProc('', 1, false, false,
+								 function(w) { return types.effectDoNothing(); }),
+						    DEFAULT_TICK_DELAY);
+			  }),
+	     new PrimProc('on-tick',
+			  2,
+			  false, false,
+			  function(f, aDelay) {
+			      check(f, isFunction, "on-tick", "procedure", 1, arguments);
+			      check(aDelay, isNumber, "on-tick", "number", 2, arguments);
+			      return new OnTickBang(f,
+						    new PrimProc('', 1, false, false,
+								 function(w) { return types.effectDoNothing(); }),
+						    aDelay);
+			  }) ]);
+
+
+
+EXPORTS['on-tick!'] =
+    new CasePrimitive('on-tick!',
+	[new PrimProc('on-tick!',
+		      2,
+		      false, false,
+		      function(handler, effectHandler) {
+			  check(handler, isFunction, "on-tick!", "procedure", 1, arguments);
+			  check(effectHandler, isFunction, "on-tick!","procedure", 2, arguments);
+			  return new OnTickBang(handler, effectHandler, DEFAULT_TICK_DELAY);
+		      }),
+	 new PrimProc('on-tick!',
+		      3,
+		      false, false,
+		      function(handler, effectHandler, aDelay)  {
+			  check(handler, isFunction, "on-tick!", "procedure", 1, arguments);
+			  check(effectHandler, isFunction, "on-tick!","procedure", 2, arguments);
+			  check(aDelay, isNumber, "on-tick!", "number", 3, arguments);
+			  return new OnTickBang(handler, effectHandler, aDelay);
+		      }) ]);
+
+
+
+var onEvent = function(funName, inConfigName, numArgs) {
+    return function(handler) {
+	return onEventBang(funName, inConfigName)(handler,
+						  new PrimProc('', numArgs, false, false, function() { return types.EMPTY; }));
+    };
+};
+
+
+var onEventBang = function(funName, inConfigName) {
+
+    var CustomConfigOption = function(handler, effectHandler) {
+	WorldConfigOption.call(this, funName);
+	this.handler = handler;
+	this.effectHandler = effectHandler;
+    };
+    CustomConfigOption.prototype = helpers.heir(WorldConfigOption.prototype);
+
+    CustomConfigOption.prototype.configure =function(config) {
+	var newHash = {};
+	newHash[inConfigName] = this.handler;
+	newHash[inConfigName+'Effect'] = this.effectHandler;
+	return config.updateAll(newHash);
+    }
+
+    return function(handler, effectHandler) {
+	check(handler, isFunction, funName, 'procedure', 1, arguments);
+	check(effectHandler, isFunction, funName, 'procedure', 2, arguments);
+	return new CustomConfigOption(handler, effectHandler);
+    };
+};
+
+
+EXPORTS['on-key'] = new PrimProc('on-key', 1, false, false, onEvent('on-key', 'onKey', 2));
+EXPORTS['on-key!'] = new PrimProc('on-key!', 2, false, false, onEventBang('on-key!', 'onKey'));
+
+
+EXPORTS['stop-when'] = new PrimProc('stop-when', 1, false, false,
+				       onEvent('stop-when', 'stopWhen', 1));
+EXPORTS['stop-when!'] = new PrimProc('stop-when!', 2, false, false,
+					onEventBang('stop-when!', 'stopWhen'));
+
+
+
+
+
+var DrawConfigOption = function(f) {
+    WorldConfigOption.call(this, 'to-draw');
+    this.f = f;
+};
+
+DrawConfigOption.prototype = helpers.heir(WorldConfigOption.prototype);
+
+DrawConfigOption.prototype.configure = function(config) {
+    return config.updateAll({'onRedraw': this.f});
+};
+
+
+EXPORTS['to-draw'] =
+    new PrimProc('to-draw',
+		 1,
+		 false, false,
+		 function(f) {
+		     check(f, isFunction, 'to-draw', 'procedure', 1);
+		     return new DrawConfigOption(f);
+		 });
+
+
+var DrawPageOption = function(domHandler) {
+    WorldConfigOption.call(this, 'to-draw-page');
+    this.domHandler = domHandler;
+};
+DrawPageOption.prototype = helpers.heir(WorldConfigOption.prototype);
+DrawPageOption.prototype.configure = function(config) {
+    return config.updateAll({'onDraw': this.domHandler});
+};
+
+
+var DrawPageAndCssOption = function(domHandler, styleHandler) {
+    WorldConfigOption.call(this, 'to-draw-page');
+    this.domHandler = domHandler;
+    this.styleHandler = styleHandler;
+};
+DrawPageAndCssOption.prototype = helpers.heir(WorldConfigOption.prototype);
+DrawPageAndCssOption.prototype.configure = function(config) {
+    return config.updateAll({'onDraw': this.domHandler,
+			     'onDrawCss' : this.styleHandler});
+};
+
+
+
+
+EXPORTS['to-draw-page'] =
+    new CasePrimitive('to-draw-page',
+	[new PrimProc('to-draw-page',
+		      1,
+		      false, false,
+		      function(domHandler) {
+			  check(domHandler, isFunction, 'to-draw-page', 'procedure', 1);
+			  return new DrawPageOption(domHandler);
+		      }),
+	 new PrimProc('to-draw-page',
+		      2,
+		      false, false,
+		      function(domHandler, styleHandler) {
+		 	  check(domHandler, isFunction, 'to-draw-page', 'procedure', 1, arguments);
+			  check(styleHandler, isFunction, 'to-draw-page', 'procedure', 2, arguments);
+			  return new DrawPageAndCssOption(domHandler, styleHandler);		      }) ]);
+
+
+var InitialEffectOption = function(effect) {
+    WorldConfigOption.call(this, 'initial-effect');
+    this.effect = effect;
+};
+InitialEffectOption.prototype = helpers.heir(WorldConfigOption.prototype);
+InitialEffectOption.prototype.configure = function(config) {
+    return config.updateAll({'initialEffect': this.effect});
+};
+
+
+EXPORTS['initial-effect'] =
+    new PrimProc('initial-effect',
+		 1,
+		 false, false,
+		 function(effect) {
+		     return new InitialEffectOption(effect);
+		 });
+
+
+
+/**************************
+ *** Jsworld Primitives ***
+ **************************/
+
+
+var jsp = function(attribList) {
+	checkListOf(attribList, function(x) { return isList(x) && length(x) == 2; },
+		    'js-p', 'list of (list of X Y)', 1);
+	var attribs = convertAttribList(attribList);
+	var node = jsworld.MobyJsworld.p(attribs);
+	node.toWrittenString = function(cache) { return "(js-p)"; };
+	node.toDisplayedString = node.toWrittenString;
+	node.toDomNode = function(cache) { return node; };
+	return helpers.wrapJsValue(node);
+};
+EXPORTS['js-p'] =
+    new CasePrimitive('js-p',
+	[new PrimProc('js-p', 0, false, false, function() { return jsp(types.EMPTY); }),
+	 new PrimProc('js-p', 1, false, false, jsp)]);
+
+
+var jsdiv = function(attribList) {
+	checkListOf(attribList, isAssocList, 'js-div', '(listof X Y)', 1);
+
+	var attribs = convertAttribList(attribList);
+	var node = jsworld.MobyJsworld.div(attribs);
+	
+	node.toWrittenString = function(cache) { return "(js-div)"; };
+	node.toDisplayedString = node.toWrittenString;
+	node.toDomNode = function(cache) { return node; };
+	return helpers.wrapJsValue(node);
+};
+
+EXPORTS['js-div'] =
+    new CasePrimitive('js-div',
+		      [new PrimProc('js-div', 0, false, false, function() {
+			  return jsdiv(types.EMPTY); 
+		      }),
+		       new PrimProc('js-div', 1, false, false, jsdiv)
+		      ]);
+
+
+var jsButtonBang = function(funName) {
+	return function(worldUpdateF, effectF, attribList) {
+		check(worldUpdateF, isFunction, funName, 'procedure', 1);
+		check(effectF, isFunction, funName, 'procedure', 2);
+		checkListOf(attribList, isAssocList, funName, '(listof X Y)', 3);
+
+		var attribs = attribList ? convertAttribList(attribList) : {};
+		var node = jsworld.MobyJsworld.buttonBang(worldUpdateF, effectF, attribs);
+
+		node.toWrittenString = function(cache) { return '(' + funName + ' ...)'; };
+		node.toDisplayedString = node.toWrittenString;
+		node.toDomNode = function(cache) { return node; };
+		return helpers.wrapJsValue(node);
+	}
+};
+var jsButton = function(updateWorldF, attribList) {
+	var noneF = new types.PrimProc('', 1, false, false, function(w) { return types.EMPTY; });
+	return jsButtonBang('js-button')(updateWorldF, noneF, attribList);
+};
+EXPORTS['js-button'] =
+    new CasePrimitive('js-button',
+	[new PrimProc('js-button', 1, false, false,
+		      function(updateWorldF) {
+			  return jsButton(updateWorldF, types.EMPTY)}),
+	 new PrimProc('js-button', 2, false, false, jsButton)]);
+
+
+EXPORTS['js-button!'] =
+    new CasePrimitive('js-button!',
+	[new PrimProc('js-button!', 2, false, false, 
+		      function(worldUpdateF, effectF) {
+			  return jsButtonBang('js-button!')(worldUpdateF, effectF, types.EMPTY);
+		      }),
+	 new PrimProc('js-button!', 3, false, false, 
+		      jsButtonBang('js-button!'))]);
+
+
+
+var jsInput = function(type, updateF, attribList) {
+    check(type, isString, 'js-input', 'string', 1);
+    check(updateF, isFunction, 'js-input', 'procedure', 2);
+    checkListOf(attribList, isAssocList, 'js-input', '(listof X Y)', 3);
+
+    var attribs = attribList ? convertAttribList(attribList) : {};
+    var node = jsworld.MobyJsworld.input(String(type), 
+					 updateF, attribs);
+
+    node.toWrittenString = function(cache) { return "(js-input ...)"; }
+    node.toDisplayedString = node.toWrittenString;
+    node.toDomNode = function(cache) { return node; }
+    return helpers.wrapJsValue(node);
+};
+
+EXPORTS['js-input'] =
+	new CasePrimitive('js-input', 
+	[new PrimProc('js-input', 2, false, false, 
+		      function(type, updateF) {
+			  return jsInput(type, updateF, types.EMPTY)}),
+	 new PrimProc('js-input', 3, false, false, jsInput)]);
+
+
+
+var jsImg = function(src, attribList) {
+    check(src, isString, "js-img", "string", 1);
+    checkListOf(attribList, isAssocList, 'js-img', '(listof X Y)', 2);
+
+    var attribs = convertAttribList(attribList);
+    var node = jsworld.MobyJsworld.img(String(src), attribs);
+
+    node.toWrittenString = function(cache) { return "(js-img ...)"; }
+    node.toDisplayedString = node.toWrittenString;
+    node.toDomNode = function(cache) { return node; }
+    return helpers.wrapJsValue(node);
+};
+
+
+
+EXPORTS['js-img'] =
+    new CasePrimitive('js-img',
+	[new PrimProc('js-img', 1, false, false, 
+		      function(src) { return jsImg(src, types.EMPTY); }),
+	 new PrimProc('js-img', 2, false, false, jsImg)]);
+
+
+
+EXPORTS['js-text'] =
+    new PrimProc('js-text',
+		 1,
+		 false, false,
+		 function(s) {
+		     check(s, isString, 'js-text', 'string', 1);
+
+		     var node = jsworld.MobyJsworld.text(String(s), []);
+		     node.toWrittenString = function(cache) { return "(js-text ...)"; }
+		     node.toDisplayedString = node.toWrittenString;
+		     node.toDomNode = function(cache) { return node; }
+		     return helpers.wrapJsValue(node);
+		 });
+
+
+var jsSelect = function(optionList, updateF, attribList) {
+    checkListOf(optionList, isString, 'js-select', 'listof string', 1);
+    check(updateF, isFunction, 'js-select', 'procedure', 2);
+    checkListOf(attribList, isAssocList, 'js-select', '(listof X Y)', 3);
+
+    var attribs = attribList ? convertAttribList(attribList) : {};
+    var options = helpers.deepListToArray(optionList);
+    for (var i = 0 ; i < options.length; i++) {
+	options[i] = String(options[i]);
+    }
+    var node = jsworld.MobyJsworld.select(options, updateF, attribs);
+
+    node.toWrittenString = function(cache) { return '(js-select ...)'; };
+    node.toDisplayedString = node.toWrittenString;
+    node.toDomNode = function(cache) { return node; };
+    return helpers.wrapJsValue(node);
+};
+
+
+EXPORTS['js-select'] =
+    new CasePrimitive(
+	'js-select',
+	[new PrimProc('js-select', 2, false, false, 
+		      function(optionList, updateF) {
+			  return jsSelect(optionList, updateF,
+					  types.EMPTY)
+		      }),
+	 new PrimProc('js-select', 3, false, false,
+		      jsSelect)]);
+
+
+
+
+EXPORTS['big-bang'] =
+    new PrimProc('big-bang',
+		 1,
+		 true, true,
+		 function(state, initW, handlers) {
+		     arrayEach(handlers,
+			       function(x, i) {
+				   check(x, function(y) { return isWorldConfigOption(y) || isList(y) || types.isWorldConfig(y); },
+					 'js-big-bang', 'handler or attribute list', i+2);
+			       });
+		     var unwrappedConfigs = 
+			 helpers.map(function(x) {
+			     if ( isWorldConfigOption(x) ) {
+				 return function(config) { return x.configure(config); };
+			     }
+			     else {
+				 return x;
+			     }
+			 },
+				     handlers);
+		     return types.internalPause(function(caller, restarter, onFail) {
+			 var bigBangController;
+			 var onBreak = function() {
+			     bigBangController.breaker();
+			 }
+			 state.addBreakRequestedListener(onBreak);
+			 bigBangController = jsworld.MobyJsworld.bigBang(
+			     initW, 
+			     state.getToplevelNodeHook()(),
+			     unwrappedConfigs,
+			     caller,
+			     function(v) {
+				 state.removeBreakRequestedListener(onBreak);
+				 restarter(v);
+			     },
+ 			     onFail);
+		     })
+		 });
+
+
+//////////////////////////////////////////////////////////////////////
+
+
+var emptyPage = function(attribList) {
+    checkListOf(attribList, isAssocList, 'empty-page', '(listof X Y)', 1);
+
+    var attribs = convertAttribList(attribList);
+    var node = jsworld.MobyJsworld.emptyPage(attribs);
+    
+    // 	node.toWrittenString = function(cache) { return "(js-div)"; };
+    // 	node.toDisplayedString = node.toWrittenString;
+    // 	node.toDomNode = function(cache) { return node; };
+    // 	return helpers.wrapJsValue(node);
+    return node;
+};
+
+EXPORTS['empty-page'] =
+    new CasePrimitive('empty-page',
+		      [new PrimProc('empty-page', 0, false, false, 
+				    function() {  return emptyPage(types.EMPTY); }),
+		       new PrimProc('empty-page', 1, false, false, emptyPage)]);
+
+
+EXPORTS['place-on-page'] = 
+    new PrimProc('empty-page',
+		 4,
+		 false, false,
+		 function(elt, left, top, page) {
+		     // FIXME: add type checking
+		     check(left, isReal, 'place-on-page', 'real', 2);
+		     check(top, isReal, 'place-on-page', 'real', 3);
+		     return jsworld.MobyJsworld.placeOnPage(
+			 elt, jsnums.toFixnum(left), jsnums.toFixnum(top), page);
+		 });
+
+
+
+
+
+//////////////////////////////////////////////////////////////////////
+
+
+
+
+
+EXPORTS['make-world-config'] =
+    new PrimProc('make-world-config',
+		 2,
+		 true, false,
+		 function(startup, shutdown, startupArgs) {
+		 	var allArgs = [startup, shutdown].concat(startupArgs);
+		 	check(startup, isFunction, 'make-world-config', 'procedure', 1, allArgs);
+			check(shutdown, procArityContains(1), 'make-world-config', 'procedure (arity 1)', 2, allArgs);
+			arrayEach(startupArgs, function(x, i) { check(x, isFunction, 'make-world-config', 'handler', i+3, allArgs); });
+
+			if ( !procArityContains(startupArgs.length)(startup) ) {
+				raise( types.incompleteExn(
+					types.exnFailContract,
+					'make-world-config: 1st argument must have arity equal to '
+					+ 'the number of arguments after the second',
+					[]) );
+			}
+
+			return types.worldConfig(startup, shutdown, startupArgs);
+		 });
+
+
+EXPORTS['make-effect-type'] =
+	makeOptionPrimitive(
+	    'make-effect-type',
+	    4,
+	    [false],
+	    true,
+	    function(userArgs, aState, name, superType, fieldCnt, impl, guard) {
+		check(name, isSymbol, 'make-effect-type', 'string', 1, userArgs);
+		check(superType, function(x) { return x === false || types.isEffectType(x) },
+		      'make-effect-type', 'effect type or #f', 2, userArgs);
+		check(fieldCnt, isNatural, 'make-effect-type', 'exact non-negative integer', 3, userArgs);
+		check(impl, isFunction, 'make-effect-type', 'procedure', 4, userArgs);
+//		checkListOf(handlerIndices, isNatural, 'make-effect-type', 'exact non-negative integer', 5);
+		check(guard, function(x) { return x === false || isFunction(x); }, 'make-effect-type', 'procedure or #f', 6, userArgs);
+		// Check the number of arguments on the guard
+		var numberOfGuardArgs = fieldCnt + 1 + (superType ? superType.numberOfArgs : 0);
+		if ( guard && !procArityContains(numberOfGuardArgs)(guard) ) {
+			raise(types.incompleteExn(
+				types.exnFailContract,
+				helpers.format(
+					'make-effect-type: guard procedure does not accept ~a arguments '
+					+ '(one more than the number constructor arguments): ~s',
+					[numberOfGuardArgs, guard]),
+				[]));
+		}
+
+//		var jsImpl = schemeProcToJs(aState, impl);
+		var jsGuard = (guard ? schemeProcToJs(aState, guard) : false);
+//		var handlerIndices_js = helpers.map(jsnums.toFixnum, helpers.schemeListToArray(handlerIndices));
+
+//		var caller = makeCaller(aState);
+//		var wrapHandler = function(handler, changeWorld) {
+//			return types.jsObject('function', function() {
+//				var externalArgs = arguments;
+//				changeWorld(function(w, k) {
+//					var args = [w];
+//					for (var i = 0; i < externalArgs.length; i++) {
+//						args.push( helpers.wrapJsValue(externalArgs[i]) );
+//					}
+//					caller(handler, args, k);
+//				});
+//			});
+//		}
+
+		var anEffectType = types.makeEffectType(String(name),
+							superType,
+							fieldCnt,
+							impl,
+//							handlerIndices_js,
+							jsGuard,
+							makeCaller(aState));
+		aState.v = getMakeStructTypeReturns(anEffectType);
+	    });
+
+
+EXPORTS['effect-type?'] = new PrimProc('effect-type?', 1, false, false, types.isEffectType);
+EXPORTS['effect?'] = new PrimProc('effect?', 1, false, false, types.isEffect);
+
+//EXPORTS['make-effect:do-nothing'] = new PrimProc('make-effect:do-nothing', 0, false, false, types.EffectDoNothing.constructor);
+//EXPORTS['effect:do-nothing?'] = new PrimProc('effect:do-nothing?', 1, false, false, types.EffectDoNothing.predicate);
+
+
+EXPORTS['make-render-effect-type'] =
+	makeOptionPrimitive(
+	    'make-render-effect-type',
+	    4,
+	    [false],
+	    true,
+	    function(userArgs, aState, name, superType, fieldCnt, impl, guard) {
+		check(name, isSymbol, 'make-render-effect-type', 'string', 1, userArgs);
+		check(superType, function(x) { return x === false || types.isEffectType(x) },
+		      'make-render-effect-type', 'effect type or #f', 2, userArgs);
+		check(fieldCnt, isNatural, 'make-render-effect-type', 'exact non-negative integer', 3, userArgs);
+		check(impl, isFunction, 'make-render-effect-type', 'procedure', 4, userArgs);
+		check(guard, function(x) { return x === false || isFunction(x); }, 'make-render-effect-type', 'procedure or #f', 6, userArgs);
+		// Check the number of arguments on the guard
+		var numberOfGuardArgs = fieldCnt + 1 + (superType ? superType.numberOfArgs : 0);
+		if ( guard && !procArityContains(numberOfGuardArgs)(guard) ) {
+			raise(types.incompleteExn(
+				types.exnFailContract,
+				helpers.format(
+					'make-effect-type: guard procedure does not accept ~a arguments '
+					+ '(one more than the number constructor arguments): ~s',
+					[numberOfGuardArgs, guard]),
+				[]));
+		}
+		var jsGuard = (guard ? schemeProcToJs(aState, guard) : false);
+
+		var aRenderEffectType = types.makeRenderEffectType(String(name),
+								   superType,
+								   fieldCnt,
+								   impl,
+								   jsGuard);
+		aState.v = getMakeStructTypeReturns(aRenderEffectType);
+	    });
+
+
+EXPORTS['render-effect-type?'] = new PrimProc('render-effect-type?', 1, false, false, types.isRenderEffectType);
+EXPORTS['render-effect?'] = new PrimProc('render-effect?', 1, false, false, types.isRenderEffect);
+
+
+EXPORTS['world-with-effects'] =
+    new PrimProc('world-with-effects',
+		 2,
+		 false, false,
+		 function(effects, w) {
+		 	check(effects, isCompoundEffect, 'world-with-effects', 'compound effect', 1, arguments);
+
+			return jsworld.Jsworld.with_multiple_effects(w, helpers.flattenSchemeListToArray(effects));
+		 });
+
+
+
+EXPORTS['make-render-effect'] = new PrimProc('make-render-effect', 2, false, false, types.makeRenderEffect);
+
+EXPORTS['render-effect?'] = new PrimProc('render-effect?', 1, false, false, types.isRenderEffect);
+
+EXPORTS['render-effect-dom-node'] =
+    new PrimProc('render-effect-dom-node',
+		 1,
+		 false, false,
+		 function(effect) {
+		 	check(effect, types.isRenderEffect, 'render-effect-dom-node', 'render-effect', 1);
+			return types.renderEffectDomNode(effect);
+		 });
+
+EXPORTS['render-effect-effects'] =
+    new PrimProc('render-effect-effects',
+		 1,
+		 false, false,
+		 function(effect) {
+		 	check(effect, types.isRenderEffect, 'render-effect-effects', 'render-effect', 1);
+			return types.renderEffectEffects(effect);
+		 });
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+//////////////////////////////////////////////////////////////////////
+
+// Helper Functions
+
+
+
+
+
+
+
+
+var checkList = function(x, functionName, position, args) {
+	if ( !isList(x) ) {
+		helpers.throwCheckError([functionName,
+					 'list',
+					 helpers.ordinalize(position),
+					 x],
+					position,
+					args);
+	}
+}
+
+
+var length = function(lst) {
+    checkList(lst, 'length', 1, [lst]);
+    var ret = 0;
+    for (; !isEmpty(lst); lst = lst.rest()) {
+	ret = ret+1;
+    }
+    return ret;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var getMakeStructTypeReturns = function(aStructType) {
+	var name = aStructType.name;
+	return new types.ValuesWrapper(
+		[aStructType,
+		 (new types.StructConstructorProc(name,
+					    'make-'+name,
+					    aStructType.numberOfArgs,
+					    false,
+					    false,
+					    aStructType.constructor)),
+		 (new types.StructPredicateProc(name, name+'?', 1, false, false, aStructType.predicate)),
+		 (new types.StructAccessorProc(name,
+					 name+'-ref',
+					 2,
+					 false,
+					 false,
+					 function(x, i) {
+						check(x, aStructType.predicate, name+'-ref', 'struct:'+name, 1, arguments);
+						check(i, isNatural, name+'-ref', 'non-negative exact integer', 2, arguments);
+
+						var numFields = aStructType.numberOfFields;
+						if ( jsnums.greaterThanOrEqual(i, numFields) ) {
+							var msg = (name+'-ref: slot index for <struct:'+name+'> not in ' +
+								   '[0, ' + (numFields-1) + ']: ' + i);
+							raise( types.incompleteExn(types.exnFailContract, msg, []) );
+						}
+						return aStructType.accessor(x, jsnums.toFixnum(i));
+					 })),
+		 (new types.StructMutatorProc(name,
+					name+'-set!',
+					3,
+					false,
+					false,
+					function(x, i, v) {
+						check(x, aStructType.predicate, name+'-set!', 'struct:'+name, 1, arguments);
+						check(i, isNatural, name+'-set!', 'non-negative exact integer', 2, arguments);
+
+						var numFields = aStructType.numberOfFields;
+						if ( jsnums.greaterThanOrEqual(i, numFields) ) {
+							var msg = (name+'-set!: slot index for <struct'+name+'> not in ' +
+								   '[0, ' + (numFields-1) + ']: ' + i);
+							raise( types.incompleteExn(types.exnFailContract, msg, []) );
+						}
+						aStructType.mutator(x, jsnums.toFixnum(i), v)
+					})) ]);
+};
+
+
+
+
+//////////////////////////////////////////////////////////////////////
+
+
+var isNumber = jsnums.isSchemeNumber;
+var isReal = jsnums.isReal;
+var isRational = jsnums.isRational;
+var isComplex = isNumber;
+var isInteger = jsnums.isInteger;
+
+var isNatural = function(x) {
+	return jsnums.isExact(x) && isInteger(x) && jsnums.greaterThanOrEqual(x, 0);
+};
+
+var isNonNegativeReal = function(x) {
+	return isReal(x) && jsnums.greaterThanOrEqual(x, 0);
+};
+
+var isSymbol = types.isSymbol;
+var isChar = types.isChar;
+var isString = types.isString;
+var isPair = types.isPair;
+var isEmpty = function(x) { return x === types.EMPTY; };
+var isList = helpers.isList;
+var isListOf = helpers.isListOf;
+
+var isVector = types.isVector;
+var isBox = types.isBox;
+var isHash = types.isHash;
+var isByteString = types.isByteString;
+
+var isByte = function(x) {
+	return (isNatural(x) &&
+		jsnums.lessThanOrEqual(x, 255));
+}
+
+var isBoolean = function(x) {
+	return (x === true || x === false);
+}
+
+var isFunction = types.isFunction;
+
+var isEqual = function(x, y) {
+	return types.isEqual(x, y, new types.UnionFind());
+}
+
+var isEq = function(x, y) {
+	return x === y;
+}
+
+var isEqv = function(x, y) {
+	if (isNumber(x) && isNumber(y)) {
+		return jsnums.eqv(x, y);
+	}
+	else if (isChar(x) && isChar(y)) {
+		return x.val === y.val;
+	}
+	return x === y;
+}
+
+
+
+
+
+
+var isStyle = function(x) {
+	return ((isString(x) || isSymbol(x)) &&
+		(String(x).toLowerCase() == "solid" ||
+		 String(x).toLowerCase() == "outline"));
+};
+
+
+var isAssocList = function(x) {
+	return isPair(x) && isPair(x.rest()) && isEmpty(x.rest().rest());
+};
+
+
+var isCompoundEffect = function(x) {
+	return ( types.isEffect(x) || isListOf(x, isCompoundEffect) );
+};
+
+var isJsValue = types.isJsValue;
+var isJsFunction = function(x) {
+    return isJsValue(x) && typeof(x.unbox()) == 'function';
+};
+
+
+
+var arrayEach = function(arr, f) {
+	for (var i = 0; i < arr.length; i++) {
+		f.call(null, arr[i], i);
+	}
+}
+
+//var throwCheckError = helpers.throwCheckError;
+var check = helpers.check;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+//////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////
+
+
+
+
+
+/*
+
+
+
+PRIMITIVES['js-p'] =
+    makeOptionPrimitive('js-p',
+			0,
+			[types.EMPTY],
+			false,
+			function(userArgs, attribList) {
+				checkListOf(attribList, function(x) { return isList(x) && length(x) == 2; },
+					    'js-p', 'list of (list of X Y)', 1, userArgs);
+
+				var attribs = assocListToHash(attribList);
+				var node = helpers.wrapJsValue( jsworld.Jsworld.p(attribs) );
+
+				node.toWrittenString = function(cache) { return "(js-p)"; };
+				node.toDisplayedString = node.toWrittenString;
+			//	node.toDomNode = function(cache) { return node; };
+				return node;
+			});
+
+
+PRIMITIVES['js-div'] =
+    makeOptionPrimitive('js-div',
+			0,
+			[types.EMPTY],
+			false,
+			function(userArgs, attribList) {
+				checkListOf(attribList, isAssocList, 'js-div', '(listof X Y)', 1, userArgs);
+
+				var attribs = assocListToHash(attribList);
+				var node = helpers.wrapJsValue( jsworld.Jsworld.div(attribs) );
+				
+				node.toWrittenString = function(cache) { return "(js-div)"; };
+				node.toDisplayedString = node.toWrittenString;
+			//	node.toDomNode = function(cache) { return node; };
+				return node;
+			});
+
+
+var jsButtonBang = function(funName, worldUpdateF, effectF, attribList) {
+	var attribs = assocListToHash(attribList);
+	var node = helpers.wrapJsValue( jsworld.Jsworld.buttonBang(worldUpdateF, effectF, attribs) );
+
+	node.toWrittenString = function(cache) { return '(' + funName + ' ...)'; };
+	node.toDisplayedString = node.toWrittenString;
+//	node.toDomNode = function(cache) { return node; };
+	return node;
+};
+PRIMITIVES['js-button'] =
+    makeOptionPrimitive('js-button',
+			1,
+			[types.EMPTY],
+			false,
+			function(userArgs, updateWorldF, attribList) {
+				check(updateWorldF, isFunction, 'js-button', 'procedure', 1, userArgs);
+				checkListOf(attribList, isAssocList, 'js-button', '(listof X Y)', 2, userArgs);
+
+				var noneF = new types.PrimProc('', 1, false, false, function(w) { return types.EMPTY; });
+				return jsButtonBang('js-button', updateWorldF, noneF, attribList);
+			});
+
+PRIMITIVES['js-button!'] =
+    makeOptionPrimitive('js-button!',
+			2,
+			[types.EMPTY],
+			false,
+			function(userArgs, updateWorldF, effectF, attribList) {
+				check(worldUpdateF, isFunction, funName, 'procedure', 1, userArgs);
+				check(effectF, isFunction, funName, 'procedure', 2, userArgs);
+				checkListOf(attribList, isAssocList, funName, '(listof X Y)', 3, userArgs);
+
+				return jsButtonBang('js-button!', updateWorldF, effectF, attribList);
+			});
+
+
+PRIMITIVES['js-input'] =
+    makeOptionPrimitive('js-input',
+			2,
+			[types.EMPTY],
+			false,
+			function(userArgs, type, updateF, attribList) {
+				check(type, isString, 'js-input', 'string', 1, userArgs);
+				check(updateF, isFunction, 'js-input', 'procedure', 2, userArgs);
+				checkListOf(attribList, isAssocList, 'js-input', '(listof X Y)', 3, userArgs);
+
+				var attribs = assocListToHash(attribList);
+				var node = helpers.wrapJsValue( jsworld.Jsworld.input(type.toString(), updateF, attribs) );
+
+				node.toWrittenString = function(cache) { return "(js-input ...)"; }
+				node.toDisplayedString = node.toWrittenString;
+			//	node.toDomNode = function(cache) { return node; }
+				return node;
+			});
+
+
+PRIMITIVES['js-img'] =
+    makeOptionPrimitive('js-img',
+			1,
+			[types.EMPTY],
+			false,
+			function(userArgs, src, attribList) {
+				check(src, isString, "js-img", "string", 1, userArgs);
+				checkListOf(attribList, isAssocList, 'js-img', '(listof X Y)', 2, userArgs);
+
+				var attribs = assocListToHash(attribList);
+			        var node = helpers.wrapJsValue( jsworld.Jsworld.img(src.toString(), attribs) );
+
+				node.toWrittenString = function(cache) { return "(js-img ...)"; }
+				node.toDisplayedString = node.toWrittenString;
+			//	node.toDomNode = function(cache) { return node; }
+				return node;
+			});
+
+
+PRIMITIVES['js-text'] =
+    new PrimProc('js-text',
+		 1,
+		 false, false,
+		 function(s) {
+		 	check(s, isString, 'js-text', 'string', 1);
+
+		        var node = helpers.wrapJsValue( jsworld.Jsworld.text(s.toString(), []) );
+			node.toWrittenString = function(cache) { return "(js-text ...)"; }
+			node.toDisplayedString = node.toWrittenString;
+//			node.toDomNode = function(cache) { return node; }
+			return node;
+		 });
+
+
+PRIMITIVES['js-select'] =
+    makeOptionPrimitive('js-select',
+			2,
+			[types.EMPTY],
+			false,
+			function(userArgs, optionList, updateF, attribList) {
+				checkListOf(optionList, isString, 'js-select', 'listof string', 1, userArgs);
+				check(updateF, isFunction, 'js-select', 'procedure', 2, userArgs);
+				checkListOf(attribList, isAssocList, 'js-select', '(listof X Y)', 3, userArgs);
+
+				var attribs = assocListToHash(attribList);
+				var options = helpers.deepListToArray(optionList);
+			        for (var i = 0; i < options.length; i++) {
+				    options[i] = options[i].toString();
+				}
+				var node = helpers.wrapJsValue( jsworld.Jsworld.select(options, updateF, attribs) );
+
+				node.toWrittenString = function(cache) { return '(js-select ...)'; };
+				node.toDisplayedString = node.toWrittenString;
+			//	node.toDomNode = function(cache) { return node; };
+				return node;
+			});
+
+
+
+PRIMITIVES['js-big-bang'] =
+    new PrimProc('js-big-bang',
+		 1,
+		 true, true,
+		 function(aState, initW, configs) {
+		 	arrayEach(configs,
+				  function(x, i) {
+				  	check(x, function(y) { return (types.isWorldConfig(y) ||
+									jsworld.Jsworld.isBuiltInConfig(y)); },
+					      'js-big-bang', 'world configuration', i+2);
+				  });
+
+			return PAUSE(function(caller, onSuccess, onFail) {
+				var bigBangController = {};
+				var onBreak = function() {
+					bigBangController.breaker(aState);
+				}
+				aState.addBreakRequestedListener(onBreak);
+				aState.onSuccess = function(v) {
+					aState.removeBreakRequestedListener(onBreak);
+					onSuccess(v);
+				};
+				jsworld.Jsworld.bigBang(initW,
+//							aState.getToplevelNodeHook()(),
+							configs,
+							aState,
+							caller,
+							bigBangController);
+//							caller,
+//							function(v) {
+//								aState.removeBreakRequestedListener(onBreak);
+//								onSuccess(v);
+//							},
+//							onFail,
+//							bigBangController);
+			});
+		 });
+
+
+//////////////////////////////////////////////////////////////////////
+
+
+    var emptyPage = function(attribList) {
+	checkListOf(attribList, isAssocList, 'empty-page', '(listof X Y)', 1);
+
+	var attribs = assocListToHash(attribList);
+	var node = jsworld.MobyJsworld.emptyPage(attribs);
+	
+// 	node.toWrittenString = function(cache) { return "(js-div)"; };
+// 	node.toDisplayedString = node.toWrittenString;
+// 	node.toDomNode = function(cache) { return node; };
+// 	return helpers.wrapJsValue(node);
+	return node;
+    };
+
+    PRIMITIVES['empty-page'] =
+	new CasePrimitive('empty-page',
+			  [new PrimProc('empty-page', 0, false, false, 
+					function() {  return emptyPage(types.EMPTY); }),
+			   new PrimProc('empty-page', 1, false, false, emptyPage)]);
+
+    
+    PRIMITIVES['place-on-page'] = 
+	new PrimProc('empty-page',
+		     4,
+		     false, false,
+		     function(elt, left, top, page) {
+			 // FIXME: add type checking
+			 return jsworld.MobyJsworld.placeOnPage(
+			     elt, left, top, page);
+		     });
+					    
+
+
+
+
+//////////////////////////////////////////////////////////////////////
+
+
+
+
+
+PRIMITIVES['make-world-config'] =
+    makeOptionPrimitive('make-world-config',
+			2,
+			[false, false],
+			false,
+			function(userArgs, startup, shutdown, pause, restart) {
+				check(startup, procArityContains(1), 'make-world-config', 'procedure', 1, userArgs);
+				check(shutdown, procArityContains(1), 'make-world-config', 'procedure (arity 1)', 2, userArgs);
+				check(pause, function(x) { return (x === false || procArityContains(1)(x)); },
+				      'make-world-config', 'procedure (arity 1) or #f', 3, userArgs);
+				check(restart, function(x) { return (x === false || procArityContains(2)(x)); },
+				      'make-world-config', 'procedure (arity 2) or #f', 4, userArgs);
+
+				return types.worldConfig(startup, shutdown, pause, restart);
+			});
+
+PRIMITIVES['bb-info'] = types.BigBangInfo;
+PRIMITIVES['make-bb-info'] = new PrimProc('make-bb-info', 2, false, false, types.makeBigBangInfo);
+PRIMITIVES['bb-info?'] = new PrimProc('bb-info?', 1, false, false, types.isBigBangInfo);
+
+PRIMITIVES['bb-info-change-world'] =
+    new PrimProc('bb-info-change-world',
+		 1,
+		 false, false, 
+		 function(bbInfo) {
+		 	check(bbInfo, types.isBigBangInfo, 'bb-info-change-world', 'bb-info', 1);
+			return types.bbInfoChangeWorld(bbInfo);
+		 });
+
+PRIMITIVES['bb-info-toplevel-node'] =
+    new PrimProc('bb-info-toplevel-node',
+		 1,
+		 false, false, 
+		 function(bbInfo) {
+		 	check(bbInfo, types.isBigBangInfo, 'bb-info-toplevel-node', 'bb-info', 1);
+			return types.bbInfoToplevelNode(bbInfo);
+		 });
+
+
+PRIMITIVES['make-effect-type'] =
+	makeOptionPrimitive(
+	    'make-effect-type',
+	    4,
+	    [false],
+	    true,
+	    function(userArgs, aState, name, superType, fieldCnt, impl, guard) {
+		check(name, isSymbol, 'make-effect-type', 'string', 1, userArgs);
+		check(superType, function(x) { return x === false || types.isEffectType(x) },
+		      'make-effect-type', 'effect type or #f', 2, userArgs);
+		check(fieldCnt, isNatural, 'make-effect-type', 'exact non-negative integer', 3, userArgs);
+		check(impl, isFunction, 'make-effect-type', 'procedure', 4, userArgs);
+		check(guard, function(x) { return x === false || isFunction(x); }, 'make-effect-type', 'procedure or #f', 6, userArgs);
+
+		var numberOfGuardArgs = fieldCnt + 1 + (superType ? superType.numberOfArgs : 0);
+		var anEffectType = types.makeEffectType(name.toString(),
+							superType,
+							fieldCnt,
+							impl,
+							checkAndGetGuard('make-effect-type',
+									 guard,
+									 numberOfGuardArgs));
+		aState.v = getMakeStructTypeReturns(anEffectType);
+	    });
+
+
+PRIMITIVES['effect-type?'] = new PrimProc('effect-type?', 1, false, false, types.isEffectType);
+PRIMITIVES['effect?'] = new PrimProc('effect?', 1, false, false, types.isEffect);
+
+//PRIMITIVES['make-effect:do-nothing'] = new PrimProc('make-effect:do-nothing', 0, false, false, types.EffectDoNothing.constructor);
+//PRIMITIVES['effect:do-nothing?'] = new PrimProc('effect:do-nothing?', 1, false, false, types.EffectDoNothing.predicate);
+
+
+PRIMITIVES['make-render-effect-type'] =
+	makeOptionPrimitive(
+	    'make-render-effect-type',
+	    4,
+	    [false],
+	    true,
+	    function(userArgs, aState, name, superType, fieldCnt, impl, guard) {
+		check(name, isSymbol, 'make-render-effect-type', 'string', 1, userArgs);
+		check(superType, function(x) { return x === false || types.isEffectType(x) },
+		      'make-render-effect-type', 'effect type or #f', 2, userArgs);
+		check(fieldCnt, isNatural, 'make-render-effect-type', 'exact non-negative integer', 3, userArgs);
+		check(impl, isFunction, 'make-render-effect-type', 'procedure', 4, userArgs);
+		check(guard, function(x) { return x === false || isFunction(x); }, 'make-render-effect-type', 'procedure or #f', 6, userArgs);
+
+		var numberOfGuardArgs = fieldCnt + 1 + (superType ? superType.numberOfArgs : 0);
+		var aRenderEffectType =
+			types.makeRenderEffectType(name.toString(),
+						   superType,
+						   fieldCnt,
+						   impl,
+						   checkAndGetGuard('make-render-effect-type',
+								    guard,
+								    numberOfGuardArgs));
+		aState.v = getMakeStructTypeReturns(aRenderEffectType);
+	    });
+
+
+PRIMITIVES['render-effect-type?'] = new PrimProc('render-effect-type?', 1, false, false, types.isRenderEffectType);
+PRIMITIVES['render-effect?'] = new PrimProc('render-effect?', 1, false, false, types.isRenderEffect);
+
+
+PRIMITIVES['world-with-effects'] =
+    new PrimProc('world-with-effects',
+		 2,
+		 false, false,
+		 function(effects, w) {
+		 	check(effects, isCompoundEffect, 'world-with-effects', 'compound effect', 1, arguments);
+
+			return jsworld.Jsworld.worldWithEffects(helpers.flattenSchemeListToArray(effects), w);
+		 });
+
+
+
+PRIMITIVES['make-render-effect'] = new PrimProc('make-render-effect', 2, false, false, types.makeRenderEffect);
+
+PRIMITIVES['render-effect?'] = new PrimProc('render-effect?', 1, false, false, types.isRenderEffect);
+
+PRIMITIVES['render-effect-dom-node'] =
+    new PrimProc('render-effect-dom-node',
+		 1,
+		 false, false,
+		 function(effect) {
+		 	check(effect, types.isRenderEffect, 'render-effect-dom-node', 'render-effect', 1);
+			return types.renderEffectDomNode(effect);
+		 });
+
+PRIMITIVES['render-effect-effects'] =
+    new PrimProc('render-effect-effects',
+		 1,
+		 false, false,
+		 function(effect) {
+		 	check(effect, types.isRenderEffect, 'render-effect-effects', 'render-effect', 1);
+			return types.renderEffectEffects(effect);
+		 });
+
+
+
+
+
+
+
+
+PRIMITIVES['stop-when'] =
+    new PrimProc('stop-when', 1, false, false,
+		 function(test) {
+		 	check(test, isFunction, 'stop-when', 'procedure', 1);
+			return jsworld.Jsworld.stopWhenConfig(test);
+		 });
+//PRIMITIVES['stop-when!'] = new PrimProc('stop-when!', 2, false, false,
+//					onEventBang('stop-when!', 'stopWhen'));
+
+
+PRIMITIVES['to-draw'] =
+    new PrimProc('to-draw',
+		 1,
+		 false, false,
+		 function(f) {
+		     check(f, isFunction, 'to-draw', 'procedure', 1);
+		     return jsworld.Jsworld.onDrawSceneConfig(f);
+
+		 });
+
+
+PRIMITIVES['to-draw-page'] =
+    new CasePrimitive('to-draw-page',
+	[new PrimProc('to-draw-page',
+		      1,
+		      false, false,
+		      function(domHandler) {
+			  check(domHandler, isFunction, 'to-draw-page', 'procedure', 1);
+			  return jsworld.Jsworld.onDrawPageConfig(domHandler);
+		      }),
+	 new PrimProc('to-draw-page',
+		      2,
+		      false, false,
+		      function(domHandler, styleHandler) {
+		 	  check(domHandler, isFunction, 'to-draw-page', 'procedure', 1, arguments);
+			  check(styleHandler, isFunction, 'to-draw-page', 'procedure', 2, arguments);
+			  return jsworld.Jsworld.onDrawPageConfig(domHandler, styleHandler);
+		      }) ]);
+
+
+
+*/
\ No newline at end of file
diff --git a/world/scratch/jsworld/jsworld.rkt b/world/scratch/jsworld/jsworld.rkt
new file mode 100644
index 0000000..e706821
--- /dev/null
+++ b/world/scratch/jsworld/jsworld.rkt
@@ -0,0 +1,50 @@
+#lang s-exp "../lang/js-impl/js-impl.rkt"
+
+;; Loaded so we have access to image library stuff, as well as the world kernel
+(require "../world/kernel.rkt"
+	 "../image/image.rkt")
+
+
+(require-js "private/jsworld/jsworld.js"
+	    "private/jsworld.js"
+	    "jsworld.js")
+
+
+(provide big-bang
+	 to-draw
+         to-draw-page
+         
+         key=?
+	 on-tick on-tick!
+	 on-key on-key!
+	 stop-when stop-when!
+
+	 initial-effect
+
+	 js-p
+	 js-div
+	 js-button
+	 js-button!
+	 js-input
+	 js-img
+	 js-text
+	 js-select
+
+
+	 empty-page
+	 place-on-page
+
+	 make-world-config
+	 make-effect-type
+	 effect-type?
+	 effect?
+
+	 #;make-render-effect-type
+	 #;render-effect-type?
+
+	 world-with-effects
+
+	 #;make-render-effect
+	 #;render-effect?
+	 #;render-effect-dom-node
+	 #;render-effect-effects)
diff --git a/world/scratch/jsworld/private/jsworld.js b/world/scratch/jsworld/private/jsworld.js
new file mode 100644
index 0000000..17a0cc8
--- /dev/null
+++ b/world/scratch/jsworld/private/jsworld.js
@@ -0,0 +1,777 @@
+// Depends on world.js, world-config.js
+
+(function() {
+
+    var world = {};
+    world.Kernel = STATE.invokedModules["mzscheme-vm/world/kernel"].lookup("kernel");
+
+
+
+    var Jsworld = jsworld.MobyJsworld = {};
+
+    // The real low-level jsworld module:
+    var _js = jsworld.Jsworld;
+
+
+    var caller;
+    var setCaller = function(c) {
+    	caller = function(op, args, k) {
+	    c(op, args, k, handleError);
+	};
+    };
+    var unsetCaller = function() {
+    	caller = function(op, args, k) {
+		throw new Error('caller not defined!');
+	};
+    };
+    unsetCaller();
+
+    // The restarted and things to set it
+    // Note that we never want to restart the same computation
+    // more than once, so we throw an error if someone tries to do that
+    var restarter;
+    var setRestarter = function(r) {
+	    var hasRestarted = false;
+	    restarter = function(v) {
+		    if (hasRestarted) {
+			    throw new Error('Cannot restart twice!');
+		    }
+		    hasRestarted = true;
+		    r(v);
+	    };
+    };
+    var unsetRestarter = function() {
+	restarter = function() {
+		throw new Error('restarter not defined!');
+	};
+    };
+    unsetRestarter();
+
+
+    var errorReporter = function(e) {
+	// default: do nothing.
+    };
+
+
+
+    var terminator;
+    var setTerminator = function(t) {
+	    terminator = t;
+    };
+    var unsetTerminator = function() {
+	terminator = function() {
+		throw new Error('terminator not defined!');
+	};
+    };
+    unsetTerminator();
+
+
+
+    // mutateStringsInDeepArray: array -> array
+    // walks and in-place mutates Scheme strings to primitive strings.
+    var mutateStringsInDeepArray = function(thing) {
+	var i, length;
+	if (typeof(thing) === 'object' &&
+	    thing.constructor === Array) {
+	    length = thing.length;
+	    for (i = 0; i < length; i++) {
+		thing[i] = mutateStringsInDeepArray(thing[i]);
+	    }
+	} else if (types.isString(thing)) {
+	    return thing.toString();
+	}
+	return thing;
+    };
+
+
+
+
+    var userConfigs = [];
+
+    var startUserConfigs = function(k) {
+	    helpers.forEachK(userConfigs,
+			     function(aConfig, k2) {
+				caller(aConfig.startup, aConfig.startupArgs,
+					function(res) {
+					    aConfig.isRunning = true;
+						aConfig.shutdownArg = res;
+						k2()
+					});
+			     },
+			     handleError,
+			     k);
+    }
+
+    var shutdownUserConfigs = function(k) {
+//	    console.log('shutting down user configs');
+	    var theConfigs = userConfigs;
+	    userConfigs = []
+	    helpers.forEachK(theConfigs,
+			     function(aConfig, k2) {
+//			     	console.log('    shutting down a config');
+				 if (aConfig.isRunning) {
+				     aConfig.isRunning = false;
+			     	     caller(aConfig.shutdown, [aConfig.shutdownArg], k2);
+				 } else {
+				     k2();
+				 }
+			     },
+			     handleError,
+			     k);
+    }
+
+    var expandHandler = function(handler) {
+	return types.jsValue('function', function() {
+		var wrappedStimulusArgs = [];
+		for (var i = 0; i < arguments.length; i++) {
+			wrappedStimulusArgs.push( helpers.wrapJsValue(arguments[i]) );
+		}
+
+		Jsworld.updateWorld(
+			function(w, k) {
+				var args = [w].concat(wrappedStimulusArgs);
+				caller(handler, args, k);
+			},
+			function() {});
+	});
+    };
+
+
+//    var unwrapWorldEffects = function(w) {
+//	if ( _js.has_effects(w) ) {
+//		var unwrappedEffects =
+//			helpers.map(function(e) {
+//					if ( types.isEffect(e) ) {
+//						return types.makeJsworldEffect(function(k) {
+//								caller(types.effectThunk(e), [], k);
+//							});
+//					}
+//					else {
+//						return e;
+//					}
+//				    },
+//				    w.getEffects());
+//		var returnVal = _js.with_multiple_effects(w.getWorld(), unwrappedEffects);
+//		return returnVal;
+//	}
+//	else {
+//		return w;
+//	}
+//    };
+
+
+    var deepUnwrapJsValues = function(x, k) {
+	    if ( types.isJsValue(x) ) {
+		k(x.unbox());
+	    }
+	    else if ( types.isRenderEffect(x) ) {
+		    x.callImplementation(caller, function(y) { deepUnwrapJsValues(y, k); });
+	    }
+//		    var effects = helpers.schemeListToArray( types.renderEffectEffects(x) ).reverse();
+//		    types.setRenderEffectEffects(x, types.EMPTY);
+//
+//		    helpers.forEachK(effects,
+//				     function(ef, k2) { caller(ef, [], k2); },
+//				     handleError,
+//				     function() { deepUnwrapJsValues(types.renderEffectDomNode(x), k); });
+//	    }
+	    else if ( types.isPair(x) ) {
+		deepUnwrapJsValues(x.first(), function(first) {
+			deepUnwrapJsValues(x.rest(), function(rest) {
+				k( types.cons(first, rest) );
+			});
+		});
+	    }
+	    else {
+		    k(x);
+	    }
+    };
+    
+
+
+
+
+
+
+
+    // isHandler: X -> boolean
+    // Right now, a handler is a function that consumes and produces
+    // configs.  We should tighten up the type check eventually.
+    var isHandler = function(x) {
+	return typeof(x) == 'function';
+    }
+
+
+
+
+    //////////////////////////////////////////////////////////////////////
+    //From this point forward, we define wrappers to integrate jsworld
+    //with Moby.
+
+
+    // getBigBangWindow: -> window
+    var getBigBangWindow = function() {
+        if (window.document.getElementById("jsworld-div") !== undefined) {
+	    return window;
+	} else {
+	    var newDiv = window.document.createElement("div");
+	    newDiv.id = 'jsworld-div';
+	    window.document.appendChild(newDiv);
+	    return window;
+	}
+    }
+
+
+    // types are
+    // sexp: (cons node (listof sexp))
+    // css-style: (node (listof (list string string)))
+
+    // Exports:
+
+
+
+
+    var isPair = types.isPair;
+    var isEmpty = function(x) { return x === types.EMPTY; };
+    var isList = function(x) { return (isPair(x) || isEmpty(x)); };
+
+
+
+    // The default printWorldHook will write the written content of the node.
+    // We probably want to invoke the pretty printer here instead!
+    Jsworld.printWorldHook = function(world, node) {
+	var newNode;
+	if(node.lastChild == null) {
+	    newNode = types.toDomNode(world);
+	    node.appendChild(newNode);
+	    helpers.maybeCallAfterAttach(newNode);
+	} else {
+	    newNode = types.toDomNode(world);
+	    node.replaceChild(newNode, node.lastChild);
+	    helpers.maybeCallAfterAttach(newNode);
+	}
+    };
+
+
+
+    // Figure out the target of an event.
+    // http://www.quirksmode.org/js/events_properties.html#target
+    var findEventTarget = function(e) {
+	var targ;
+	if (e.target) 
+	    targ = e.target;
+	else if (e.srcElement) 
+	    targ = e.srcElement;
+	if (targ.nodeType == 3) // defeat Safari bug
+	    targ = targ.parentNode;
+	return targ;
+    }
+
+    // isNode: any -> boolean
+    // Returns true if the thing has a nodeType.
+    var isNode = function(thing) {
+	return thing && typeof(thing.nodeType) != 'undefined';
+    }
+
+
+
+    // checkWellFormedDomTree: X X (or number undefined) -> void
+    // Check to see if the tree is well formed.  If it isn't,
+    // we need to raise a meaningful error so the user can repair
+    // the structure.
+    //
+    // Invariants:
+    // The dom tree must be a pair.
+    // The first element must be a node.
+    // Each of the rest of the elements must be dom trees.
+    // If the first element is a text node, it must NOT have children.
+    var checkWellFormedDomTree = function(x, top, index) {
+	var fail = function(formatStr, formatArgs) {
+		throw types.schemeError(
+			types.incompleteExn(types.exnFailContract,
+					    helpers.format(formatStr, formatArgs),
+			       		    []));
+	}
+
+	if (_js.isPage(x)) {
+	    return;
+	}
+
+	if (types.isPair(x)) {
+	    var firstElt = x.first();
+	    var restElts = x.rest();
+
+	    if (! isNode(firstElt)) {
+		fail("on-draw: expected a dom-element, but received ~s instead, the first element within ~s", [firstElt, top]);
+	    }
+
+	    if (firstElt.nodeType == Node.TEXT_NODE && !restElts.isEmpty() ) {
+		fail("on-draw: the text node ~s must not have children.  It has ~s", [firstElt, restElts]);
+	    }
+
+	    var i = 2;
+	    while( !restElts.isEmpty() ) {
+		checkWellFormedDomTree(restElts.first(), x, i);
+		restElts = restElts.rest();
+		i++;
+	    }
+	} else {
+		var formatStr = "on-draw: expected a dom-s-expression, but received ~s instead";
+		var formatArgs = [x];
+		if (index != undefined) {
+			formatStr += ", the ~a element within ~s";
+			formatArgs.push( helpers.ordinalize(index) );
+			formatArgs.push(top);
+		}
+		formatStr += ".";
+
+		fail(formatStr, formatArgs);
+	}
+    };
+
+
+    // Compatibility for attaching events to nodes.
+    var attachEvent = function(node, eventName, fn) {
+	if (node.addEventListener) {
+	    // Mozilla
+	    node.addEventListener(eventName, fn, false);
+	} else {
+	    // IE
+	    node.attachEvent('on' + eventName, fn, false);
+	}
+	return function() {
+	    detachEvent(node, eventName, fn);
+	}
+    };
+
+    var detachEvent = function(node, eventName, fn) {
+	if (node.addEventListener) {
+	    // Mozilla
+	    node.removeEventListener(eventName, fn, false);
+	} else {
+	    // IE
+	    node.detachEvent('on' + eventName, fn, false);
+	}
+    }
+
+
+    var preventDefault = function(event) {
+	if (event.preventDefault) {
+	    event.preventDefault();
+	} else {
+	    event.returnValue = false;
+	}
+    }
+
+    var stopPropagation = function(event) {
+	if (event.stopPropagation) {
+	    event.stopPropagation();
+	} else {
+	    event.cancelBubble = true;
+	}
+    }
+
+
+    // bigBang: world dom (listof (list string string)) (arrayof handler) -> world
+    Jsworld.bigBang = function(initWorld, toplevelNode, handlers, theCaller, theRestarter, onFail) {
+	// shutdownListeners: arrayof (-> void)
+	// We maintain a list of thunks that need to be called as soon as we come out of
+	// bigBang, to do cleanup.
+	var shutdownListeners = [];
+
+	var onTermination = function(w) {
+	    for (var i = 0; i < shutdownListeners.length; i++) {
+		try { 
+		    shutdownListeners[i]();
+		} catch (e) { }
+	    }
+	    shutdownUserConfigs(function() {
+		unsetCaller();
+		theRestarter(w);
+	    });
+	}
+
+
+	//console.log('in high level big-bang');
+	errorReporter = onFail;
+
+	setCaller(theCaller);
+	setRestarter(theRestarter);
+	setTerminator(function(w) {
+		detachEvent(toplevelNode, 'click', absorber);
+		shutdownUserConfigs(function() {
+		    unsetCaller();
+		    unsetTerminator();
+		    restarter(w);
+		});
+	});
+
+	var attribs = types.EMPTY;
+	
+	// Ensure that the toplevelNode can be focused by mouse or keyboard
+	toplevelNode.tabIndex = 0;
+
+	// Absorb all click events so they don't bubble up.
+	var absorber = function(e) {
+		preventDefault(e);
+		stopPropagation(e);
+		return false;
+	}
+
+	attachEvent(toplevelNode, 'click', absorber);
+	shutdownListeners.push(function() { detachEvent(toplevelNode, 'click', absorber)});
+
+
+
+	var config = new world.Kernel.config.WorldConfig();
+	for(var i = 0; i < handlers.length; i++) {
+	    if (isList(handlers[i])) {
+		attribs = handlers[i];
+	    }
+	    else if (isHandler(handlers[i])) {
+		config = handlers[i](config);
+	    }
+	    else if ( types.isWorldConfig(handlers[i]) ) {
+		    handlers[i].startupArgs = helpers.map(expandHandler, handlers[i].startupArgs);
+		    userConfigs.push(handlers[i]); 
+	    }
+	}
+	config = config.updateAll({'changeWorld': Jsworld.updateWorld,
+				   'shutdownWorld': Jsworld.shutdownWorld});
+	var stimuli = new world.Kernel.stimuli.StimuliHandler(config, caller, restarter);
+	
+	var wrappedHandlers = [];
+	var wrappedRedraw;
+	var wrappedRedrawCss;
+	
+
+	if (config.lookup('onDraw')) {
+	    wrappedRedraw = function(w, k) {
+		try {
+		    caller(config.lookup('onDraw'), [w],
+			    function(newDomTree) {
+			    	deepUnwrapJsValues(newDomTree, function(unwrappedTree) {
+					checkWellFormedDomTree(unwrappedTree, unwrappedTree, undefined);
+					var result = [toplevelNode, 
+						      helpers.deepListToArray(unwrappedTree)];
+					k(result);
+				});
+			    });
+		} catch (e) {
+		    handleError(e);
+//		    throw e;
+		}
+	    }
+
+	    if (config.lookup('onDrawCss')) {
+		    wrappedRedrawCss = function(w, k) {
+			try {
+			    caller(config.lookup('onDrawCss'), [w],
+				    function(res) {
+					var result = helpers.deepListToArray(res);
+					result = mutateStringsInDeepArray(result);
+	//				plt.Kernel.setLastLoc(undefined);
+					k(result);
+				    });
+			} catch (e) {
+			    handleError(e);
+	//		    throw e;
+			}
+		    }
+	    }
+	    else {
+		    wrappedRedrawCss = function(w, k) { k([]); };
+	    }
+	    wrappedHandlers.push(_js.on_draw(wrappedRedraw, wrappedRedrawCss));
+	} else if (config.lookup('onRedraw')) {
+	    var reusableCanvas = undefined;
+	    var reusableCanvasNode = undefined;
+	    
+	    wrappedRedraw = function(w, k) {
+		try {
+			//console.log('in onRedraw handler');
+		    caller(config.lookup('onRedraw'), [w],
+			    function(aScene) {
+				// Performance hack: if we're using onRedraw, we know
+				// we've got a scene, so we optimize away the repeated
+				// construction of a canvas object.
+				if ( world.Kernel.isImage(aScene) ) {
+					var width = aScene.getWidth();
+					var height = aScene.getHeight();
+
+					if (! reusableCanvas) {
+						reusableCanvas = world.Kernel.makeCanvas(width, height);
+						// Note: the canvas object may itself manage objects,
+						// as in the case of an excanvas.  In that case, we must make
+						// sure jsworld doesn't try to disrupt its contents!
+						reusableCanvas.jsworldOpaque = true;
+						reusableCanvasNode = _js.node_to_tree(reusableCanvas);
+					}
+
+					reusableCanvas.width = width;
+					reusableCanvas.height = height;			
+					var ctx = reusableCanvas.getContext("2d");
+					aScene.render(ctx, 0, 0);
+
+					k([toplevelNode, reusableCanvasNode]);
+				} else {
+					k([toplevelNode, _js.node_to_tree(types.toDomNode(aScene))]);
+				}
+			   });
+		} catch (e) {
+		    handleError(e);
+//		    throw e;
+		}
+	    }
+	    
+	    wrappedRedrawCss = function(w, k) {
+		    //console.log('in RedrawCss handler');
+		k([[reusableCanvas, 
+		    ["width", reusableCanvas.width + "px"],
+		    ["height", reusableCanvas.height + "px"]]]);
+	    }
+	    wrappedHandlers.push(_js.on_draw(wrappedRedraw, wrappedRedrawCss));
+	} else {
+	    wrappedHandlers.push(_js.on_world_change
+				 (function(w, k) { 
+				     Jsworld.printWorldHook(w, toplevelNode);
+				     k();
+				 }));
+	}
+
+	if (config.lookup('tickDelay')) {
+	    var wrappedTick = function(w, k) {
+		caller(config.lookup('onTick'),
+		       [w], 
+		       k);
+	    }
+	    var wrappedDelay = jsnums.toFixnum( config.lookup('tickDelay') );
+	    wrappedHandlers.push(_js.on_tick(wrappedDelay, wrappedTick));
+	}
+
+	if (config.lookup('stopWhen')) {
+	    wrappedHandlers.push(_js.stop_when(
+			function(w, k) { 
+				caller(config.lookup('stopWhen'), [w],
+					function(res) { k(res); });
+			}));
+	}
+	
+
+	if (config.lookup('onKey')) {
+	    var wrappedKey = function(w, e, k) {
+		    caller(config.lookup('onKey'), [w, helpers.getKeyCodeName(e)], k);
+	    }
+	    wrappedHandlers.push(_js.on_key(wrappedKey));
+	    toplevelNode.focus();
+	}
+
+
+	if (config.lookup('initialEffect')) {
+	    var updaters =
+		world.Kernel.applyEffect(config.lookup('initialEffect'));
+	    for (var i = 0 ; i < updaters.length; i++) {
+		if (config.lookup('stopWhen') && 
+		    config.lookup('stopWhen')([initWorld])) {
+		    break;
+		} else {
+		    initWorld = updaters[i](initWorld);
+		}
+	    }
+	}
+	
+
+	_js.big_bang(toplevelNode,
+		     initWorld,
+		     wrappedHandlers,
+		     helpers.assocListToHash(attribs),
+		     terminator);
+
+	startUserConfigs(function() {});
+
+	return {
+	    breaker: function() {
+		handleError(types.schemeError(
+		    types.incompleteExn(types.exnBreak, 'user break', [])));
+	    }
+	};
+
+    }
+
+
+
+    var handleError = function(e) {
+//	helpers.reportError(e);
+	// When something bad happens, shut down 
+	// the world computation.
+//	helpers.reportError("Shutting down jsworld computations");
+//	world.Kernel.stimuli.onShutdown(); 
+	world.Kernel.stimuli.massShutdown();
+	shutdownUserConfigs(function() {
+	    errorReporter(e);
+//		console.log('Got an error, the error was:');
+//		console.log(e);
+		if (typeof(console) !== 'undefined' && console.log) {
+			if (e.stack) {
+				console.log(e.stack);
+			}
+			else {
+				console.log(e);
+			}
+		}
+		if ( types.isSchemeError(e) ) {
+			terminator(e);
+		}
+		else if ( types.isInternalError(e) ) {
+			terminator(e);
+		}
+		else if (typeof(e) == 'string') {
+			terminator( types.schemeError(types.incompleteExn(types.exnFail, e, [])) );
+		}
+		else if (e instanceof Error) {
+			terminator( types.schemeError(types.incompleteExn(types.exnFail, e.message, [])) );
+		}
+		else {
+			terminator( types.schemeError(e) );
+		}
+	});
+    }
+    
+
+
+    // updateWorld: CPS( CPS(world -> world) -> void )
+    Jsworld.updateWorld = function(updater, k) {
+	var wrappedUpdater = function(w, k2) {
+	    try {
+		updater(w, k2);
+	    } catch (e) {
+		if (typeof(console) !== 'undefined' && console.log && e.stack) {
+			    console.log(e.stack);
+		    }
+		handleError(e);
+//		k2(w);
+	    }
+	}
+
+	_js.change_world(wrappedUpdater, k);
+    }
+    
+
+
+    // shutdownWorld: -> void
+    // Shut down all world computations.
+    Jsworld.shutdownWorld = function() {
+	_js.shutdown();
+    };
+
+
+//    var getAttribs = function(args) {
+//	if (args.length == 0) {
+//	    return []
+//	}
+//	if (args.length == 1) {
+//	    return helpers.assocListToHash(args[0]);
+//	} else {
+//	    throw new Error("getAttribs recevied unexpected value for args: "
+//			    + args);
+//	}
+//    }
+
+
+    Jsworld.p = _js.p;
+
+    Jsworld.div = _js.div;
+
+    Jsworld.buttonBang = function(updateWorldF, effectF, attribs) {
+	var wrappedF = function(w, evt, k) {
+	    try {
+// FIXME: Get effects back online!
+//		caller(effectF, [world],
+//			function(effect) {
+			    caller(updateWorldF, [w],
+				function(newWorld) {
+//					world.Kernel.applyEffect(effect);
+					k(newWorld);
+				});
+//			});
+	    } catch (e) {
+		if (typeof(console) !== 'undefined' && console.log && e.stack) {
+			    console.log(e.stack);
+		    }
+		handleError(e);
+//		k(w);
+	    }
+	}
+	return _js.button(wrappedF, attribs);
+    };
+    
+
+    Jsworld.input = function(type, updateF, attribs) {
+	    var wrappedUpdater = function(w, evt, k) {
+		    caller(updateF, [w, evt], k);
+	    }
+	    return _js.input(type, wrappedUpdater, attribs);
+    };
+
+
+    Jsworld.get_dash_input_dash_value = function(node) {
+//	plt.Kernel.check(node, 
+//			 function(x) { return (plt.Kernel.isString(node) ||
+//					       node.nodeType == 
+//					       Node.ELEMENT_NODE) }, 
+//			 "get-input-value",
+//			 "dom-node",
+//			 1);
+	if (types.isString(node)) {
+	    return (document.getElementById(node).value || "");
+	} else {
+	    return (node.value || "");
+	}
+
+    };
+
+
+
+    // Images.
+    Jsworld.img = _js.img;
+
+    // text: string -> node
+    Jsworld.text = _js.text;
+
+    Jsworld.select = function(options, updateF, attribs) { 
+	    var wrappedUpdater = function(w, e, k) {
+//		    console.log(e);
+		    caller(updateF, [w, e.target.value], k);
+	    }
+	    return _js.select(attribs, options, wrappedUpdater);
+    };
+
+
+
+
+    //////////////////////////////////////////////////////////////////////
+    Jsworld.emptyPage = _js.emptyPage;
+
+    Jsworld.placeOnPage = function(elt, left, top, page) { 
+	deepUnwrapJsValues(elt, function(newElt) {
+	    elt = types.toDomNode(newElt);});
+ 	return _js.placeOnPage(elt, left, top, page);
+    };
+
+
+    // fixme: add support for textarea, h1, canvas
+
+
+//    // raw_node: scheme-value assoc -> node
+//    Jsworld.rawNode = function(x, args) {
+//	var attribs = getAttribs(args);
+//	var node = _js.raw_node(types.toDomNode(x), attribs);
+//	node.toWrittenString = function(cache) { return "(js-raw-node ...)"; }
+//	node.toDisplayedString = node.toWrittenString;
+//	node.toDomNode = function(cache) { return node; }
+//	return node;
+//    };
+
+
+
+})();
diff --git a/world/scratch/jsworld/private/jsworld/jsworld.js b/world/scratch/jsworld/private/jsworld/jsworld.js
new file mode 100644
index 0000000..f4d315d
--- /dev/null
+++ b/world/scratch/jsworld/private/jsworld/jsworld.js
@@ -0,0 +1,1488 @@
+var jsworld = {};
+
+// Stuff here is copy-and-pasted from Chris's JSWorld.  We
+// namespace-protect it, and add the Javascript <-> Moby wrapper
+// functions here.
+
+(function() {
+
+    /* Type signature notation
+     * CPS(a b ... -> c) is used to denote
+     *    a b ... (c -> void) -> void
+     */
+
+    jsworld.Jsworld = {};
+    var Jsworld = jsworld.Jsworld;
+
+
+    var currentFocusedNode = false;
+
+    var doNothing = function() {};
+
+
+
+    //
+    // WORLD STUFFS
+    //
+
+    function InitialWorld() {}
+
+    var world = new InitialWorld();
+    var worldListeners = [];
+    var eventDetachers = [];
+    var runningBigBangs = [];
+
+    var changingWorld = false;
+
+
+
+    // Close all world computations.
+    Jsworld.shutdown = function() {
+	while(runningBigBangs.length > 0) {
+	    var currentRecord = runningBigBangs.pop();
+	    if (currentRecord) { currentRecord.pause(); }
+	}
+	clear_running_state();
+    }
+
+
+
+    function add_world_listener(listener) {
+	worldListeners.push(listener);
+    }
+
+
+    function remove_world_listener(listener) {
+	var index = worldListeners.indexOf(listener);
+	if (index != -1) {
+	    worldListeners.splice(index, 1);
+	}
+    }
+
+    function clear_running_state() {
+	world = new InitialWorld();
+	worldListeners = [];
+
+	for (var i = 0; i < eventDetachers.length; i++) {
+		eventDetachers[i]();
+	}
+	eventDetachers = [];
+	changingWorld = false;
+    }
+
+
+    // If we're in the middle of a change_world, delay.
+    var DELAY_BEFORE_RETRY = 10;
+
+
+    // change_world: CPS( CPS(world -> world) -> void )
+    // Adjust the world, and notify all listeners.
+    var change_world = function(updater, k) {
+
+	// Check to see if we're in the middle of changing
+	// the world already.  If so, put on the queue
+	// and exit quickly.
+	if (changingWorld) {
+	    setTimeout(
+		function() {
+		    change_world(updater, k)}, 
+		DELAY_BEFORE_RETRY);
+	    return;
+	}
+
+
+	changingWorld = true;
+	var originalWorld = world;
+
+	var changeWorldHelp = function() {
+		if (world instanceof WrappedWorldWithEffects) {
+			var effects = world.getEffects();
+			helpers.forEachK(effects,
+				 function(anEffect, k2) { 
+				     anEffect.invokeEffect(change_world, k2); 
+				 },
+				 function (e) { 
+				     changingWorld = false;
+				     throw e; 
+				 },
+				 function() {
+				 	world = world.getWorld();
+					changeWorldHelp2();
+				 });
+		} else {
+			changeWorldHelp2();
+		}
+	};
+	
+	var changeWorldHelp2 = function() {
+		helpers.forEachK(worldListeners,
+				 function(listener, k2) { 
+				     listener(world, originalWorld, k2);
+				 },
+				 function(e) { 
+				     changingWorld = false;
+				     world = originalWorld;
+				     throw e; },
+				 function() {
+				     changingWorld = false;
+				     k();
+				 });
+	};
+
+	try {
+		updater(world, function(newWorld) {
+				world = newWorld;
+				changeWorldHelp();
+			});
+	} catch(e) {
+	    changingWorld = false;
+	    world = originalWorld;
+
+	    if (typeof(console) !== 'undefined' && console.log && e.stack) {
+		console.log(e.stack);
+	    }
+	    throw e;
+	}
+    }
+    Jsworld.change_world = change_world;
+
+
+
+
+    //
+    // STUFF THAT SHOULD REALLY BE IN ECMASCRIPT
+    //
+    Number.prototype.NaN0=function(){return isNaN(this)?0:this;}
+    function getPosition(e){
+	var left = 0;
+	var top  = 0;
+	while (e.offsetParent){
+	    left += e.offsetLeft + (e.currentStyle?(parseInt(e.currentStyle.borderLeftWidth)).NaN0():0);
+	    top  += e.offsetTop  + (e.currentStyle?(parseInt(e.currentStyle.borderTopWidth)).NaN0():0);
+	    e     = e.offsetParent;
+	}
+	left += e.offsetLeft + (e.currentStyle?(parseInt(e.currentStyle.borderLeftWidth)).NaN0():0);
+	top  += e.offsetTop  + (e.currentStyle?(parseInt(e.currentStyle.borderTopWidth)).NaN0():0);
+	return {x:left, y:top};	
+    }
+    Jsworld.getPosition = getPosition;
+
+
+    var gensym_counter = 0;
+    function gensym(){ return gensym_counter++;}
+    Jsworld.gensym = gensym;
+
+
+    function map(a1, f) {
+	var b = new Array(a1.length);
+	for (var i = 0; i < a1.length; i++) {
+		b[i] = f(a1[i]);
+	}
+	return b;
+    }
+    Jsworld.map = map;
+
+
+
+    function concat_map(a, f) {
+	var b = [];
+	for (var i = 0; i < a.length; i++) {
+		b = b.concat(f(a[i]));
+	}
+	return b;
+    }
+
+
+    function mapi(a, f) {
+	var b = new Array(a.length);
+	for (var i = 0; i < a.length; i++) {
+		b[i] = f(a[i], i);
+	}
+	return b;
+    }
+    Jsworld.mapi = mapi;
+
+
+    function fold(a, x, f) {
+	for (var i = 0; i < a.length; i++) {
+		x = f(a[i], x);
+	}
+	return x;
+    }
+    Jsworld.fold = fold;
+
+
+    function augment(o, a) {
+	var oo = {};
+	for (var e in o)
+	    oo[e] = o[e];
+	for (var e in a)
+	    oo[e] = a[e];
+	return oo;
+    }
+    Jsworld.augment = augment;
+
+
+    function assoc_cons(o, k, v) {
+	var oo = {};
+	for (var e in o)
+	    oo[e] = o[e];
+	oo[k] = v;
+	return oo;
+    }
+    Jsworld.assoc_cons = assoc_cons;
+
+
+    function cons(value, array) {
+	return [value].concat(array);
+    }
+    Jsworld.cons = cons;
+
+
+    function append(array1, array2){
+	return array1.concat(array2);
+    }
+    Jsworld.append = append;
+
+    function array_join(array1, array2){
+	var joined = [];
+	for (var i = 0; i < array1.length; i++)
+	    joined.push([array1[i], array2[i]]);
+	return joined;
+    }
+    Jsworld.array_join = array_join;
+
+
+    function removeq(a, value) {
+	for (var i = 0; i < a.length; i++)
+	    if (a[i] === value){
+		return a.slice(0, i).concat(a.slice(i+1));
+	    }			
+	return a;
+    }
+    Jsworld.removeq = removeq;
+
+    function removef(a, value) {
+	for (var i = 0; i < a.length; i++)
+	    if ( f(a[i]) ){
+		return a.slice(0, i).concat(a.slice(i+1));
+	    }			
+	return a;
+    }
+    Jsworld.removef = removef;
+
+
+    function filter(a, f) {
+	var b = [];
+	for (var i = 0; i < a.length; i++) {
+		if ( f(a[i]) ) {
+			b.push(a[i]);
+		}
+	}
+	return b;
+    }
+    Jsworld.filter = filter;
+
+
+    function without(obj, attrib) {
+	var o = {};
+	for (var a in obj)
+	    if (a != attrib)
+		o[a] = obj[a];
+	return o;
+    }
+    Jsworld.without = without;
+
+
+    function memberq(a, x) {
+	for (var i = 0; i < a.length; i++)
+	    if (a[i] === x) return true;
+	return false;
+    }
+    Jsworld.memberq = memberq;
+
+
+    function member(a, x) {
+	for (var i = 0; i < a.length; i++)
+	    if (a[i] == x) return true;
+	return false;
+    }
+    Jsworld.member = member;
+
+
+
+    function head(a){
+	return a[0];
+    }
+    Jsworld.head = head;
+
+
+    function tail(a){
+	return a.slice(1, a.length);
+    }
+    Jsworld.tail = tail;
+
+    //
+    // DOM UPDATING STUFFS
+    //
+
+    // tree(N): { node: N, children: [tree(N)] }
+    // relation(N): { relation: 'parent', parent: N, child: N } | { relation: 'neighbor', left: N, right: N }
+    // relations(N): [relation(N)]
+    // nodes(N): [N]
+    // css(N): [css_node(N)]
+    // css_node(N): { node: N, attribs: attribs } | { className: string, attribs: attribs }
+    // attrib: { attrib: string, values: [string] }
+    // attribs: [attrib]
+
+    // treeable(nodes(N), relations(N)) = bool
+    /*function treeable(nodes, relations) {
+    // for all neighbor relations between x and y
+    for (var i = 0; i < relations.length; i++)
+    if (relations[i].relation == 'neighbor') {
+    var x = relations[i].left, y = relations[i].right;
+ 
+    // there does not exist a neighbor relation between x and z!=y or z!=x and y
+    for (var j = 0; j < relations.length; j++)
+    if (relations[j].relation === 'neighbor')
+    if (relations[j].left === x && relations[j].right !== y ||
+    relations[j].left !== x && relations[j].right === y)
+    return false;
+    }
+ 
+    // for all parent relations between x and y
+    for (var i = 0; i < relations.length; i++)
+    if (relations[i].relation == 'parent') {
+    var x = relations[i].parent, y = relations[i].child;
+ 
+    // there does not exist a parent relation between z!=x and y
+    for (var j = 0; j < relations.length; j++)
+    if (relations[j].relation == 'parent')
+    if (relations[j].parent !== x && relations[j].child === y)
+    return false;
+    }
+ 
+    // for all neighbor relations between x and y
+    for (var i = 0; i < relations.length; i++)
+    if (relations[i].relation == 'neighbor') {
+    var x = relations[i].left, y = relations[i].right;
+ 
+    // all parent relations between z and x or y share the same z
+    for (var j = 0; j < relations.length; j++)
+    if (relations[j].relation == 'parent')
+    for (var k = 0; k < relations.length; k++)
+    if (relations[k].relation == 'parent')
+    if (relations[j].child === x && relations[k].child === y &&
+    relations[j].parent !== relations[k].parent)
+    return false;
+    }
+ 
+    return true;
+    }*/
+
+
+    // node_to_tree: dom -> dom-tree
+    // Given a native dom node, produces the appropriate tree.
+    function node_to_tree(domNode) {
+	var result = [domNode];
+	for (var c = domNode.firstChild; c != null; c = c.nextSibling) {
+	    result.push(node_to_tree(c));
+	}
+	return result;
+    }
+    Jsworld.node_to_tree = node_to_tree;
+
+
+
+    // nodes(tree(N)) = nodes(N)
+    function nodes(tree) {
+	var ret;
+	
+	if (tree.node.jsworldOpaque == true) {
+	    return [tree.node];
+	}
+
+	ret = [tree.node];
+	for (var i = 0; i < tree.children.length; i++)
+	    ret = ret.concat(nodes(tree.children[i]));
+	
+	return ret;
+    }
+
+
+    // relations(tree(N)) = relations(N)
+    function relations(tree) {
+	var ret = [];	
+
+	for (var i = 0; i < tree.children.length; i++)
+	    ret.push({ relation: 'parent', 
+		       parent: tree.node, 
+		       child: tree.children[i].node });
+	
+	for (var i = 0; i < tree.children.length - 1; i++)
+	    ret.push({ relation: 'neighbor', 
+		       left: tree.children[i].node,
+		       right: tree.children[i + 1].node });
+	
+	if (! tree.node.jsworldOpaque) {
+	    for (var i = 0; i < tree.children.length; i++) {
+		ret = ret.concat(relations(tree.children[i]));
+	    }
+	}
+	
+	return ret;
+    }
+
+
+
+    var removeAllChildren = function(n) {
+	while (n.firstChild) {
+	    n.removeChild(n.firstChild);
+	}
+    }
+
+
+    // Preorder traversal.
+    var preorder = function(node, f) {
+	f(node, function() {
+	    var child = node.firstChild;
+	    var nextSibling;
+	    while (child) {
+		var nextSibling = child.nextSibling;
+		preorder(child, f);
+		child = nextSibling;
+	    }
+	});
+    };
+
+
+    // update_dom(nodes(Node), relations(Node)) = void
+    function update_dom(toplevelNode, nodes, relations) {
+
+	// TODO: rewrite this to move stuff all in one go... possible? necessary?
+	
+	// move all children to their proper parents
+	for (var i = 0; i < relations.length; i++) {
+	    if (relations[i].relation == 'parent') {
+		var parent = relations[i].parent, child = relations[i].child;
+		if (child.parentNode !== parent) {
+		    parent.appendChild(child);
+		}
+	    }
+	}
+	
+	// arrange siblings in proper order
+	// truly terrible... BUBBLE SORT
+	var unsorted = true;
+	while (unsorted) {
+	    unsorted = false;
+	    for (var i = 0; i < relations.length; i++) {
+		if (relations[i].relation == 'neighbor') {
+		    var left = relations[i].left, right = relations[i].right;
+				
+		    if (! nodeEq(left.nextSibling, right)) {
+			left.parentNode.insertBefore(left, right)
+			unsorted = true;
+		    }
+		}
+	    }
+	}
+
+	// Finally, remove nodes that shouldn't be attached anymore.
+	var nodesPlus = nodes.concat([toplevelNode]);
+	preorder(toplevelNode, function(aNode, continueTraversalDown) {
+	    if (aNode.jsworldOpaque) {
+		if (! isMemq(aNode, nodesPlus)) {
+		    aNode.parentNode.removeChild(aNode);
+		}
+	    } else {
+		if (! isMemq(aNode, nodesPlus)) {
+		    aNode.parentNode.removeChild(aNode);
+		} else {
+		    continueTraversalDown();
+		}
+	    }
+	});
+
+	refresh_node_values(nodes);
+    }
+    
+
+    // isMemq: X (arrayof X) -> boolean
+    // Produces true if any of the elements of L are nodeEq to x.
+    var isMemq = function(x, L) {
+	var i;
+	for (i = 0 ; i < L.length; i++) {
+	    if (nodeEq(x, L[i])) {
+		return true;
+	    }
+	}
+	return false;
+    };
+
+
+    // nodeEq: node node -> boolean
+    // Returns true if the two nodes should be the same.
+    var nodeEq = function(node1, node2) {
+	return (node1 && node2 && node1 === node2);
+    }
+
+
+
+    // camelCase: string -> string
+    function camelCase(name) {
+	return name.replace(/\-(.)/g, function(m, l){return l.toUpperCase()});
+    }
+
+
+    function set_css_attribs(node, attribs) {
+	for (var j = 0; j < attribs.length; j++){
+	    node.style[camelCase(attribs[j].attrib)] = attribs[j].values.join(" ");
+	}
+    }
+
+
+    // isMatchingCssSelector: node css -> boolean
+    // Returns true if the CSS selector matches.
+    function isMatchingCssSelector(node, css) {
+	if (css.id.match(/^\./)) {
+	    // Check to see if we match the class
+	    return ('className' in node && member(node['className'].split(/\s+/),
+					      css.id.substring(1)));
+	} else {
+	    return ('id' in node && node.id == css.id);
+	}
+    }
+
+
+    function update_css(nodes, css) {
+	// clear CSS
+	for (var i = 0; i < nodes.length; i++) {
+	    if ( !nodes[i].jsworldOpaque ) {
+		    clearCss(nodes[i]);
+	    }
+	}
+	
+	// set CSS
+	for (var i = 0; i < css.length; i++)
+	    if ('id' in css[i]) {
+		for (var j = 0; j < nodes.length; j++)
+		    if (isMatchingCssSelector(nodes[j], css[i])) {
+			set_css_attribs(nodes[j], css[i].attribs);
+		    }
+	    }
+	    else set_css_attribs(css[i].node, css[i].attribs);
+    }
+
+
+    var clearCss = function(node) {
+	// FIXME: we should not be clearing the css
+// 	if ('style' in node)
+// 	    node.style.cssText = "";
+    }
+
+
+
+    // If any node cares about the world, send it in.
+    function refresh_node_values(nodes) {
+	for (var i = 0; i < nodes.length; i++) {
+	    if (nodes[i].onWorldChange) {
+		nodes[i].onWorldChange(world);
+	    }
+	}
+    }
+
+
+
+    function do_redraw(world, oldWorld, toplevelNode, redraw_func, redraw_css_func, k) {
+	if (oldWorld instanceof InitialWorld) {
+	    // Simple path
+	    redraw_func(world,
+		function(drawn) {
+			var t = sexp2tree(drawn);
+			var ns = nodes(t);
+	    		// HACK: css before dom, due to excanvas hack.
+	    		redraw_css_func(world,
+				function(css) {
+					update_css(ns, sexp2css(css));
+					update_dom(toplevelNode, ns, relations(t));
+					k();
+				});
+		});
+	} else {
+	    maintainingSelection(
+		function(k2) {
+		    // For legibility, here is the non-CPS version of the same function:
+		    /*
+			var oldRedraw = redraw_func(oldWorld);
+ 			var newRedraw = redraw_func(world);	    
+ 			var oldRedrawCss = redraw_css_func(oldWorld);
+			var newRedrawCss = redraw_css_func(world);
+			var t = sexp2tree(newRedraw);
+ 			var ns = nodes(t);
+
+			// Try to save the current selection and preserve it across
+			// dom updates.
+
+ 			if(oldRedraw !== newRedraw) {
+				// Kludge: update the CSS styles first.
+				// This is a workaround an issue with excanvas: any style change
+				// clears the content of the canvas, so we do this first before
+				// attaching the dom element.
+				update_css(ns, sexp2css(newRedrawCss));
+				update_dom(toplevelNode, ns, relations(t));
+ 			} else {
+				if(oldRedrawCss !== newRedrawCss) {
+					update_css(ns, sexp2css(newRedrawCss));
+				}
+ 			}
+		    */
+
+		    // We try to avoid updating the dom if the value
+		    // hasn't changed.
+		    redraw_func(oldWorld,
+			function(oldRedraw) {
+			    redraw_func(world,
+				function(newRedraw) {
+				    redraw_css_func(oldWorld,
+					function(oldRedrawCss) {
+					    redraw_css_func(world,
+						function(newRedrawCss) {
+						    var t = sexp2tree(newRedraw);
+						    var ns = nodes(t);
+
+						    // Try to save the current selection and preserve it across
+						    // dom updates.
+
+ 						    if(oldRedraw !== newRedraw) {
+							// Kludge: update the CSS styles first.
+							// This is a workaround an issue with excanvas: any style change
+							// clears the content of the canvas, so we do this first before
+							// attaching the dom element.
+							update_css(ns, sexp2css(newRedrawCss));
+							update_dom(toplevelNode, ns, relations(t));
+						    } else {
+							if (oldRedrawCss !== newRedrawCss) {
+							    update_css(ns, sexp2css(newRedrawCss));
+							}
+						    }
+						    k2();
+						})
+					})
+				})
+			});
+		}, k);
+	}
+    }
+
+
+    // maintainingSelection: (-> void) -> void
+    // Calls the thunk f while trying to maintain the current focused selection.
+    function maintainingSelection(f, k) {
+	var currentFocusedSelection;
+	if (hasCurrentFocusedSelection()) {
+	    currentFocusedSelection = getCurrentFocusedSelection();
+	    f(function() {
+		currentFocusedSelection.restore();
+		k();
+	    });
+	} else {
+	    f(function() { k(); });
+	}
+    }
+
+
+
+    function FocusedSelection() {
+	this.focused = currentFocusedNode;
+	this.selectionStart = currentFocusedNode.selectionStart;
+	this.selectionEnd = currentFocusedNode.selectionEnd;
+    }
+
+    // Try to restore the focus.
+    FocusedSelection.prototype.restore = function() {
+	// FIXME: if we're scrolling through, what's visible
+	// isn't restored yet.
+	if (this.focused.parentNode) {
+	    this.focused.selectionStart = this.selectionStart;
+	    this.focused.selectionEnd = this.selectionEnd;
+	    this.focused.focus();
+	} else if (this.focused.id) {
+	    var matching = document.getElementById(this.focused.id);
+	    if (matching) {
+		matching.selectionStart = this.selectionStart;
+		matching.selectionEnd = this.selectionEnd;
+		matching.focus();
+	    }
+	}
+    };
+
+    function hasCurrentFocusedSelection() {
+	return currentFocusedNode != undefined;
+    }
+
+    function getCurrentFocusedSelection() {
+	return new FocusedSelection();
+    }
+
+
+
+    //////////////////////////////////////////////////////////////////////
+
+    function BigBangRecord(top, world, handlerCreators, handlers, attribs) {    
+	this.top = top;
+	this.world = world;
+	this.handlers = handlers;
+	this.handlerCreators = handlerCreators;
+	this.attribs = attribs;
+    }
+
+    BigBangRecord.prototype.restart = function() {
+	big_bang(this.top, this.world, this.handlerCreators, this.attribs);
+    }
+    
+    BigBangRecord.prototype.pause = function() {
+	for(var i = 0 ; i < this.handlers.length; i++) {
+	    if (this.handlers[i] instanceof StopWhenHandler) {
+		// Do nothing for now.
+	    } else {
+		this.handlers[i].onUnregister(top);
+	    }
+	}
+    };
+    //////////////////////////////////////////////////////////////////////
+
+    // Notes: big_bang maintains a stack of activation records; it should be possible
+    // to call big_bang re-entrantly.
+    function big_bang(top, init_world, handlerCreators, attribs, k) {
+	// clear_running_state();
+
+	// Construct a fresh set of the handlers.
+	var handlers = map(handlerCreators, function(x) { return x();} );
+	if (runningBigBangs.length > 0) { 
+	    runningBigBangs[runningBigBangs.length - 1].pause();
+	}
+
+	// Create an activation record for this big-bang.
+	var activationRecord = 
+	    new BigBangRecord(top, init_world, handlerCreators, handlers, attribs);
+	runningBigBangs.push(activationRecord);
+	function keepRecordUpToDate(w, oldW, k2) {
+	    activationRecord.world = w;
+	    k2();
+	}
+	add_world_listener(keepRecordUpToDate);
+
+
+
+	// Monitor for termination and register the other handlers.
+	var stopWhen = new StopWhenHandler(function(w, k2) { k2(false); },
+					   function(w, k2) { k2(w); });
+	for(var i = 0 ; i < handlers.length; i++) {
+	    if (handlers[i] instanceof StopWhenHandler) {
+		stopWhen = handlers[i];
+	    } else {
+		handlers[i].onRegister(top);
+	    }
+	}
+	function watchForTermination(w, oldW, k2) {
+	    stopWhen.test(w,
+		function(stop) {
+		    if (stop) {
+			Jsworld.shutdown();
+		        k(w);
+	/*
+			stopWhen.receiver(world,
+			    function() {		    
+				var currentRecord = runningBigBangs.pop();
+				if (currentRecord) { currentRecord.pause(); }
+				if (runningBigBangs.length > 0) {
+				    var restartingBigBang = runningBigBangs.pop();
+				    restartingBigBang.restart();
+				}
+				k();
+			    });
+	*/
+		    }
+		    else { k2(); }
+		});
+	};
+	add_world_listener(watchForTermination);
+
+
+	// Finally, begin the big-bang.
+	copy_attribs(top, attribs);
+	change_world(function(w, k2) { k2(init_world); }, doNothing);
+
+
+    }
+    Jsworld.big_bang = big_bang;
+
+
+
+
+
+    // on_tick: number CPS(world -> world) -> handler
+    function on_tick(delay, tick) {
+	return function() {
+	    var scheduleTick, ticker;
+
+
+	    (new Date()).valueOf()
+
+	    scheduleTick = function(t) {
+		ticker.watchId = setTimeout(
+		    function() { 
+			ticker.watchId = undefined;
+			var startTime = (new Date()).valueOf();
+			change_world(tick, 
+				     function() { 
+					 var endTime = (new Date()).valueOf();
+					 scheduleTick(Math.max(delay - (endTime - startTime),
+							       0)); 
+				     }); 
+		    },
+		    t);
+	    };
+	    
+	    ticker = {
+		watchId: -1,
+		onRegister: function (top) { 
+		    scheduleTick(delay);
+		},
+
+		onUnregister: function (top) {
+		    if (ticker.watchId)
+			clearTimeout(ticker.watchId);
+		}
+	    };
+	    return ticker;
+	};
+    }
+    Jsworld.on_tick = on_tick;
+
+
+    function on_key(press) {
+	return function() {
+	    var wrappedPress = function(e) {
+		    preventDefault(e);
+		    stopPropagation(e);
+		    change_world(function(w, k) { press(w, e, k); }, doNothing);
+	    };
+	    return {
+		onRegister: function(top) { attachEvent(top, 'keydown', wrappedPress); },
+		onUnregister: function(top) { detachEvent(top, 'keydown', wrappedPress); }
+	    };
+	}
+    }
+    Jsworld.on_key = on_key;
+
+
+    
+    //  on_draw: CPS(world -> (sexpof node)) CPS(world -> (sexpof css-style)) -> handler
+    function on_draw(redraw, redraw_css) {
+	var wrappedRedraw = function(w, k) {
+	    redraw(w, function(newDomTree) {
+	    	checkDomSexp(newDomTree, newDomTree);
+	    	k(newDomTree);
+	    });
+	}
+
+	return function() {
+	    var drawer = {
+		_top: null,
+		_listener: function(w, oldW, k2) { 
+		    do_redraw(w, oldW, drawer._top, wrappedRedraw, redraw_css, k2); 
+		},
+		onRegister: function (top) { 
+		    drawer._top = top;
+		    add_world_listener(drawer._listener);
+		},
+
+		onUnregister: function (top) {
+		    remove_world_listener(drawer._listener);
+		}
+	    };
+	    return drawer;
+	};
+    }
+    Jsworld.on_draw = on_draw;
+
+
+
+    function StopWhenHandler(test, receiver) {
+	this.test = test;
+	this.receiver = receiver;
+    }
+    // stop_when: CPS(world -> boolean) CPS(world -> boolean) -> handler
+    function stop_when(test, receiver) {
+	return function() {
+	    if (receiver == undefined) {
+		receiver = function(w, k) { k(w); };
+	    }
+	    return new StopWhenHandler(test, receiver);
+	};
+    }
+    Jsworld.stop_when = stop_when;
+
+
+
+    function on_world_change(f) {
+	var listener = function(world, oldW, k) { f(world, k); };
+	return function() {
+	    return { 
+		onRegister: function (top) { 
+		    add_world_listener(listener); },
+		onUnregister: function (top) {
+		    remove_world_listener(listener)}
+	    };
+	};
+    }
+    Jsworld.on_world_change = on_world_change;
+
+
+
+
+
+    // Compatibility for attaching events to nodes.
+    function attachEvent(node, eventName, fn) {
+	if (node.addEventListener) {
+	    // Mozilla
+	    node.addEventListener(eventName, fn, false);
+	} else {
+	    // IE
+	    node.attachEvent('on' + eventName, fn, false);
+	}
+    }
+
+    var detachEvent = function(node, eventName, fn) {
+	if (node.addEventListener) {
+	    // Mozilla
+	    node.removeEventListener(eventName, fn, false);
+	} else {
+	    // IE
+	    node.detachEvent('on' + eventName, fn, false);
+	}
+    }
+
+    //
+    // DOM CREATION STUFFS
+    //
+
+    // add_ev: node string CPS(world event -> world) -> void
+    // Attaches a world-updating handler when the world is changed.
+    function add_ev(node, event, f) {
+	var eventHandler = function(e) { change_world(function(w, k) { f(w, e, k); },
+						       doNothing); };
+	attachEvent(node, event, eventHandler);
+	eventDetachers.push(function() { detachEvent(node, event, eventHandler); });
+    }
+
+    // add_ev_after: node string CPS(world event -> world) -> void
+    // Attaches a world-updating handler when the world is changed, but only
+    // after the fired event has finished.
+    function add_ev_after(node, event, f) {
+	var eventHandler = function(e) {
+		setTimeout(function() { change_world(function(w, k) { f(w, e, k); },
+						     doNothing); },
+			   0);
+	};
+
+	attachEvent(node, event, eventHandler);
+	eventDetachers.push(function() { detachEvent(node, event, eventHandler); });
+    }
+
+
+    function addFocusTracking(node) {
+	attachEvent(node, "focus", function(e) {
+	    currentFocusedNode = node; });
+	attachEvent(node, "blur", function(e) {
+	    currentFocusedNode = undefined;
+	});
+	return node;
+    }
+
+
+
+
+
+    //
+    // WORLD STUFFS
+    //
+
+
+    function sexp2tree(sexp) {
+	if (isPage(sexp)) {
+	    return sexp2tree(node_to_tree(sexp.toDomNode()));
+	} else {
+	    if(sexp.length == undefined) return { node: sexp, children: [] };
+	    else return { node: sexp[0], children: map(sexp.slice(1), sexp2tree) };
+	}
+    }
+
+    function sexp2attrib(sexp) {
+	return { attrib: sexp[0], values: sexp.slice(1) };
+    }
+
+    function sexp2css_node(sexp) {
+	var attribs = map(sexp.slice(1), sexp2attrib);
+	if (typeof sexp[0] == 'string'){
+	    return [{ id: sexp[0], attribs: attribs }];
+	} else if ('length' in sexp[0]){
+	    return map(sexp[0], function (id) { return { id: id, attribs: attribs } });
+	} else {
+	    return [{ node: sexp[0], attribs: attribs }];
+	}
+    }
+
+    function sexp2css(sexp) {
+	return concat_map(sexp, sexp2css_node);
+    }
+
+
+
+    function isTextNode(n) {
+	return (n.nodeType == Node.TEXT_NODE);
+    }
+
+
+    function isElementNode(n) {
+	return (n.nodeType == Node.ELEMENT_NODE);
+    }
+
+
+    var throwDomError = function(thing, topThing) {
+	throw new JsworldDomError(
+	    helpers.format(
+		"Expected a non-empty array, received ~s within ~s",
+		[thing, topThing]),
+	    thing);
+    };
+
+    // checkDomSexp: X X -> boolean
+    // Checks to see if thing is a DOM-sexp.  If not,
+    // throws an object that explains why not.
+    function checkDomSexp(thing, topThing) {
+	if (isPage(thing)) {
+	    return;
+	}
+
+	if (! thing instanceof Array) {
+	    throwDomError(thing, topThing);
+	}
+	if (thing.length == 0) {
+	    throwDomError(thing, topThing);
+	}
+
+	// Check that the first element is a Text or an element.
+	if (isTextNode(thing[0])) {
+	    if (thing.length > 1) {
+		throw new JsworldDomError(helpers.format("Text node ~s can not have children",
+							 [thing]),
+					  thing);
+	    }
+	} else if (isElementNode(thing[0])) {
+	    for (var i = 1; i < thing.length; i++) {
+		checkDomSexp(thing[i], thing);
+	    }
+	} else {
+	    throw new JsworldDomError(
+		helpers.format(
+		    "expected a Text or an Element, received ~s within ~s",
+		    [thing, topThing]),
+		thing[0]);
+	}
+    }
+
+    function JsworldDomError(msg, elt) {
+	this.msg = msg;
+	this.elt = elt;
+    }
+    JsworldDomError.prototype.toString = function() {
+	return "on-draw: " + this.msg;
+    }
+
+
+
+
+
+    //
+    // DOM CREATION STUFFS
+    //
+
+
+    function copy_attribs(node, attribs) {
+	if (attribs)
+	    for (a in attribs) {
+		if (attribs.hasOwnProperty(a)) {
+		    if (typeof attribs[a] == 'function')
+			add_ev(node, a, attribs[a]);
+		    else{
+			node[a] = attribs[a];//eval("node."+a+"='"+attribs[a]+"'");
+		    }
+		}
+	    }
+	return node;
+    }
+
+
+    //
+    // NODE TYPES
+    //
+
+    function p(attribs) {
+	return addFocusTracking(copy_attribs(document.createElement('p'), attribs));
+    }
+    Jsworld.p = p;
+
+    function div(attribs) {
+	return addFocusTracking(copy_attribs(document.createElement('div'), attribs));
+    }
+    Jsworld.div = div;
+
+    // Used To Be: (world event -> world) (hashof X Y) -> domElement
+    // Now: CPS(world event -> world) (hashof X Y) -> domElement
+    function button(f, attribs) {
+	var n = document.createElement('button');
+	n.onclick = function(e) {return false;};
+	add_ev(n, 'click', f);
+	return addFocusTracking(copy_attribs(n, attribs));
+    }
+    Jsworld.button = button;
+
+
+
+
+    var preventDefault = function(event) {
+	if (event.preventDefault) {
+	    event.preventDefault();
+	} else {
+	    event.returnValue = false;
+	}
+    }
+
+    var stopPropagation = function(event) {
+	if (event.stopPropagation) {
+	    event.stopPropagation();
+	} else {
+	    event.cancelBubble = true;
+	}
+    }
+
+
+    var stopClickPropagation = function(node) {
+	attachEvent(node, "click",
+		    function(e) {
+			stopPropagation(e);
+		    });
+	return node;
+    }
+    
+
+    // input: string CPS(world -> world) 
+    function input(aType, updateF, attribs) {
+	aType = aType.toLowerCase();
+	var dispatchTable = { text : text_input,
+			      password: text_input,
+			      checkbox: checkbox_input
+			      //button: button_input,
+			      //radio: radio_input 
+	};
+
+	if (dispatchTable[aType]) {
+	    return (dispatchTable[aType])(aType, updateF, attribs);
+	}
+	else {
+	    throw new Error("js-input: does not currently support type " + aType);
+	}
+    }
+    Jsworld.input = input;
+
+
+
+
+    var text_input = function(type, updateF, attribs) {
+	var n = document.createElement('input');
+	n.type = type;
+
+	var lastVal = n.value;
+	var onEvent = function() {
+	    if (! n.parentNode) { return; }
+	    setTimeout(
+		function() {
+		    if (lastVal != n.value) {
+			lastVal = n.value;
+			change_world(function (w, k) {
+			    updateF(w, n.value, k);
+			}, doNothing);
+		    }
+		},
+		0);
+	}
+
+
+// 	attachEvent(n, "keypress", onEvent);
+// 	eventDetachers.push(function() {
+// 	    detachEvent(n, "keypress", onEvent); });
+
+	attachEvent(n, "keydown", onEvent);
+	eventDetachers.push(function() {
+	    detachEvent(n, "keydown", onEvent); });
+
+	attachEvent(n, "change", onEvent);
+	eventDetachers.push(function() {
+	    detachEvent(n, "change", onEvent); });
+
+// 	function onKey(w, e, k) {
+// 	    updateF(w, n.value, k);
+// 	}
+// 	// This established the widget->world direction
+// 	add_ev_after(n, 'keypress', onKey);
+
+	// Every second, do a manual polling of the object, just in case.
+// 	var delay = 1000;
+// 	var intervalId = setInterval(function() {
+// 	    if (! n.parentNode) {
+// 		clearInterval(intervalId);
+// 		return;
+// 	    }
+// 	    if (lastVal != n.value) {
+// 		lastVal = n.value;
+// 		change_world(function (w, k) {
+// 		    updateF(w, n.value, k);
+// 		}, doNothing);
+// 	    }
+// 	},
+// 		    delay);
+	return stopClickPropagation(
+	    addFocusTracking(copy_attribs(n, attribs)));
+    };
+
+
+    var checkbox_input = function(type, updateF, attribs) {
+	var n = document.createElement('input');
+	n.type = type;
+	var onCheck = function(w, e, k) {
+	    updateF(w, n.checked, k);
+	};
+	// This established the widget->world direction
+	add_ev_after(n, 'change', onCheck);
+	
+ 	attachEvent(n, 'click', function(e) {
+ 	    stopPropagation(e);
+ 	});
+
+	return copy_attribs(n, attribs);
+    };
+
+
+    var button_input = function(type, updateF, attribs) {
+	var n = document.createElement('button');
+	add_ev(n, 'click', function(w, e, k) { updateF(w, n.value, k); });
+	return addFocusTracking(copy_attribs(n, attribs));
+    };
+
+
+
+    
+
+    function text(s, attribs) {
+	var result = document.createElement("div");
+	result.appendChild(document.createTextNode(String(s)));
+	result.jsworldOpaque = true;
+	return result;
+    }
+    Jsworld.text = text;
+
+    function select(attribs, opts, f){
+	var n = document.createElement('select');
+	for(var i = 0; i < opts.length; i++) {
+	    n.add(option({value: opts[i]}), null);
+	}
+	n.jsworldOpaque = true;
+	add_ev(n, 'change', f);
+	var result = addFocusTracking(copy_attribs(n, attribs));
+	return result;
+    }
+    Jsworld.select = select;
+
+    function option(attribs){
+	var node = document.createElement("option");
+        node.text = attribs.value;
+	node.value = attribs.value;
+ 	return node;
+    }
+
+
+
+    function textarea(attribs){
+	return addFocusTracking(copy_attribs(document.createElement('textarea'), attribs));
+    }
+    Jsworld.textarea = textarea;
+
+    function h1(attribs){
+	return addFocusTracking(copy_attribs(document.createElement('h1'), attribs));
+    }
+    Jsworld.h1 = h1;
+
+    function canvas(attribs){
+	return addFocusTracking(copy_attribs(document.createElement('canvas'), attribs));	
+    }
+    Jsworld.canvas = canvas;
+
+
+    function img(src, attribs) {
+	var n = document.createElement('img');
+	n.src = src;
+	return addFocusTracking(copy_attribs(n, attribs));
+    }
+    Jsworld.img = img;
+
+
+
+    function raw_node(node, attribs) {
+	return addFocusTracking(copy_attribs(node, attribs));
+    }
+    Jsworld.raw_node = raw_node;
+
+
+
+
+
+    //////////////////////////////////////////////////////////////////////
+    //////////////////////////////////////////////////////////////////////
+    // Effects
+
+    // An effect is an object with an invokeEffect() method.
+    
+    var WrappedWorldWithEffects = function(w, effects) {
+	if (w instanceof WrappedWorldWithEffects) {
+	    this.w = w.w;
+	    this.e = w.e.concat(effects);
+	} else {
+	    this.w = w;
+	    this.e = effects;
+	}
+    };
+
+    WrappedWorldWithEffects.prototype.getWorld = function() {
+	return this.w;
+    };
+
+    WrappedWorldWithEffects.prototype.getEffects = function() {
+	return this.e;
+    };
+
+
+    //////////////////////////////////////////////////////////////////////
+
+    Jsworld.with_effect = function(w, e) {
+	return new WrappedWorldWithEffects(w, [e]);
+    };
+
+    Jsworld.with_multiple_effects = function(w, effects) {
+	return new WrappedWorldWithEffects(w, effects);
+    };
+
+    Jsworld.has_effects = function(w) {
+	return w instanceof WrappedWorldWithEffects;
+    };
+
+
+
+
+    //////////////////////////////////////////////////////////////////////
+    // Example effect: raise an alert.
+    Jsworld.alert_effect = function(msg) {
+	return new AlertEffect(msg);
+    };
+
+    var AlertEffect = function(msg) {
+	this.msg = msg;
+    };
+
+    AlertEffect.prototype.invokeEffect = function(k) {
+	alert(this.msg);
+	k();
+    };
+
+
+    //////////////////////////////////////////////////////////////////////
+
+
+    // Example effect: play a song, given its url
+    Jsworld.music_effect = function(musicUrl) {
+	return new MusicEffect(musicUrl);
+    };
+
+    var MusicEffect = function(musicUrl) {
+	this.musicUrl = musicUrl;
+    };
+
+    MusicEffect.prototype.invokeEffect = function(k) {
+	new Audio(url).play();
+	k();
+    };
+
+
+
+
+
+    //////////////////////////////////////////////////////////////////////
+    // Pages
+
+
+    var Page = function(elts, attribs) {
+	if (typeof(elts) === 'undefined') { 
+	    elts = [];
+	}
+	this.elts = elts;
+	this.attribs = attribs;
+    };
+
+    Page.prototype.add = function(elt, positionLeft, positionTop) {
+	return new Page(this.elts.concat([{elt: elt, 
+					   positionTop: positionTop,
+					   positionLeft: positionLeft}]),
+			this.attribs);
+    };
+
+    Page.prototype.toDomNode = function() {
+	var aDiv = div();
+	for (var i = 0 ; i < this.elts.length; i++) {
+	    var elt = this.elts[i].elt;
+	    if (! elt.style) {
+		elt.style = '';
+	    }
+
+	    elt.style.position = 'absolute';
+	    elt.style.left = this.elts[i].positionLeft + "px";
+	    elt.style.top = this.elts[i].positionTop + "px";	    
+	    aDiv.appendChild(elt);
+	};
+	copy_attribs(aDiv, this.attribs)
+	return aDiv;
+    };
+
+
+    isPage = function(x) {
+	return x instanceof Page;
+    };
+
+    Jsworld.isPage = isPage;
+
+    Jsworld.emptyPage = function(attribs) {
+	var result = new Page([], attribs);
+	return result;
+    };
+
+    Jsworld.placeOnPage = function(elt, positionLeft, positionTop, page) {
+	if (typeof(elt) === 'string') {
+	    elt = text(elt);
+	}
+	return page.add(elt, positionLeft, positionTop);
+    };
+
+
+
+})();
diff --git a/world/scratch/world/compiled/kernel_rkt.dep b/world/scratch/world/compiled/kernel_rkt.dep
new file mode 100644
index 0000000..63c7550
--- /dev/null
+++ b/world/scratch/world/compiled/kernel_rkt.dep
@@ -0,0 +1 @@
+("5.1.1" ("20b08da4180281e3468edf47b1d9c436989a35c2" . "c5c6223485c4a0496ad4df78dd013eb9a4700ebb") #"/home/dyoo/work/js-vm/world/../lang/js-impl/js-impl.rkt" (collects #"s-exp" #"lang" #"reader.rkt"))
diff --git a/world/scratch/world/compiled/kernel_rkt.zo b/world/scratch/world/compiled/kernel_rkt.zo
new file mode 100644
index 0000000..8e695be
Binary files /dev/null and b/world/scratch/world/compiled/kernel_rkt.zo differ
diff --git a/world/scratch/world/kernel.js b/world/scratch/world/kernel.js
new file mode 100644
index 0000000..c0b51f9
--- /dev/null
+++ b/world/scratch/world/kernel.js
@@ -0,0 +1,1938 @@
+var world = {};
+world.Kernel = {};
+
+EXPORTS['kernel'] = world.Kernel;
+
+
+
+
+
+var worldListeners = [];
+var stopped;
+var timerInterval = false;
+
+
+// Inheritance from pg 168: Javascript, the Definitive Guide.
+var heir = function(p) {
+    var f = function() {}
+    f.prototype = p;
+    return new f();
+}
+
+
+// clone: object -> object
+// Copies an object.  The new object should respond like the old
+// object, including to things like instanceof
+var clone = function(obj) {
+    var C = function() {}
+    C.prototype = obj;
+    var c = new C();
+    for (property in obj) {
+	if (obj.hasOwnProperty(property)) {
+	    c[property] = obj[property];
+	}
+    }
+    return c;
+};
+
+
+
+
+var announceListeners = [];
+world.Kernel.addAnnounceListener = function(listener) {
+    announceListeners.push(listener);
+};
+world.Kernel.removeAnnounceListener = function(listener) {
+    var idx = announceListeners.indexOf(listener);
+    if (idx != -1) {
+	announceListeners.splice(idx, 1);
+    }
+};
+world.Kernel.announce = function(eventName, vals) {
+    for (var i = 0; i < announceListeners.length; i++) {
+	try {
+	    announceListeners[i](eventName, vals);
+	} catch (e) {}
+    }
+};
+
+
+
+
+
+
+
+
+
+
+// changeWorld: world -> void
+// Changes the current world to newWorld.
+var changeWorld = function(newWorld) {
+    world = newWorld;
+    notifyWorldListeners();
+}
+
+
+// updateWorld: (world -> world) -> void
+// Public function: update the world, given the old state of the
+// world.
+world.Kernel.updateWorld = function(updater) {
+    var newWorld = updater(world);
+    changeWorld(newWorld);
+}
+
+
+world.Kernel.shutdownWorld = function() {
+    stopped = true;
+};
+
+
+// notifyWorldListeners: -> void
+// Tells all of the world listeners that the world has changed.
+var notifyWorldListeners = function() {
+    var i;
+    for (i = 0; i < worldListeners.length; i++) {
+	worldListeners[i](world);
+    }
+}
+
+// addWorldListener: (world -> void) -> void
+// Adds a new world listener: whenever the world is changed, the aListener
+// will be called with that new world.
+var addWorldListener = function(aListener) {
+    worldListeners.push(aListener);
+}
+
+
+// getKeyCodeName: keyEvent -> String
+// Given an event, try to get the name of the key.
+var getKeyCodeName = function(e) {
+    var code = e.charCode || e.keyCode;
+    var keyname;
+    if (code == 37) {
+	keyname = "left";
+    } else if (code == 38) {
+	keyname = "up";
+    } else if (code == 39) {
+	keyname = "right";
+    } else if (code == 40) {
+	keyname = "down";
+    } else {
+	keyname = String.fromCharCode(code); 
+    }
+    return keyname;
+}
+
+
+// resetWorld: -> void
+// Resets all of the world global values.
+var resetWorld = function() {
+    if (timerInterval) {
+	clearInterval(timerInterval);
+	timerInterval = false;
+    }
+    stopped = false;
+    worldListeners = [];
+}
+
+
+var getBigBangWindow = function(width, height) {
+    if (window.document.getElementById("canvas") != undefined) {
+	return window;
+    }
+
+    var newWindow = window.open(
+	"big-bang.html",
+	"big-bang");
+    //"toolbar=false,location=false,directories=false,status=false,menubar=false,width="+width+",height="+height);
+    if (newWindow == null) { 
+        throw new Error("Error: Not allowed to create a new window."); }
+
+    return newWindow;
+}
+
+
+
+// scheduleTimerTick: -> void
+// Repeatedly schedules an evaluation of the onTick until the program has stopped.
+var scheduleTimerTick = function(window, config) {
+    timerInterval = window.setInterval(
+	function() {
+	    if (stopped) {
+		window.clearTimeout(timerInterval);
+		timerInterval = false;
+	    }
+	    else {
+		world.Kernel.stimuli.onTick();
+	    }
+	},
+	config.lookup('tickDelay'));
+}
+
+
+
+
+// Base class for all images.
+var BaseImage = function(pinholeX, pinholeY) {
+    this.pinholeX = pinholeX;
+    this.pinholeY = pinholeY;
+}
+world.Kernel.BaseImage = BaseImage;
+
+
+var isImage = function(thing) {
+    return (thing !== null &&
+	    thing !== undefined &&
+	    thing instanceof BaseImage);
+}
+
+
+
+BaseImage.prototype.updatePinhole = function(x, y) {
+    var aCopy = clone(this);
+    aCopy.pinholeX = x;
+    aCopy.pinholeY = y;
+    return aCopy;
+};
+
+
+
+// render: context fixnum fixnum: -> void
+// Render the image, where the upper-left corner of the image is drawn at
+// (x, y).
+// NOTE: the rendering should be oblivous to the pinhole.
+BaseImage.prototype.render = function(ctx, x, y) {
+    throw new Error('BaseImage.render unimplemented!');
+    //	plt.Kernel.throwMobyError(
+    //	    false, 
+    //	    "make-moby-error-type:generic-runtime-error", 
+    //	    "Unimplemented method render");
+};
+
+
+// makeCanvas: number number -> canvas
+// Constructs a canvas object of a particular width and height.
+world.Kernel.makeCanvas = function(width, height) {
+    var canvas = document.createElement("canvas");
+    canvas.width = width;
+    canvas.height = height;
+
+    canvas.style.width = canvas.width + "px";
+    canvas.style.height = canvas.height + "px";
+    
+    // KLUDGE: IE compatibility uses /js/excanvas.js, and dynamic
+    // elements must be marked this way.
+    if (window && typeof window.G_vmlCanvasManager != 'undefined') {
+	canvas = window.G_vmlCanvasManager.initElement(canvas);
+    }
+    return canvas;
+};
+
+
+
+var withIeHack = function(canvas, f) {
+    // 	canvas.style.display = 'none';
+    // 	document.body.appendChild(canvas);
+    // 	try {
+    var result = f(canvas);
+    // 	} catch(e) {
+    // 	    document.body.removeChild(canvas);
+    // 	    canvas.style.display = '';
+    // 	    throw e;
+    // 	}
+    // 	document.body.removeChild(canvas);
+    // 	canvas.style.display = '';
+    return result;
+};
+
+
+BaseImage.prototype.toDomNode = function(cache) {
+    var that = this;
+    var width = that.getWidth();
+    var height = that.getHeight();
+    var canvas = world.Kernel.makeCanvas(width, height);
+
+    // KLUDGE: on IE, the canvas rendering functions depend on a
+    // context where the canvas is attached to the DOM tree.
+
+    // We initialize an afterAttach hook; the client's responsible
+    // for calling this after the dom node is attached to the
+    // document.
+    canvas.afterAttach = function() {
+	var ctx = canvas.getContext("2d");
+	that.render(ctx, 0, 0);
+    };
+
+    return canvas;
+};
+
+
+
+
+BaseImage.prototype.toWrittenString = function(cache) { return "<image>"; }
+BaseImage.prototype.toDisplayedString = function(cache) { return "<image>"; }
+
+BaseImage.prototype.isEqual = function(other, aUnionFind) {
+    return (this.pinholeX == other.pinholeX &&
+	    this.pinholeY == other.pinholeY);
+};
+
+
+
+
+// isScene: any -> boolean
+// Produces true when x is a scene.
+var isScene = function(x) {
+    return ((x != undefined) && (x != null) && (x instanceof SceneImage));
+};
+
+// SceneImage: primitive-number primitive-number (listof image) -> Scene
+var SceneImage = function(width, height, children, withBorder) {
+    BaseImage.call(this, 0, 0);
+    this.width = width;
+    this.height = height;
+    this.children = children; // arrayof [image, number, number]
+    this.withBorder = withBorder;
+}
+SceneImage.prototype = heir(BaseImage.prototype);
+
+
+// add: image primitive-number primitive-number -> Scene
+SceneImage.prototype.add = function(anImage, x, y) {
+    return new SceneImage(this.width, 
+			  this.height,
+			  this.children.concat([[anImage, 
+						 x - anImage.pinholeX, 
+						 y - anImage.pinholeY]]),
+			  this.withBorder);
+};
+
+// render: 2d-context primitive-number primitive-number -> void
+SceneImage.prototype.render = function(ctx, x, y) {
+    var i;
+    var childImage, childX, childY;
+    // Clear the scene.
+    ctx.clearRect(x, y, this.width, this.height);
+    // Then ask every object to render itself.
+    for(i = 0; i < this.children.length; i++) {
+	childImage = this.children[i][0];
+	childX = this.children[i][1];
+	childY = this.children[i][2];
+	ctx.save();
+	childImage.render(ctx, childX + x, childY + y);
+	ctx.restore();
+
+
+    }
+    // Finally, draw the black border if withBorder is true
+    if (this.withBorder) {
+	ctx.strokeStyle = 'black';
+	ctx.strokeRect(x, y, this.width, this.height);
+    }
+};
+
+SceneImage.prototype.getWidth = function() {
+    return this.width;
+};
+
+SceneImage.prototype.getHeight = function() {
+    return this.height;
+};
+
+SceneImage.prototype.isEqual = function(other, aUnionFind) {
+    if (!(other instanceof SceneImage)) {
+	return false;
+    } 
+
+    if (this.pinholeX != other.pinholeX ||
+	this.pinholeY != other.pinholeY ||
+	this.width != other.width ||
+	this.height != other.height ||
+	this.children.length != other.children.length) {
+	return false;
+    }
+
+    for (var i = 0; i < this.children.length; i++) {
+	var rec1 = this.children[i];
+	var rec2 = other.children[i];
+	if (rec1[1] !== rec2[1] ||
+	    rec1[2] !== rec2[2] ||
+	    !types.isEqual(rec1[0], 
+			   rec2[0],
+			   aUnionFind)) {
+	    return false;
+ 	}
+    }
+    return true;
+};
+
+
+//////////////////////////////////////////////////////////////////////
+
+
+var FileImage = function(src, rawImage) {
+    BaseImage.call(this, 0, 0);
+    var self = this;
+    this.src = src;
+    this.isLoaded = false;
+    if (rawImage && rawImage.complete) { 
+	this.img = rawImage;
+	this.isLoaded = true;
+	this.pinholeX = self.img.width / 2;
+	this.pinholeY = self.img.height / 2;
+    } else {
+	// fixme: we may want to do something blocking here for
+	// onload, since we don't know at this time what the file size
+	// should be, nor will drawImage do the right thing until the
+	// file is loaded.
+	this.img = new Image();
+	this.img.onload = function() {
+	    self.isLoaded = true;
+	    self.pinholeX = self.img.width / 2;
+	    self.pinholeY = self.img.height / 2;
+	};
+	this.img.onerror = function(e) {
+	    self.img.onerror = "";
+	    self.img.src = "http://www.wescheme.org/images/broken.png";
+	}
+	this.img.src = src;
+    }
+}
+FileImage.prototype = heir(BaseImage.prototype);
+//    world.Kernel.FileImage = FileImage;
+
+
+var imageCache = {};
+FileImage.makeInstance = function(path, rawImage) {
+    if (! (path in imageCache)) {
+	imageCache[path] = new FileImage(path, rawImage);
+    } 
+    return imageCache[path];
+};
+
+FileImage.installInstance = function(path, rawImage) {
+    imageCache[path] = new FileImage(path, rawImage);
+};
+
+FileImage.installBrokenImage = function(path) {
+    imageCache[path] = new TextImage("Unable to load " + path, 10, 
+				     colorDb.get("red"));
+};
+
+
+
+FileImage.prototype.render = function(ctx, x, y) {
+    ctx.drawImage(this.img, x, y);
+};
+
+
+FileImage.prototype.getWidth = function() {
+    return this.img.width;
+};
+
+
+FileImage.prototype.getHeight = function() {
+    return this.img.height;
+};
+
+// Override toDomNode: we don't need a full-fledged canvas here.
+FileImage.prototype.toDomNode = function(cache) {
+    return this.img.cloneNode(true);
+};
+
+FileImage.prototype.isEqual = function(other, aUnionFind) {
+    return (other instanceof FileImage &&
+	    this.pinholeX == other.pinholeX &&
+	    this.pinholeY == other.pinholeY &&
+	    this.src == other.src);
+    //		    types.isEqual(this.img, other.img, aUnionFind));
+};
+
+
+//////////////////////////////////////////////////////////////////////
+
+
+// OverlayImage: image image -> image
+// Creates an image that overlays img1 on top of the
+// other image.  shiftX and shiftY are deltas off the first
+// image's pinhole.
+var OverlayImage = function(img1, img2, shiftX, shiftY) {
+    var deltaX = img1.pinholeX - img2.pinholeX + shiftX;
+    var deltaY = img1.pinholeY - img2.pinholeY + shiftY;
+    var left = Math.min(0, deltaX);
+    var top = Math.min(0, deltaY);
+    var right = Math.max(deltaX + img2.getWidth(), 
+			 img1.getWidth());
+    var bottom = Math.max(deltaY + img2.getHeight(),
+			  img1.getHeight());
+
+    BaseImage.call(this, 
+		   Math.floor((right-left) / 2),
+		   Math.floor((bottom-top) / 2));
+    this.img1 = img1;
+    this.img2 = img2;
+    this.width = right - left;
+    this.height = bottom - top;
+
+    this.img1Dx = -left;
+    this.img1Dy = -top;
+    this.img2Dx = deltaX - left;	
+    this.img2Dy = deltaY - top;
+};
+
+OverlayImage.prototype = heir(BaseImage.prototype);
+
+
+OverlayImage.prototype.render = function(ctx, x, y) {
+    this.img2.render(ctx, x + this.img2Dx, y + this.img2Dy);
+    this.img1.render(ctx, x + this.img1Dx, y + this.img1Dy);
+};
+
+
+OverlayImage.prototype.getWidth = function() {
+    return this.width;
+};
+
+OverlayImage.prototype.getHeight = function() {
+    return this.height;
+};
+
+OverlayImage.prototype.isEqual = function(other, aUnionFind) {
+    return ( other instanceof OverlayImage &&
+	     this.pinholeX == other.pinholeX &&
+	     this.pinholeY == other.pinholeY &&
+	     this.width == other.width &&
+	     this.height == other.height &&
+	     this.img1Dx == other.img1Dx &&
+	     this.img1Dy == other.img1Dy &&
+	     this.img2Dx == other.img2Dx &&
+	     this.img2Dy == other.img2Dy &&
+	     types.isEqual(this.img1, other.img1, aUnionFind) &&
+	     types.isEqual(this.img2, other.img2, aUnionFind) );
+};
+
+
+//////////////////////////////////////////////////////////////////////
+
+
+// rotate: angle image -> image
+// Rotates image by angle degrees in a counter-clockwise direction.
+// based on http://stackoverflow.com/questions/3276467/adjusting-div-width-and-height-after-rotated
+var RotateImage = function(angle, img) {
+    var sin   = Math.sin(angle * Math.PI / 180),
+		cos   = Math.cos(angle * Math.PI / 180);
+	
+	// (w,0) rotation
+	var x1 = Math.floor(cos * img.getWidth()),
+		y1 = Math.floor(sin * img.getWidth());
+	
+	// (0,h) rotation
+	var x2 = Math.floor(-sin * img.getHeight()),
+		y2 = Math.floor( cos * img.getHeight());
+	
+	// (w,h) rotation
+	var x3 = Math.floor(cos * img.getWidth() - sin * img.getHeight()),
+		y3 = Math.floor(sin * img.getWidth() + cos * img.getHeight());
+	
+	var minX = Math.min(0, x1, x2, x3),
+		maxX = Math.max(0, x1, x2, x3),
+		minY = Math.min(0, y1, y2, y3),
+		maxY = Math.max(0, y1, y2, y3);
+	
+	var rotatedWidth  = maxX - minX,
+		rotatedHeight = maxY - minY;
+	
+	// resize the image
+    BaseImage.call(this, 
+				   Math.floor(rotatedWidth / 2),
+				   Math.floor(rotatedHeight / 2));
+		
+	this.img	= img;
+	this.width	= rotatedWidth;
+	this.height = rotatedHeight;
+    this.angle	= angle;
+	this.translateX = -minX;
+	this.translateY = -minY;
+};
+
+RotateImage.prototype = heir(BaseImage.prototype);
+
+
+// translate drawing point, so that this.img appears in the UL corner. Then rotate and render this.img.
+RotateImage.prototype.render = function(ctx, x, y) {
+	ctx.translate(this.translateX, this.translateY);
+	ctx.rotate(this.angle * Math.PI / 180);
+    this.img.render(ctx, x, y);
+	ctx.restore();
+};
+
+
+RotateImage.prototype.getWidth = function() {
+    return this.width;
+};
+
+RotateImage.prototype.getHeight = function() {
+    return this.height;
+};
+
+RotateImage.prototype.isEqual = function(other, aUnionFind) {
+    return ( other instanceof RotateImage &&
+			this.pinholeX == other.pinholeX &&
+			this.pinholeY == other.pinholeY &&
+			this.width == other.width &&
+			this.height == other.height &&
+			this.angle == other.angle &&
+			this.translateX == other.translateX &&
+			this.translateY == other.translateY &&
+			types.isEqual(this.img, other.img, aUnionFind) );
+};
+
+//////////////////////////////////////////////////////////////////////
+
+
+// ScaleImage: factor factor image -> image
+// Scale an image
+var ScaleImage = function(xFactor, yFactor, img) {
+    
+    // resize the image
+    BaseImage.call(this, 
+		   Math.floor((img.getWidth() * xFactor) / 2),
+		   Math.floor((img.getHeight() * yFactor) / 2));
+    
+    this.img	= img;
+    this.width	= img.getWidth() * xFactor;
+    this.height = img.getHeight() * yFactor;
+    this.xFactor = xFactor;
+    this.yFactor = yFactor;
+};
+
+ScaleImage.prototype = heir(BaseImage.prototype);
+
+
+// scale the context, and pass it to the image's render function
+ScaleImage.prototype.render = function(ctx, x, y) {
+    ctx.save();
+    ctx.scale(this.xFactor, this.yFactor);
+    this.img.render(ctx, x, y);
+    ctx.restore();
+};
+
+
+ScaleImage.prototype.getWidth = function() {
+    return this.width;
+};
+
+ScaleImage.prototype.getHeight = function() {
+    return this.height;
+};
+
+ScaleImage.prototype.isEqual = function(other, aUnionFind) {
+    return ( other instanceof ScaleImage &&
+	     this.pinholeX == other.pinholeX &&
+	     this.pinholeY == other.pinholeY &&
+	     this.width == other.width &&
+	     this.height == other.height &&
+	     this.xFactor == other.xFactor &&
+	     this.yFactor == other.yFactor &&
+	     types.isEqual(this.img, other.img, aUnionFind) );
+};
+
+//////////////////////////////////////////////////////////////////////
+
+
+
+var colorString = function(aColor) {
+    return ("rgb(" + 
+	    types.colorRed(aColor) + "," +
+	    types.colorGreen(aColor) + ", " + 
+	    types.colorBlue(aColor) + ")");
+};
+
+
+
+var RectangleImage = function(width, height, style, color) {
+    BaseImage.call(this, width/2, height/2);
+    this.width = width;
+    this.height = height;
+    this.style = style;
+    this.color = color;
+};
+RectangleImage.prototype = heir(BaseImage.prototype);
+
+
+RectangleImage.prototype.render = function(ctx, x, y) {
+    if (this.style.toString().toLowerCase() == "outline") {
+	ctx.save();
+	ctx.beginPath();
+	ctx.strokeStyle = colorString(this.color);
+	ctx.strokeRect(x, y, this.width, this.height);
+	ctx.closePath();
+	ctx.restore();
+    } else {
+	ctx.save();
+	ctx.beginPath();
+
+	ctx.fillStyle = colorString(this.color);
+	ctx.fillRect(x, y, this.width, this.height);
+
+	ctx.closePath();
+	ctx.restore();
+    }
+};
+
+RectangleImage.prototype.getWidth = function() {
+    return this.width;
+};
+
+
+RectangleImage.prototype.getHeight = function() {
+    return this.height;
+};
+
+RectangleImage.prototype.isEqual = function(other, aUnionFind) {
+    return (other instanceof RectangleImage &&
+	    this.pinholeX == other.pinholeX &&
+	    this.pinholeY == other.pinholeY &&
+	    this.width == other.width &&
+	    this.height == other.height &&
+	    this.style == other.style &&
+	    types.isEqual(this.color, other.color, aUnionFind));
+};
+
+
+//////////////////////////////////////////////////////////////////////
+
+var TextImage = function(msg, size, color) {
+    BaseImage.call(this, 0, 0);
+    this.msg = msg;
+    this.size = size;
+    this.color = color;
+    this.font = this.size + "px Optimer";
+
+    
+    var canvas = world.Kernel.makeCanvas(0, 0);
+    var ctx = canvas.getContext("2d");
+    ctx.font = this.font;
+    var metrics = ctx.measureText(msg);
+
+    this.width = metrics.width;
+    // KLUDGE: I don't know how to get at the height.
+    this.height = ctx.measureText("m").width + 20;
+
+}
+
+TextImage.prototype = heir(BaseImage.prototype);
+
+TextImage.prototype.render = function(ctx, x, y) {
+    ctx.save();
+    ctx.font = this.font;
+    ctx.textAlign = 'left';
+    ctx.textBaseline = 'top';
+    ctx.fillStyle = colorString(this.color);
+    ctx.fillText(this.msg, x, y);
+    ctx.restore();
+};
+
+TextImage.prototype.getWidth = function() {
+    return this.width;
+};
+
+
+TextImage.prototype.getHeight = function() {
+    return this.height;
+};
+
+TextImage.prototype.isEqual = function(other, aUnionFind) {
+    return (other instanceof TextImage &&
+	    this.pinholeX == other.pinholeX &&
+	    this.pinholeY == other.pinholeY &&
+	    this.msg == other.msg &&
+	    this.size == other.size &&
+	    types.isEqual(this.color, other.color, aUnionFind) &&
+	    this.font == other.font);
+};
+
+
+//////////////////////////////////////////////////////////////////////
+
+var CircleImage = function(radius, style, color) {
+    BaseImage.call(this, radius, radius);
+    this.radius = radius;
+    this.style = style;
+    this.color = color;
+}
+CircleImage.prototype = heir(BaseImage.prototype);
+
+CircleImage.prototype.render = function(ctx, x, y) {
+    ctx.save();
+    ctx.beginPath();
+    ctx.arc(x + this.radius,
+	    y + this.radius,
+	    this.radius, 0, 2*Math.PI, false);
+    ctx.closePath();
+    if (this.style.toString().toLowerCase() == "outline") {
+	ctx.strokeStyle = colorString(this.color);
+	ctx.stroke();
+    } else {
+	ctx.fillStyle = colorString(this.color);
+	ctx.fill();
+    }
+
+    ctx.restore();
+};
+
+CircleImage.prototype.getWidth = function() {
+    return this.radius * 2;
+};
+
+CircleImage.prototype.getHeight = function() {
+    return this.radius * 2;
+};
+
+CircleImage.prototype.isEqual = function(other, aUnionFind) {
+    return (other instanceof CircleImage &&
+	    this.pinholeX == other.pinholeX &&
+	    this.pinholeY == other.pinholeY &&
+	    this.radius == other.radius &&
+	    this.style == other.style &&
+	    types.isEqual(this.color, other.color, aUnionFind));
+};
+
+
+
+//////////////////////////////////////////////////////////////////////
+
+
+// StarImage: fixnum fixnum fixnum color -> image
+var StarImage = function(points, outer, inner, style, color) {
+    BaseImage.call(this,
+		   Math.max(outer, inner),
+		   Math.max(outer, inner));
+    this.points = points;
+    this.outer = outer;
+    this.inner = inner;
+    this.style = style;
+    this.color = color;
+
+    this.radius = Math.max(this.inner, this.outer);
+};
+
+StarImage.prototype = heir(BaseImage.prototype);
+
+var oneDegreeAsRadian = Math.PI / 180;
+
+// render: context fixnum fixnum -> void
+// Draws a star on the given context.
+// Most of this code here adapted from the Canvas tutorial at:
+// http://developer.apple.com/safari/articles/makinggraphicswithcanvas.html
+StarImage.prototype.render = function(ctx, x, y) {
+    ctx.save();
+    ctx.beginPath();
+    for( var pt = 0; pt < (this.points * 2) + 1; pt++ ) {
+	var rads = ( ( 360 / (2 * this.points) ) * pt ) * oneDegreeAsRadian - 0.5;
+	var radius = ( pt % 2 == 1 ) ? this.outer : this.inner;
+	ctx.lineTo(x + this.radius + ( Math.sin( rads ) * radius ), 
+		   y + this.radius + ( Math.cos( rads ) * radius ) );
+    }
+    ctx.closePath();
+    if (this.style.toString().toLowerCase() == "outline") {
+	ctx.strokeStyle = colorString(this.color);
+	ctx.stroke();
+    } else {
+	ctx.fillStyle = colorString(this.color);
+	ctx.fill();
+    }
+
+    ctx.restore();
+};
+
+// getWidth: -> fixnum
+StarImage.prototype.getWidth = function() {
+    return this.radius * 2;
+};
+
+
+// getHeight: -> fixnum
+StarImage.prototype.getHeight = function() {
+    return this.radius * 2;
+};
+
+StarImage.prototype.isEqual = function(other, aUnionFind) {
+    return (other instanceof StarImage &&
+	    this.pinholeX == other.pinholeX &&
+	    this.pinholeY == other.pinholeY &&
+	    this.points == other.points &&
+	    this.outer == other.outer &&
+	    this.inner == other.inner &&
+	    this.style == other.style &&
+	    types.isEqual(this.color, other.color, aUnionFind));
+};
+
+
+
+
+//////////////////////////////////////////////////////////////////////
+//Triangle
+///////
+var TriangleImage = function(side, style, color) {
+    this.width = side;
+    this.height = Math.ceil(side * Math.sqrt(3) / 2);
+
+    BaseImage.call(this, Math.floor(this.width/2), Math.floor(this.height/2));
+    this.side = side;
+    this.style = style;
+    this.color = color;
+}
+TriangleImage.prototype = heir(BaseImage.prototype);
+
+
+TriangleImage.prototype.render = function(ctx, x, y) {
+    var width = this.getWidth();
+    var height = this.getHeight();
+    ctx.save();
+    ctx.beginPath();
+    ctx.moveTo(x + this.side/2, y);
+    ctx.lineTo(x + width, y + height);
+    ctx.lineTo(x, y + height);
+    ctx.closePath();
+
+    if (this.style.toString().toLowerCase() == "outline") {
+	ctx.strokeStyle = colorString(this.color);
+	ctx.stroke();
+    }
+    else {
+	ctx.fillStyle = colorString(this.color);
+	ctx.fill();
+    }
+    ctx.restore();
+};
+
+
+
+TriangleImage.prototype.getWidth = function() {
+    return this.width;
+};
+
+TriangleImage.prototype.getHeight = function() {
+    return this.height;
+};
+
+TriangleImage.prototype.isEqual = function(other, aUnionFind) {
+    return (other instanceof TriangleImage &&
+	    this.pinholeX == other.pinholeX &&
+	    this.pinholeY == other.pinholeY &&
+	    this.side == other.side &&
+	    this.style == other.style &&
+	    types.isEqual(this.color, other.color, aUnionFind));
+};
+
+
+
+//////////////////////////////////////////////////////////////////////
+//Ellipse 
+var EllipseImage = function(width, height, style, color) {
+    BaseImage.call(this, Math.floor(width/2), Math.floor(height/2));
+    this.width = width;
+    this.height = height;
+    this.style = style;
+    this.color = color;
+};
+
+EllipseImage.prototype = heir(BaseImage.prototype);
+
+
+EllipseImage.prototype.render = function(ctx, aX, aY) {
+    ctx.save();
+    ctx.beginPath();
+
+    // Most of this code is taken from:
+    // http://webreflection.blogspot.com/2009/01/ellipse-and-circle-for-canvas-2d.html
+    var hB = (this.width / 2) * .5522848,
+    vB = (this.height / 2) * .5522848,
+    eX = aX + this.width,
+    eY = aY + this.height,
+    mX = aX + this.width / 2,
+    mY = aY + this.height / 2;
+    ctx.moveTo(aX, mY);
+    ctx.bezierCurveTo(aX, mY - vB, mX - hB, aY, mX, aY);
+    ctx.bezierCurveTo(mX + hB, aY, eX, mY - vB, eX, mY);
+    ctx.bezierCurveTo(eX, mY + vB, mX + hB, eY, mX, eY);
+    ctx.bezierCurveTo(mX - hB, eY, aX, mY + vB, aX, mY);
+    ctx.closePath();
+    if (this.style.toString().toLowerCase() == "outline") {
+ 	ctx.strokeStyle = colorString(this.color);
+	ctx.stroke();
+    }
+    else {
+ 	ctx.fillStyle = colorString(this.color);
+	ctx.fill();
+    }
+
+
+    ctx.restore();
+};
+
+EllipseImage.prototype.getWidth = function() {
+    return this.width;
+};
+
+EllipseImage.prototype.getHeight = function() {
+    return this.height;
+};
+
+EllipseImage.prototype.isEqual = function(other, aUnionFind) {
+    return (other instanceof EllipseImage &&
+	    this.pinholeX == other.pinholeX &&
+	    this.pinholeY == other.pinholeY &&
+	    this.width == other.width &&
+	    this.height == other.height &&
+	    this.style == other.style &&
+	    types.isEqual(this.color, other.color, aUnionFind));
+};
+
+
+//////////////////////////////////////////////////////////////////////
+//Line
+var LineImage = function(x, y, color) {
+    if (x >= 0) {
+	if (y >= 0) {
+	    BaseImage.call(this, 0, 0);
+	} else {
+	    BaseImage.call(this, 0, -y);
+	}
+    } else {
+	if (y >= 0) {
+	    BaseImage.call(this, -x, 0);
+	} else {
+	    BaseImage.call(this, -x, -y);
+	}
+    }
+
+
+    this.x = x;
+    this.y = y;
+    this.color = color;
+    this.width = Math.abs(x) + 1;
+    this.height = Math.abs(y) + 1;
+}
+
+LineImage.prototype = heir(BaseImage.prototype);
+
+
+LineImage.prototype.render = function(ctx, xstart, ystart) {
+    ctx.save();
+
+    if (this.x >= 0) {
+	if (this.y >= 0) {
+	    ctx.moveTo(xstart, ystart);
+	    ctx.lineTo((xstart + this.x),
+		       (ystart + this.y));
+	} else {
+	    ctx.moveTo(xstart, ystart + (-this.y));
+	    ctx.lineTo(xstart + this.x, ystart);
+	}
+    } else {
+	if (this.y >= 0) {
+	    ctx.moveTo(xstart + (-this.x), ystart);
+	    ctx.lineTo(xstart,
+		       (ystart + this.y));		
+	} else {
+	    ctx.moveTo(xstart + (-this.x), ystart + (-this.y));
+	    ctx.lineTo(xstart, ystart);
+	}
+    }
+    ctx.strokeStyle = colorString(this.color);
+    ctx.stroke();
+    ctx.restore();
+};
+
+
+LineImage.prototype.getWidth = function() {
+    return this.width;
+};
+
+
+LineImage.prototype.getHeight = function() {
+    return this.height;
+};
+
+LineImage.prototype.isEqual = function(other, aUnionFind) {
+    return (other instanceof LineImage &&
+	    this.pinholeX == other.pinholeX &&
+	    this.pinholeY == other.pinholeY &&
+	    this.x == other.x &&
+	    this.y == other.y &&
+	    types.isEqual(this.color, other.color, aUnionFind));
+};
+
+
+
+
+
+//////////////////////////////////////////////////////////////////////
+// Effects
+
+/**
+     * applyEffect: compound-effect -> (arrayof (world -> world))
+
+     applyEffect applies all of the effects
+
+     @param aCompEffect a compound effect is either a scheme list of
+     compound effects or a single primitive effect */
+world.Kernel.applyEffect = function(aCompEffect) {
+    if ( types.isEmpty(aCompEffect) ) {
+    	// Do Nothing
+    } else if ( types.isPair(aCompEffect) ) {
+    	var results = world.Kernel.applyEffect(aCompEffect.first());
+    	return results.concat(world.Kernel.applyEffect(aCompEffect.rest()));
+    } else {
+	var newResult = aCompEffect.run();
+	if (newResult) {
+	    return newResult;
+	}
+    }
+    return [];
+}
+
+//////////////////////////////////////////////////////////////////////////
+
+
+
+
+// Color database
+var ColorDb = function() {
+    this.colors = {};
+}
+ColorDb.prototype.put = function(name, color) {
+    this.colors[name] = color;
+};
+
+ColorDb.prototype.get = function(name) {
+    return this.colors[name.toString().toUpperCase()];
+};
+
+
+// FIXME: update toString to handle the primitive field values.
+
+var colorDb = new ColorDb();
+colorDb.put("ORANGE", types.color(255, 165, 0));
+colorDb.put("RED", types.color(255, 0, 0));
+colorDb.put("ORANGERED", types.color(255, 69, 0));
+colorDb.put("TOMATO", types.color(255, 99, 71));
+colorDb.put("DARKRED", types.color(139, 0, 0));
+colorDb.put("RED", types.color(255, 0, 0));
+colorDb.put("FIREBRICK", types.color(178, 34, 34));
+colorDb.put("CRIMSON", types.color(220, 20, 60));
+colorDb.put("DEEPPINK", types.color(255, 20, 147));
+colorDb.put("MAROON", types.color(176, 48, 96));
+colorDb.put("INDIAN RED", types.color(205, 92, 92));
+colorDb.put("INDIANRED", types.color(205, 92, 92));
+colorDb.put("MEDIUM VIOLET RED", types.color(199, 21, 133));
+colorDb.put("MEDIUMVIOLETRED", types.color(199, 21, 133));
+colorDb.put("VIOLET RED", types.color(208, 32, 144));
+colorDb.put("VIOLETRED", types.color(208, 32, 144));
+colorDb.put("LIGHTCORAL", types.color(240, 128, 128));
+colorDb.put("HOTPINK", types.color(255, 105, 180));
+colorDb.put("PALEVIOLETRED", types.color(219, 112, 147));
+colorDb.put("LIGHTPINK", types.color(255, 182, 193));
+colorDb.put("ROSYBROWN", types.color(188, 143, 143));
+colorDb.put("PINK", types.color(255, 192, 203));
+colorDb.put("ORCHID", types.color(218, 112, 214));
+colorDb.put("LAVENDERBLUSH", types.color(255, 240, 245));
+colorDb.put("SNOW", types.color(255, 250, 250));
+colorDb.put("CHOCOLATE", types.color(210, 105, 30));
+colorDb.put("SADDLEBROWN", types.color(139, 69, 19));
+colorDb.put("BROWN", types.color(132, 60, 36));
+colorDb.put("DARKORANGE", types.color(255, 140, 0));
+colorDb.put("CORAL", types.color(255, 127, 80));
+colorDb.put("SIENNA", types.color(160, 82, 45));
+colorDb.put("ORANGE", types.color(255, 165, 0));
+colorDb.put("SALMON", types.color(250, 128, 114));
+colorDb.put("PERU", types.color(205, 133, 63));
+colorDb.put("DARKGOLDENROD", types.color(184, 134, 11));
+colorDb.put("GOLDENROD", types.color(218, 165, 32));
+colorDb.put("SANDYBROWN", types.color(244, 164, 96));
+colorDb.put("LIGHTSALMON", types.color(255, 160, 122));
+colorDb.put("DARKSALMON", types.color(233, 150, 122));
+colorDb.put("GOLD", types.color(255, 215, 0));
+colorDb.put("YELLOW", types.color(255, 255, 0));
+colorDb.put("OLIVE", types.color(128, 128, 0));
+colorDb.put("BURLYWOOD", types.color(222, 184, 135));
+colorDb.put("TAN", types.color(210, 180, 140));
+colorDb.put("NAVAJOWHITE", types.color(255, 222, 173));
+colorDb.put("PEACHPUFF", types.color(255, 218, 185));
+colorDb.put("KHAKI", types.color(240, 230, 140));
+colorDb.put("DARKKHAKI", types.color(189, 183, 107));
+colorDb.put("MOCCASIN", types.color(255, 228, 181));
+colorDb.put("WHEAT", types.color(245, 222, 179));
+colorDb.put("BISQUE", types.color(255, 228, 196));
+colorDb.put("PALEGOLDENROD", types.color(238, 232, 170));
+colorDb.put("BLANCHEDALMOND", types.color(255, 235, 205));
+colorDb.put("MEDIUM GOLDENROD", types.color(234, 234, 173));
+colorDb.put("MEDIUMGOLDENROD", types.color(234, 234, 173));
+colorDb.put("PAPAYAWHIP", types.color(255, 239, 213));
+colorDb.put("MISTYROSE", types.color(255, 228, 225));
+colorDb.put("LEMONCHIFFON", types.color(255, 250, 205));
+colorDb.put("ANTIQUEWHITE", types.color(250, 235, 215));
+colorDb.put("CORNSILK", types.color(255, 248, 220));
+colorDb.put("LIGHTGOLDENRODYELLOW", types.color(250, 250, 210));
+colorDb.put("OLDLACE", types.color(253, 245, 230));
+colorDb.put("LINEN", types.color(250, 240, 230));
+colorDb.put("LIGHTYELLOW", types.color(255, 255, 224));
+colorDb.put("SEASHELL", types.color(255, 245, 238));
+colorDb.put("BEIGE", types.color(245, 245, 220));
+colorDb.put("FLORALWHITE", types.color(255, 250, 240));
+colorDb.put("IVORY", types.color(255, 255, 240));
+colorDb.put("GREEN", types.color(0, 255, 0));
+colorDb.put("LAWNGREEN", types.color(124, 252, 0));
+colorDb.put("CHARTREUSE", types.color(127, 255, 0));
+colorDb.put("GREEN YELLOW", types.color(173, 255, 47));
+colorDb.put("GREENYELLOW", types.color(173, 255, 47));
+colorDb.put("YELLOW GREEN", types.color(154, 205, 50));
+colorDb.put("YELLOWGREEN", types.color(154, 205, 50));
+colorDb.put("MEDIUM FOREST GREEN", types.color(107, 142, 35));
+colorDb.put("OLIVEDRAB", types.color(107, 142, 35));
+colorDb.put("MEDIUMFORESTGREEN", types.color(107, 142, 35));
+colorDb.put("DARK OLIVE GREEN", types.color(85, 107, 47));
+colorDb.put("DARKOLIVEGREEN", types.color(85, 107, 47));
+colorDb.put("DARKSEAGREEN", types.color(143, 188, 139));
+colorDb.put("LIME", types.color(0, 255, 0));
+colorDb.put("DARK GREEN", types.color(0, 100, 0));
+colorDb.put("DARKGREEN", types.color(0, 100, 0));
+colorDb.put("LIME GREEN", types.color(50, 205, 50));
+colorDb.put("LIMEGREEN", types.color(50, 205, 50));
+colorDb.put("FOREST GREEN", types.color(34, 139, 34));
+colorDb.put("FORESTGREEN", types.color(34, 139, 34));
+colorDb.put("SPRING GREEN", types.color(0, 255, 127));
+colorDb.put("SPRINGGREEN", types.color(0, 255, 127));
+colorDb.put("MEDIUM SPRING GREEN", types.color(0, 250, 154));
+colorDb.put("MEDIUMSPRINGGREEN", types.color(0, 250, 154));
+colorDb.put("SEA GREEN", types.color(46, 139, 87));
+colorDb.put("SEAGREEN", types.color(46, 139, 87));
+colorDb.put("MEDIUM SEA GREEN", types.color(60, 179, 113));
+colorDb.put("MEDIUMSEAGREEN", types.color(60, 179, 113));
+colorDb.put("AQUAMARINE", types.color(112, 216, 144));
+colorDb.put("LIGHTGREEN", types.color(144, 238, 144));
+colorDb.put("PALE GREEN", types.color(152, 251, 152));
+colorDb.put("PALEGREEN", types.color(152, 251, 152));
+colorDb.put("MEDIUM AQUAMARINE", types.color(102, 205, 170));
+colorDb.put("MEDIUMAQUAMARINE", types.color(102, 205, 170));
+colorDb.put("TURQUOISE", types.color(64, 224, 208));
+colorDb.put("LIGHTSEAGREEN", types.color(32, 178, 170));
+colorDb.put("MEDIUM TURQUOISE", types.color(72, 209, 204));
+colorDb.put("MEDIUMTURQUOISE", types.color(72, 209, 204));
+colorDb.put("HONEYDEW", types.color(240, 255, 240));
+colorDb.put("MINTCREAM", types.color(245, 255, 250));
+colorDb.put("ROYALBLUE", types.color(65, 105, 225));
+colorDb.put("DODGERBLUE", types.color(30, 144, 255));
+colorDb.put("DEEPSKYBLUE", types.color(0, 191, 255));
+colorDb.put("CORNFLOWERBLUE", types.color(100, 149, 237));
+colorDb.put("STEEL BLUE", types.color(70, 130, 180));
+colorDb.put("STEELBLUE", types.color(70, 130, 180));
+colorDb.put("LIGHTSKYBLUE", types.color(135, 206, 250));
+colorDb.put("DARK TURQUOISE", types.color(0, 206, 209));
+colorDb.put("DARKTURQUOISE", types.color(0, 206, 209));
+colorDb.put("CYAN", types.color(0, 255, 255));
+colorDb.put("AQUA", types.color(0, 255, 255));
+colorDb.put("DARKCYAN", types.color(0, 139, 139));
+colorDb.put("TEAL", types.color(0, 128, 128));
+colorDb.put("SKY BLUE", types.color(135, 206, 235));
+colorDb.put("SKYBLUE", types.color(135, 206, 235));
+colorDb.put("CADET BLUE", types.color(96, 160, 160));
+colorDb.put("CADETBLUE", types.color(95, 158, 160));
+colorDb.put("DARK SLATE GRAY", types.color(47, 79, 79));
+colorDb.put("DARKSLATEGRAY", types.color(47, 79, 79));
+colorDb.put("LIGHTSLATEGRAY", types.color(119, 136, 153));
+colorDb.put("SLATEGRAY", types.color(112, 128, 144));
+colorDb.put("LIGHT STEEL BLUE", types.color(176, 196, 222));
+colorDb.put("LIGHTSTEELBLUE", types.color(176, 196, 222));
+colorDb.put("LIGHT BLUE", types.color(173, 216, 230));
+colorDb.put("LIGHTBLUE", types.color(173, 216, 230));
+colorDb.put("POWDERBLUE", types.color(176, 224, 230));
+colorDb.put("PALETURQUOISE", types.color(175, 238, 238));
+colorDb.put("LIGHTCYAN", types.color(224, 255, 255));
+colorDb.put("ALICEBLUE", types.color(240, 248, 255));
+colorDb.put("AZURE", types.color(240, 255, 255));
+colorDb.put("MEDIUM BLUE", types.color(0, 0, 205));
+colorDb.put("MEDIUMBLUE", types.color(0, 0, 205));
+colorDb.put("DARKBLUE", types.color(0, 0, 139));
+colorDb.put("MIDNIGHT BLUE", types.color(25, 25, 112));
+colorDb.put("MIDNIGHTBLUE", types.color(25, 25, 112));
+colorDb.put("NAVY", types.color(36, 36, 140));
+colorDb.put("BLUE", types.color(0, 0, 255));
+colorDb.put("INDIGO", types.color(75, 0, 130));
+colorDb.put("BLUE VIOLET", types.color(138, 43, 226));
+colorDb.put("BLUEVIOLET", types.color(138, 43, 226));
+colorDb.put("MEDIUM SLATE BLUE", types.color(123, 104, 238));
+colorDb.put("MEDIUMSLATEBLUE", types.color(123, 104, 238));
+colorDb.put("SLATE BLUE", types.color(106, 90, 205));
+colorDb.put("SLATEBLUE", types.color(106, 90, 205));
+colorDb.put("PURPLE", types.color(160, 32, 240));
+colorDb.put("DARK SLATE BLUE", types.color(72, 61, 139));
+colorDb.put("DARKSLATEBLUE", types.color(72, 61, 139));
+colorDb.put("DARKVIOLET", types.color(148, 0, 211));
+colorDb.put("DARK ORCHID", types.color(153, 50, 204));
+colorDb.put("DARKORCHID", types.color(153, 50, 204));
+colorDb.put("MEDIUMPURPLE", types.color(147, 112, 219));
+colorDb.put("CORNFLOWER BLUE", types.color(68, 64, 108));
+colorDb.put("MEDIUM ORCHID", types.color(186, 85, 211));
+colorDb.put("MEDIUMORCHID", types.color(186, 85, 211));
+colorDb.put("MAGENTA", types.color(255, 0, 255));
+colorDb.put("FUCHSIA", types.color(255, 0, 255));
+colorDb.put("DARKMAGENTA", types.color(139, 0, 139));
+colorDb.put("VIOLET", types.color(238, 130, 238));
+colorDb.put("PLUM", types.color(221, 160, 221));
+colorDb.put("LAVENDER", types.color(230, 230, 250));
+colorDb.put("THISTLE", types.color(216, 191, 216));
+colorDb.put("GHOSTWHITE", types.color(248, 248, 255));
+colorDb.put("WHITE", types.color(255, 255, 255));
+colorDb.put("WHITESMOKE", types.color(245, 245, 245));
+colorDb.put("GAINSBORO", types.color(220, 220, 220));
+colorDb.put("LIGHT GRAY", types.color(211, 211, 211));
+colorDb.put("LIGHTGRAY", types.color(211, 211, 211));
+colorDb.put("SILVER", types.color(192, 192, 192));
+colorDb.put("GRAY", types.color(190, 190, 190));
+colorDb.put("DARK GRAY", types.color(169, 169, 169));
+colorDb.put("DARKGRAY", types.color(169, 169, 169));
+colorDb.put("DIM GRAY", types.color(105, 105, 105));
+colorDb.put("DIMGRAY", types.color(105, 105, 105));
+colorDb.put("BLACK", types.color(0, 0, 0));
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+///////////////////////////////////////////////////////////////
+// Exports
+
+world.Kernel.isImage = isImage;
+world.Kernel.isScene = isScene;
+world.Kernel.isColor = function(thing) {
+    return (types.isColor(thing) ||
+	    ((types.isString(thing) || types.isSymbol(thing)) &&
+	     typeof(colorDb.get(thing)) != 'undefined'));
+};
+world.Kernel.colorDb = colorDb;
+
+world.Kernel.sceneImage = function(width, height, children, withBorder) {
+    return new SceneImage(width, height, children, withBorder);
+};
+world.Kernel.circleImage = function(radius, style, color) {
+    return new CircleImage(radius, style, color);
+};
+world.Kernel.starImage = function(points, outer, inner, style, color) {
+    return new StarImage(points, outer, inner, style, color);
+};
+world.Kernel.rectangleImage = function(width, height, style, color) {
+    return new RectangleImage(width, height, style, color);
+};
+world.Kernel.triangleImage = function(side, style, color) {
+    return new TriangleImage(side, style, color);
+};
+world.Kernel.ellipseImage = function(width, height, style, color) {
+    return new EllipseImage(width, height, style, color);
+};
+world.Kernel.lineImage = function(x, y, color) {
+    return new LineImage(x, y, color);
+};
+world.Kernel.overlayImage = function(img1, img2, shiftX, shiftY) {
+    return new OverlayImage(img1, img2, shiftX, shiftY);
+};
+world.Kernel.rotateImage = function(angle, img) {
+    return new RotateImage(angle, img);
+};
+world.Kernel.scaleImage = function(xFactor, yFactor, img) {
+	return new ScaleImage(xFactor, yFactor, img);
+};
+world.Kernel.textImage = function(msg, size, color) {
+    return new TextImage(msg, size, color);
+};
+world.Kernel.fileImage = function(path, rawImage) {
+    return FileImage.makeInstance(path, rawImage);
+};
+
+
+world.Kernel.isSceneImage = function(x) { return x instanceof SceneImage; };
+world.Kernel.isCircleImage = function(x) { return x instanceof CircleImage; };
+world.Kernel.isStarImage = function(x) { return x instanceof StarImage; };
+world.Kernel.isRectangleImage = function(x) { return x instanceof RectangleImage; };
+world.Kernel.isTriangleImage = function(x) { return x instanceof TriangleImage; };
+world.Kernel.isEllipseImage = function(x) { return x instanceof EllipseImage; };
+world.Kernel.isLineImage = function(x) { return x instanceof LineImage; };
+world.Kernel.isOverlayImage = function(x) { return x instanceof OverlayImage; };
+world.Kernel.isRotateImage = function(x) { return x instanceof RotateImage; };
+world.Kernel.isTextImage = function(x) { return x instanceof TextImage; };
+world.Kernel.isFileImage = function(x) { return x instanceof FileImage; };
+
+
+
+
+
+
+
+//////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////
+
+
+// Feeds stimuli inputs into the world.  The functions here
+// are responsible for converting to Scheme values.
+//
+// NOTE and WARNING: make sure to really do the coersions, even for
+// strings.  Bad things happen otherwise, as in the sms stuff, where
+// we're getting string-like values that aren't actually strings.
+
+
+
+world.stimuli = {};
+world.Kernel.stimuli = world.stimuli;
+
+
+(function() {
+    var handlers = [];
+
+    var doNothing = function() {};
+
+
+    var StimuliHandler = function(config, caller, restarter) {
+	this.config = config;
+	this.caller = caller;
+	this.restarter = restarter;
+	handlers.push(this);
+    };
+
+    //    StimuliHandler.prototype.failHandler = function(e) {
+    //	this.onShutdown();
+    //    	this.restarter(e);
+    //    };	
+
+    // doStimuli: CPS( (world -> effect) (world -> world) -> void )
+    //
+    // Processes a stimuli by compute the effect and applying it, and
+    // computing a new world to replace the old.
+    StimuliHandler.prototype.doStimuli = function(computeEffectF, computeWorldF, restArgs, k) {
+	var effectUpdaters = [];
+	var that = this;
+	try {
+	    that.change(function(w, k2) {
+		var args = [w].concat(restArgs);
+		var doStimuliHelper = function() {
+		    if (computeWorldF) {
+			that.caller(computeWorldF, args, k2);
+		    } else {
+			k2(w);
+		    }
+		};
+		doStimuliHelper();
+	    }, k);
+ 	    // if (computeEffectF) {
+	    // 		    that.caller(computeEffectF, [args],
+	    // 			    function(effect) {
+	    // 			    	effectUpdaters = applyEffect(effect);
+	    // 				doStimuliHelper();
+	    // 			    },
+	    //	    		    this.failHandler);
+	    // 		}
+	    // 		else { doStimuliHelper(); }
+	    // 	    },
+	    // 	    function() {
+	    // 	    	helpers.forEachK(effectUpdaters,
+	    // 				 function(effect, k2) { that.change(effect, k2); },
+	    // 				 function(e) { throw e; },
+	    // 				 k);
+	    // 	    });
+	} catch (e) { 
+	    //		if (console && console.log && e.stack) {
+	    //			console.log(e.stack);
+	    //		}
+	    this.onShutdown();
+	}
+    }
+
+
+    // Orientation change
+    // args: [azimuth, pitch, roll]
+    StimuliHandler.prototype.onTilt = function(args, k) {
+	var onTilt = this.lookup("onTilt");
+	var onTiltEffect = this.lookup("onTiltEffect");
+	this.doStimuli(onTiltEffect, onTilt, helpers.map(flt, args), k);
+    };
+
+
+    // Accelerations
+    // args: [x, y, z]
+    StimuliHandler.prototype.onAcceleration = function(args, k) {
+	var onAcceleration = this.lookup('onAcceleration');
+	var onAccelerationEffect = this.lookup('onAccelerationEffect');
+	this.doStimuli(onAccelerationEffect, onAcceleration, helpers.map(flt, args), k);
+    };
+
+
+    // Shakes
+    // args: []
+    StimuliHandler.prototype.onShake = function(args, k) {
+	var onShake = this.lookup('onShake');
+	var onShakeEffect = this.lookup('onShakeEffect');
+	this.doStimuli(onShakeEffect, onShake, [], k);
+    };
+
+
+    // Sms receiving
+    // args: [sender, message]
+    StimuliHandler.prototype.onSmsReceive = function(args, k) {
+	var onSmsReceive = this.lookup('onSmsReceive');
+	var onSmsReceiveEffect = this.lookup('onSmsReceiveEffect');
+	// IMPORTANT: must coerse to string by using x+"".  Do not use
+	// toString(): it's not safe.
+	this.doStimuli(onSmsReceiveEffect, onSmsReceive, [args[0]+"", args[1]+""], k);
+    };
+
+
+    // Locations
+    // args: [lat, lng]
+    StimuliHandler.prototype.onLocation = function(args, k) {
+	var onLocationChange = this.lookup('onLocationChange');
+	var onLocationChangeEffect = this.lookup('onLocationChangeEffect');
+	this.doStimuli(onLocationChangeEffect, onLocationChange, helpers.map(flt, args), k);
+    };
+
+
+
+    // Keystrokes
+    // args: [e]
+    StimuliHandler.prototype.onKey = function(args, k) {
+	// getKeyCodeName: keyEvent -> String
+	// Given an event, try to get the name of the key.
+	var getKeyCodeName = function(e) {
+	    var code = e.charCode || e.keyCode;
+	    var keyname;
+	    switch(code) {
+	    case 16: keyname = "shift"; break;
+	    case 17: keyname = "control"; break;
+	    case 19: keyname = "pause"; break;
+	    case 27: keyname = "escape"; break;
+	    case 33: keyname = "prior"; break;
+	    case 34: keyname = "next"; break;
+	    case 35: keyname = "end"; break;
+	    case 36: keyname = "home"; break;
+	    case 37: keyname = "left"; break;
+	    case 38: keyname = "up"; break;
+	    case 39: keyname = "right"; break;
+	    case 40: keyname = "down"; break;
+	    case 42: keyname = "print"; break;
+	    case 45: keyname = "insert"; break;
+	    case 46: keyname = String.fromCharCode(127); break;
+	    case 106: keyname = "*"; break;
+	    case 107: keyname = "+"; break;
+	    case 109: keyname = "-"; break;
+	    case 110: keyname = "."; break;
+	    case 111: keyname = "/"; break;
+	    case 144: keyname = "numlock"; break;
+	    case 145: keyname = "scroll"; break;
+	    case 186: keyname = ";"; break;
+	    case 187: keyname = "="; break;
+	    case 188: keyname = ","; break;
+	    case 189: keyname = "-"; break;
+	    case 190: keyname = "."; break;
+	    case 191: keyname = "/"; break;
+	    case 192: keyname = "`"; break;
+	    case 219: keyname = "["; break;
+	    case 220: keyname = "\\"; break;
+	    case 221: keyname = "]"; break;
+	    case 222: keyname = "'"; break;
+	    default: if (code >= 96 && code <= 105) {
+		keyname = (code - 96).toString();
+	    }
+		else if (code >= 112 && code <= 123) {
+		    keyname = "f" + (code - 111);
+		}
+		else {
+		    keyname = String.fromCharCode(code).toLowerCase();
+		}
+		break;
+	    }
+	    return keyname;
+	}
+	var keyname = getKeyCodeName(args[0]);
+	var onKey = this.lookup('onKey');
+	var onKeyEffect = this.lookup('onKeyEffect');
+	this.doStimuli(onKeyEffect, onKey, [keyname], k);
+    };
+
+
+
+    //    // Time ticks
+    //    // args: []
+    //    StimuliHandler.prototype.onTick = function(args, k) {
+    //	var onTick = this.lookup('onTick');
+    //	var onTickEffect = this.lookup('onTickEffect');
+    //	this.doStimuli(onTickEffect, onTick, [], k);
+    //    };
+
+
+
+    // Announcements
+    // args: [eventName, vals]
+    StimuliHandler.prototype.onAnnounce = function(args, k) {
+	var vals = args[1];
+	var valsList = types.EMPTY;
+	for (var i = 0; i < vals.length; i++) {
+	    valsList = types.cons(vals[vals.length - i - 1], valsList);
+	}
+
+	var onAnnounce = this.lookup('onAnnounce');
+	var onAnnounceEffect = this.lookup('onAnnounceEffect');	
+	this.doStimuli(onAnnounce, onAnnounceEffect, [args[0], valsList], k);
+    };
+
+
+
+    // The shutdown stimuli: special case that forces a world computation to quit.
+    // Also removes this instance from the list of handlers
+    StimuliHandler.prototype.onShutdown = function() {	
+	var index = handlers.indexOf(this);
+	if (index != -1) {
+	    handlers.splice(index, 1);
+	}
+
+	var shutdownWorld = this.lookup('shutdownWorld');
+	if (shutdownWorld) {
+	    shutdownWorld();
+	}
+    };
+
+
+    //////////////////////////////////////////////////////////////////////
+    // Helpers
+    var flt = types.float;
+
+    StimuliHandler.prototype.lookup = function(s) {
+	return this.config.lookup(s);
+    };
+
+    StimuliHandler.prototype.change = function(f, k) {
+	if (this.lookup('changeWorld')) {
+	    this.lookup('changeWorld')(f, k);
+	}
+	else { k(); }
+    };
+
+    // applyEffect: compound-effect: (arrayof (world -> world))
+    var applyEffect = function(e) {
+	return world.Kernel.applyEffect(e);
+    };
+
+    var makeStimulusHandler = function(funName) {
+	return function() {
+	    var args = arguments;
+	    for (var i = 0; i < handlers.length; i++) {
+		(handlers[i])[funName](args, doNothing);
+	    }
+	    //		helpers.forEachK(handlers,
+	    //				 function(h, k) { h[funName](args, k); },
+	    //				 function(e) { throw e; },
+	    //				 doNothing);
+	}
+    };
+
+    //////////////////////////////////////////////////////////////////////
+    // Exports
+
+    world.stimuli.StimuliHandler = StimuliHandler;
+
+    world.stimuli.onTilt = makeStimulusHandler('onTilt');
+    world.stimuli.onAcceleration = makeStimulusHandler('onAcceleration');
+    world.stimuli.onShake = makeStimulusHandler('onShake');
+    world.stimuli.onSmsReceive = makeStimulusHandler('onSmsReceive');
+    world.stimuli.onLocation = makeStimulusHandler('onLocation');
+    world.stimuli.onKey = makeStimulusHandler('onKey');
+    //    world.stimuli.onTick = makeStimulusHandler('onTick');
+    world.stimuli.onAnnounce = makeStimulusHandler('onAnnounce');
+
+    world.stimuli.massShutdown = function() {
+	for (var i = 0; i < handlers.length; i++) {
+	    var shutdownWorld = handlers[i].lookup('shutdownWorld');
+	    if (shutdownWorld) {
+		shutdownWorld();
+	    }
+	}
+	handlers = [];
+    };
+
+
+})();
+
+//////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////
+
+
+
+
+
+
+
+(function() {
+
+//     var make_dash_effect_colon_none =
+// 	(plt.Kernel.invokeModule("moby/runtime/effect-struct")
+// 	 .EXPORTS['make-effect:none']);
+
+    world.config = {};
+    world.Kernel.config = world.config;
+
+
+    // augment: hash hash -> hash
+    // Functionally extend a hashtable with another one.
+    var augment = function(o, a) {
+	var oo = {};
+	for (var e in o) {
+	    if (o.hasOwnProperty(e)) {
+		oo[e] = o[e];
+	    }
+	}
+	for (var e in a) {
+	    if (a.hasOwnProperty(e)) {
+		oo[e] = a[e];
+	    }
+	}
+	return oo;
+    }
+
+
+
+    var WorldConfig = function() {
+	// The following handler values are initially false until they're updated
+	// by configuration.
+      
+	// A handler is a function:
+	//     handler: world X Y ... -> Z
+
+
+	this.vals = {
+	    // changeWorld: (world -> world) -> void
+	    // When called, this will update the world based on the
+	    // updater passed to it.
+	    changeWorld: false,
+
+	    // shutdownWorld: -> void
+	    // When called, this will shut down the world computation.
+	    shutdownWorld: false,
+
+	    // initialEffect: effect
+	    // The initial effect to invoke when the world computation
+	    // begins.
+	    initialEffect: false,
+
+
+	    // onRedraw: world -> scene
+	    onRedraw: false,
+
+	    // onDraw: world -> (sexpof dom)
+	    onDraw: false,
+
+	    // onDrawCss: world -> (sexpof css-style)
+	    onDrawCss: false,
+
+
+	    // tickDelay: number
+	    tickDelay: false,
+	    // onTick: world -> world
+	    onTick: false,
+	    // onTickEffect: world -> effect
+	    onTickEffect: false,
+
+	    // onKey: world key -> world
+	    onKey: false,
+	    // onKeyEffect: world key -> effect
+	    onKeyEffect : false,
+
+	    // onTilt: world number number number -> world
+	    onTilt: false,
+	    // onTiltEffect: world number number number -> effect
+	    onTiltEffect: false,
+
+	    // onAcceleration: world number number number -> world
+	    onAcceleration: false,
+	    // onAccelerationEffect: world number number number -> effect
+	    onAccelerationEffect: false,
+
+	    // onShake: world -> world
+	    onShake: false,
+	    // onShakeEffect: world -> effect
+	    onShakeEffect: false,
+
+	    // onSmsReceive: world -> world
+	    onSmsReceive: false,
+	    // onSmsReceiveEffect: world -> effect
+	    onSmsReceiveEffect: false,
+
+	    // onLocationChange: world number number -> world
+	    onLocationChange : false,
+	    // onLocationChangeEffect: world number number -> effect
+	    onLocationChangeEffect: false,
+
+
+	    // onAnnounce: world string X ... -> world
+	    onAnnounce: false,
+	    // onAnnounce: world string X ... -> effect
+	    onAnnounceEffect: false,
+
+	    // stopWhen: world -> boolean
+	    stopWhen: false,
+	    // stopWhenEffect: world -> effect
+	    stopWhenEffect: false,
+
+
+
+	    //////////////////////////////////////////////////////////////////////
+	    // For universe game playing
+
+	    // connectToGame: string
+	    // Registers with some universe, given an identifier
+	    // which is a URL to a Universe server.
+	    connectToGame: false,
+	    onGameStart: false,
+	    onOpponentTurn: false,
+	    onMyTurn: false,
+	    afterMyTurn: false,
+	    onGameFinish: false
+	};
+    }
+
+  
+    // WorldConfig.lookup: string -> handler
+    // Looks up a value in the configuration.
+    WorldConfig.prototype.lookup = function(key) {
+//	plt.Kernel.check(key, plt.Kernel.isString, "WorldConfig.lookup", "string", 1);
+	if (key in this.vals) {
+	    return this.vals[key];
+	} else {
+	    throw Error("Can't find " + key + " in the configuration");
+	}
+    }
+  
+
+
+    // WorldConfig.updateAll: (hashof string handler) -> WorldConfig
+    WorldConfig.prototype.updateAll = function(aHash) {
+	var result = new WorldConfig();
+	result.vals = augment(this.vals, aHash);
+	return result;
+    }
+
+  
+    world.config.WorldConfig = WorldConfig;
+
+    // The following global variable CONFIG is mutated by either
+    // big-bang from the regular world or the one in jsworld.
+    world.config.CONFIG = new WorldConfig();
+
+
+    // A handler is a function that consumes a config and produces a
+    // config.
+
+
+    //////////////////////////////////////////////////////////////////////
+
+    var getNoneEffect = function() {
+	throw new Error("getNoneEffect: We should not be calling effects!");
+	//	return make_dash_effect_colon_none();
+    }
+
+
+
+    //////////////////////////////////////////////////////////////////////
+
+    world.config.Kernel = world.config.Kernel || {};
+    world.config.Kernel.getNoneEffect = getNoneEffect;
+
+
+/*
+    // makeSimplePropertyUpdater: (string (X -> boolean) string string) -> (X -> handler)
+    var makeSimplePropertyUpdater = function(propertyName,
+					     propertyPredicate,
+					     propertyTypeName,
+					     updaterName) {
+	return function(val) {
+	    plt.Kernel.check(val, propertyPredicate, updaterName, propertyTypeName, 1);
+	    return addStringMethods(
+		function(config) {
+		    return config.updateAll({propertyName: val });
+		}, updaterName);
+	}
+    };
+
+    // connects to the game
+    world.config.Kernel.connect_dash_to_dash_game = 
+	makeSimplePropertyUpdater('connectToGame',
+				  plt.Kernel.isString,
+				  "string",
+				  "connect-to-game");
+
+
+    // Registers a handler for game-start events.
+    world.config.Kernel.on_dash_game_dash_start = 
+	makeSimplePropertyUpdater('onGameStart',
+				  plt.Kernel.isFunction,
+				  "function",
+				  "on-game-start");
+
+
+    // Registers a handler for opponent-turn events.
+    world.config.Kernel.on_dash_opponent_dash_turn = 
+	makeSimplePropertyUpdater('onOpponentTurn',
+				  plt.Kernel.isFunction,
+				  "function",
+				  "on-opponent-turn");
+
+
+    // Registers a handler for my turn.
+    world.config.Kernel.on_dash_my_dash_turn = 
+	makeSimplePropertyUpdater('onMyTurn',
+				  plt.Kernel.isFunction,
+				  "function",
+				  "on-my-turn");
+
+    // Register a handler after I make a move.
+    world.config.Kernel.after_dash_my_dash_turn = 
+	makeSimplePropertyUpdater('afterMyTurn',
+				  plt.Kernel.isFunction,
+				  "function",
+				  "after-my-turn");
+
+    world.config.Kernel.on_dash_game_dash_finish = 
+	makeSimplePropertyUpdater('onGameFinish',
+				  plt.Kernel.isFunction,
+				  "function",
+				  "on-game-finish");
+*/
+
+
+
+})();
diff --git a/world/scratch/world/kernel.rkt b/world/scratch/world/kernel.rkt
new file mode 100644
index 0000000..f315428
--- /dev/null
+++ b/world/scratch/world/kernel.rkt
@@ -0,0 +1,3 @@
+#lang s-exp "../lang/js-impl/js-impl.rkt"
+
+(require-js "kernel.js")