diff --git a/actions/blend.js b/actions/blend.js
new file mode 100755
index 0000000..59ff9c5
--- /dev/null
+++ b/actions/blend.js
@@ -0,0 +1,326 @@
+/*
+ * Pixastic Lib - Blend - v0.1.0
+ * Copyright (c) 2008 Jacob Seidelin, jseidelin@nihilogic.dk, http://blog.nihilogic.dk/
+ * MIT License [http://www.opensource.org/licenses/mit-license.php]
+ */
+
+Pixastic.Actions.blend = {
+
+	process : function(params) {
+		var amount = parseFloat(params.options.amount);
+		var mode = (params.options.mode || "normal").toLowerCase();
+		var image = params.options.image;
+
+		amount = Math.max(0,Math.min(1,amount));
+
+		var amount1 = 1 - amount;
+		var amount2 = amount;
+
+		if (!image) return false;
+
+		if (Pixastic.Client.hasCanvasImageData()) {
+			var data = Pixastic.prepareData(params);
+			var rect = params.options.rect;
+			var w = rect.width;
+			var h = rect.height;
+
+			var otherCanvas = document.createElement("canvas");
+			otherCanvas.width = w;
+			otherCanvas.height = h;
+			var otherCtx = otherCanvas.getContext("2d");
+			otherCtx.drawImage(image,0,0);
+
+			var data2 = otherCtx.getImageData(0,0,w,h).data;
+
+			var w4 = w*4;
+			var y = h;
+
+			var p = w*h;
+			switch (mode) {
+				case "normal" : 
+					while (p--) {
+						var offset = p*4;
+						var r1 = data[offset], g1 = data[offset+1], b1 = data[offset+2];
+						var r2 = data2[offset], g2 = data2[offset+1], b2 = data2[offset+2];
+						data[offset] = r1 * amount1 + amount2 * r2;
+						data[offset+1] = g1 * amount1 + amount2 * g2;
+						data[offset+2] = b1 * amount1 + amount2 * b2;
+					}
+					break;
+
+				case "multiply" : 
+					while (p--) {
+						var offset = p*4;
+						var r1 = data[offset], g1 = data[offset+1], b1 = data[offset+2];
+						var r2 = data2[offset], g2 = data2[offset+1], b2 = data2[offset+2];
+						data[offset] = r1 * amount1 + amount2 * (r1 * r2 / 255);
+						data[offset+1] = g1 * amount1 + amount2 * (g1 * g2 / 255);
+						data[offset+2] = b1 * amount1 + amount2 * (b1 * b2 / 255);
+					}
+					break;
+
+				case "lighten" : 
+					while (p--) {
+						var offset = p*4;
+						var r1 = data[offset], g1 = data[offset+1], b1 = data[offset+2];
+						var r2 = data2[offset], g2 = data2[offset+1], b2 = data2[offset+2];
+						data[offset] = r1 * amount1 + amount2 * (r1 > r2 ? r1 : r2);
+						data[offset+1] = g1 * amount1 + amount2 * (g1 > g2 ? g1 : g2);
+						data[offset+2] = b1 * amount1 + amount2 * (b1 > b2 ? b1 : b2);
+					}
+					break;
+
+				case "darken" : 
+					while (p--) {
+						var offset = p*4;
+						var r1 = data[offset], g1 = data[offset+1], b1 = data[offset+2];
+						var r2 = data2[offset], g2 = data2[offset+1], b2 = data2[offset+2];
+						data[offset] = r1 * amount1 + amount2 * (r1 < r2 ? r1 : r2);
+						data[offset+1] = g1 * amount1 + amount2 * (g1 < g2 ? g1 : g2);
+						data[offset+2] = b1 * amount1 + amount2 * (b1 < b2 ? b1 : b2);
+					}
+					break;
+
+				case "average" : 
+					while (p--) {
+						var offset = p*4;
+						var r1 = data[offset], g1 = data[offset+1], b1 = data[offset+2];
+						var r2 = data2[offset], g2 = data2[offset+1], b2 = data2[offset+2];
+						data[offset] = r1 * amount1 + amount2 * ((r1 + r2) / 2);
+						data[offset+1] = g1 * amount1 + amount2 * ((g1 + g2) / 2);
+						data[offset+2] = b1 * amount1 + amount2 * ((b1 + b2) / 2);
+					}
+					break;
+
+				case "lineardodge" : 
+					while (p--) {
+						var offset = p*4;
+						var r1 = data[offset], g1 = data[offset+1], b1 = data[offset+2];
+						var r2 = data2[offset], g2 = data2[offset+1], b2 = data2[offset+2];
+						var r3 = r1+r2, g3 = g1+g2, b3 = b1+b2;
+						data[offset] = r1 * amount1 + amount2 * (r3 > 255 ? 255 : r3);
+						data[offset+1] = g1 * amount1 + amount2 * (g3 > 255 ? 255 : g3);
+						data[offset+2] = b1 * amount1 + amount2 * (b3 > 255 ? 255 : b3);
+					}
+					break;
+
+				case "linearburn" : 
+					while (p--) {
+						var offset = p*4;
+						var r1 = data[offset], g1 = data[offset+1], b1 = data[offset+2];
+						var r2 = data2[offset], g2 = data2[offset+1], b2 = data2[offset+2];
+						var r3 = (r2+r1 < 255) ? 0 : (r2+r1-255);
+						var g3 = (g2+g1 < 255) ? 0 : (g2+g1-255);
+						var b3 = (b2+b1 < 255) ? 0 : (b2+b1-255);
+
+						data[offset] = r1 * amount1 + amount2 * (r3 < 0 ? 0 : r3);
+						data[offset+1] = g1 * amount1 + amount2 * (g3 < 0 ? 0 : g3);
+						data[offset+2] = b1 * amount1 + amount2 * (b3 < 0 ? 0 : b3);
+					}
+					break;
+
+				case "difference" : 
+					while (p--) {
+						var offset = p*4;
+						var r1 = data[offset], g1 = data[offset+1], b1 = data[offset+2];
+						var r2 = data2[offset], g2 = data2[offset+1], b2 = data2[offset+2];
+						var r3 = r1-r2, g3 = g1-g2, b3 = b1-b2;
+						data[offset] = r1 * amount1 + amount2 * (r3 < 0 ? -r3 : r3);
+						data[offset+1] = g1 * amount1 + amount2 * (g3 < 0 ? -g3 : g3);
+						data[offset+2] = b1 * amount1 + amount2 * (b3 < 0 ? -b3 : b3);
+					}
+					break;
+
+
+				case "screen" : 
+					while (p--) {
+						var offset = p*4;
+						var r1 = data[offset], g1 = data[offset+1], b1 = data[offset+2];
+						var r2 = data2[offset], g2 = data2[offset+1], b2 = data2[offset+2];
+						var r3 = (255 - (((255 - r2) * (255 - r1)) >> 8));
+						var g3 = (255 - (((255 - g2) * (255 - g1)) >> 8));
+						var b3 = (255 - (((255 - b2) * (255 - b1)) >> 8));
+						data[offset] = r1 * amount1 + amount2 * r3;
+						data[offset+1] = g1 * amount1 + amount2 * g3;
+						data[offset+2] = b1 * amount1 + amount2 * b3;
+					}
+					break;
+
+				case "exclusion" : 
+					while (p--) {
+						var offset = p*4;
+						var r1 = data[offset], g1 = data[offset+1], b1 = data[offset+2];
+						var r2 = data2[offset], g2 = data2[offset+1], b2 = data2[offset+2];
+						var r3 = r2 + r1 - 2 * r2 * r1 / 255;
+						var g3 = g2 + g1 - 2 * g2 * g1 / 255;
+						var b3 = b2 + b1 - 2 * b2 * b1 / 255;
+						data[offset] = r1 * amount1 + amount2 * r3;
+						data[offset+1] = g1 * amount1 + amount2 * g3;
+						data[offset+2] = b1 * amount1 + amount2 * b3;
+					}
+					break;
+
+				case "overlay" : 
+					while (p--) {
+						var offset = p*4;
+						var r1 = data[offset], g1 = data[offset+1], b1 = data[offset+2];
+						var r2 = data2[offset], g2 = data2[offset+1], b2 = data2[offset+2];
+						var r3 = ((r1 < 128) ? (2*r2*r1/255) : (255-2*(255-r2) * (255-r1)/255));
+						var g3 = ((g1 < 128) ? (2*g2*g1/255) : (255-2*(255-g2) * (255-g1)/255));
+						var b3 = ((b1 < 128) ? (2*b2*b1/255) : (255-2*(255-b2) * (255-b1)/255));
+						data[offset] = r1 * amount1 + amount2 * r3;
+						data[offset+1] = g1 * amount1 + amount2 * g3;
+						data[offset+2] = b1 * amount1 + amount2 * b3;
+					}
+					break;
+
+				case "softlight" : 
+					while (p--) {
+						var offset = p*4;
+						var r1 = data[offset], g1 = data[offset+1], b1 = data[offset+2];
+						var r2 = data2[offset], g2 = data2[offset+1], b2 = data2[offset+2];
+						var r3 = ((r1 < 128) ? (2*((r2>>1)+64))*(r1/255) : (255-(2*(255-((r2>>1)+64))*(255-r1)/255)));
+						var g3 = ((g1 < 128) ? (2*((g2>>1)+64))*(g1/255) : (255-(2*(255-((g2>>1)+64))*(255-g1)/255)));
+						var b3 = ((b1 < 128) ? (2*((b2>>1)+64))*(b1/255) : (255-(2*(255-((b2>>1)+64))*(255-b1)/255)));
+						data[offset] = r1 * amount1 + amount2 * r3;
+						data[offset+1] = g1 * amount1 + amount2 * g3;
+						data[offset+2] = b1 * amount1 + amount2 * b3;
+					}
+					break;
+
+
+				case "hardlight" : 
+					while (p--) {
+						var offset = p*4;
+						var r1 = data[offset], g1 = data[offset+1], b1 = data[offset+2];
+						var r2 = data2[offset], g2 = data2[offset+1], b2 = data2[offset+2];
+						var r3 = ((r2 < 128) ? (2*r1*r2/255) : (255-2*(255-r1) * (255-r2)/255));
+						var g3 = ((g2 < 128) ? (2*g1*g2/255) : (255-2*(255-g1) * (255-g2)/255));
+						var b3 = ((b2 < 128) ? (2*b1*b2/255) : (255-2*(255-b1) * (255-b2)/255));
+						data[offset] = r1 * amount1 + amount2 * r3;
+						data[offset+1] = g1 * amount1 + amount2 * g3;
+						data[offset+2] = b1 * amount1 + amount2 * b3;
+					}
+					break;
+
+				case "colordodge" : 
+					while (p--) {
+						var offset = p*4;
+						var r1 = data[offset], g1 = data[offset+1], b1 = data[offset+2];
+						var r2 = data2[offset], g2 = data2[offset+1], b2 = data2[offset+2];
+						var r3 = (r2 == 255) ? 255 : ((r1<<8)/(255-r2));
+						var g3 = (g2 == 255) ? 255 : ((g1<<8)/(255-g2));
+						var b3 = (b2 == 255) ? 255 : ((b1<<8)/(255-b2));
+						data[offset] = r1 * amount1 + amount2 * (r3 > 255 ? 255 : r3);
+						data[offset+1] = g1 * amount1 + amount2 * (g3 > 255 ? 255 : g3);
+						data[offset+2] = b1 * amount1 + amount2 * (b3 > 255 ? 255 : b3);
+					}
+					break;
+
+				case "colorburn" : 
+					while (p--) {
+						var offset = p*4;
+						var r1 = data[offset], g1 = data[offset+1], b1 = data[offset+2];
+						var r2 = data2[offset], g2 = data2[offset+1], b2 = data2[offset+2];
+						var r3 = (r2 == 0) ? 0 : (255-((255-r1)<<8)/r2);
+						var g3 = (g2 == 0) ? 0 : (255-((255-g1)<<8)/g2);
+						var b3 = (b2 == 0) ? 0 : (255-((255-b1)<<8)/b2);
+						data[offset] = r1 * amount1 + amount2 * (r3 < 0 ? 0 : r3);
+						data[offset+1] = g1 * amount1 + amount2 * (g3 < 0 ? 0 : g3);
+						data[offset+2] = b1 * amount1 + amount2 * (b3 < 0 ? 0 : b3);
+					}
+					break;
+
+				case "linearlight" : 
+					while (p--) {
+						var offset = p*4;
+						var r1 = data[offset], g1 = data[offset+1], b1 = data[offset+2];
+						var r2 = data2[offset], g2 = data2[offset+1], b2 = data2[offset+2];
+						var r3 = (r2 < 128) ? ((2*r2+r1 < 255) ? 0 : (2*r2+r1-255)) : (r1+(2*(r2-128)));
+						var g3 = (g2 < 128) ? ((2*g2+g1 < 255) ? 0 : (2*g2+g1-255)) : (g1+(2*(g2-128)));
+						var b3 = (b2 < 128) ? ((2*b2+r1 < 255) ? 0 : (2*b2+r1-255)) : (b1+(2*(b2-128)));
+						if (r3 > 255) r3 = 255;
+						if (g3 > 255) g3 = 255;
+						if (b3 > 255) b3 = 255;
+						data[offset] = r1 * amount1 + amount2 * (r3 < 0 ? 0 : r3);
+						data[offset+1] = g1 * amount1 + amount2 * (g3 < 0 ? 0 : g3);
+						data[offset+2] = b1 * amount1 + amount2 * (b3 < 0 ? 0 : b3);
+					}
+					break;
+
+				case "vividlight" : 
+					while (p--) {
+						var offset = p*4;
+						var r1 = data[offset], g1 = data[offset+1], b1 = data[offset+2];
+						var r2 = data2[offset], g2 = data2[offset+1], b2 = data2[offset+2];
+						var r3 = (r2 < 128) ? ((r2 == 0) ? 0 : (255-((255-r1)<<8)/(2*r2))) : 
+							(((2*(r2-128)) == 255) ? 255 : ((r1<<8)/(255-(2*(r2-128)))));
+
+						var g3 = (g2 < 128) ? ((g2 == 0) ? 0 : (255-((255-g1)<<8)/(2*g2))) : 
+							(((2*(g2-128)) == 255) ? 255 : ((g1<<8)/(255-(2*(g2-128)))));
+
+						var b3 = (b2 < 128) ? ((b2 == 0) ? 0 : (255-((255-b1)<<8)/(2*b2))) : 
+							(((2*(b2-128)) == 255) ? 255 : ((b1<<8)/(255-(2*(b2-128)))));
+
+						if (r3 > 255) r3 = 255;
+						if (g3 > 255) g3 = 255;
+						if (b3 > 255) b3 = 255;
+						data[offset] = r1 * amount1 + amount2 * (r3 < 0 ? 0 : r3);
+						data[offset+1] = g1 * amount1 + amount2 * (g3 < 0 ? 0 : g3);
+						data[offset+2] = b1 * amount1 + amount2 * (b3 < 0 ? 0 : b3);
+					}
+					break;
+
+				case "pinlight" : 
+					while (p--) {
+						var offset = p*4;
+						var r1 = data[offset], g1 = data[offset+1], b1 = data[offset+2];
+						var r2 = data2[offset], g2 = data2[offset+1], b2 = data2[offset+2];
+
+						var r3 = (r2 < 128) ? (r1 < (2*r2) ? r1 : (2*r2)) : (r1 > (2*(r2-128)) ? r1 : (2*(r2-128)));
+						var g3 = (g2 < 128) ? (g1 < (2*g2) ? g1 : (2*g2)) : (g1 > (2*(g2-128)) ? g1 : (2*(g2-128)));
+						var b3 = (b2 < 128) ? (b1 < (2*b2) ? b1 : (2*b2)) : (b1 > (2*(b2-128)) ? b1 : (2*(b2-128)));
+
+						data[offset] = r1 * amount1 + amount2 * r3;
+						data[offset+1] = g1 * amount1 + amount2 * g3;
+						data[offset+2] = b1 * amount1 + amount2 * b3;
+					}
+					break;
+
+				case "hardmix" : 
+					while (p--) {
+						var offset = p*4;
+						var r1 = data[offset], g1 = data[offset+1], b1 = data[offset+2];
+						var r2 = data2[offset], g2 = data2[offset+1], b2 = data2[offset+2];
+						var r3 = (r2 < 128) ? ((r2 == 0) ? 0 : (255-((255-r1)<<8)/(2*r2))) : 
+							(((2*(r2-128)) == 255) ? 255 : ((r1<<8)/(255-(2*(r2-128)))));
+
+						var g3 = (g2 < 128) ? ((g2 == 0) ? 0 : (255-((255-g1)<<8)/(2*g2))) : 
+							(((2*(g2-128)) == 255) ? 255 : ((g1<<8)/(255-(2*(g2-128)))));
+
+						var b3 = (b2 < 128) ? ((b2 == 0) ? 0 : (255-((255-b1)<<8)/(2*b2))) : 
+							(((2*(b2-128)) == 255) ? 255 : ((b1<<8)/(255-(2*(b2-128)))));
+
+						data[offset] = r1 * amount1 + amount2 * (r3 < 128 ? 0 : 255);
+						data[offset+1] = g1 * amount1 + amount2 * (g3 < 128 ? 0 : 255);
+						data[offset+2] = b1 * amount1 + amount2 * (b3 < 128 ? 0 : 255);
+					}
+					break;
+
+/*
+#define ChannelBlend_HardMix(B,L)     ((uint8)((ChannelBlend_VividLight(B,L) < 128) ? 0:255))
+#define ChannelBlend_Reflect(B,L)     ((uint8)((L == 255) ? L:min(255, (B * B / (255 - L)))))
+#define ChannelBlend_Glow(B,L)        (ChannelBlend_Reflect(L,B))
+#define ChannelBlend_Phoenix(B,L)     ((uint8)(min(B,L) - max(B,L) + 255))
+#define ChannelBlend_Alpha(B,L,O)     ((uint8)(O * B + (1 - O) * L))
+#define ChannelBlend_AlphaF(B,L,F,O)  (ChannelBlend_Alpha(F(B,L),B,O))
+*/
+			}
+
+			return true;
+		}
+	},
+	checkSupport : function() {
+		return Pixastic.Client.hasCanvasImageData();
+	}
+}
\ No newline at end of file
diff --git a/actions/blur.js b/actions/blur.js
new file mode 100755
index 0000000..92ea4ac
--- /dev/null
+++ b/actions/blur.js
@@ -0,0 +1,126 @@
+/*
+ * Pixastic Lib - Blur filter - v0.1.0
+ * Copyright (c) 2008 Jacob Seidelin, jseidelin@nihilogic.dk, http://blog.nihilogic.dk/
+ * MIT License [http://www.opensource.org/licenses/mit-license.php]
+ */
+
+Pixastic.Actions.blur = {
+	process : function(params) {
+
+		if (typeof params.options.fixMargin == "undefined")
+			params.options.fixMargin = true;
+
+		if (Pixastic.Client.hasCanvasImageData()) {
+			var data = Pixastic.prepareData(params);
+			var dataCopy = Pixastic.prepareData(params, true)
+
+			/*
+			var kernel = [
+				[0.5, 	1, 	0.5],
+				[1, 	2, 	1],
+				[0.5, 	1, 	0.5]
+			];
+			*/
+
+			var kernel = [
+				[0, 	1, 	0],
+				[1, 	2, 	1],
+				[0, 	1, 	0]
+			];
+
+			var weight = 0;
+			for (var i=0;i<3;i++) {
+				for (var j=0;j<3;j++) {
+					weight += kernel[i][j];
+				}
+			}
+
+			weight = 1 / (weight*2);
+
+			var rect = params.options.rect;
+			var w = rect.width;
+			var h = rect.height;
+
+			var w4 = w*4;
+			var y = h;
+			do {
+				var offsetY = (y-1)*w4;
+
+				var prevY = (y == 1) ? 0 : y-2;
+				var nextY = (y == h) ? y - 1 : y;
+
+				var offsetYPrev = prevY*w*4;
+				var offsetYNext = nextY*w*4;
+
+				var x = w;
+				do {
+					var offset = offsetY + (x*4-4);
+
+					var offsetPrev = offsetYPrev + ((x == 1) ? 0 : x-2) * 4;
+					var offsetNext = offsetYNext + ((x == w) ? x-1 : x) * 4;
+	
+					data[offset] = (
+						/*
+						dataCopy[offsetPrev - 4]
+						+ dataCopy[offsetPrev+4] 
+						+ dataCopy[offsetNext - 4]
+						+ dataCopy[offsetNext+4]
+						+ 
+						*/
+						(dataCopy[offsetPrev]
+						+ dataCopy[offset-4]
+						+ dataCopy[offset+4]
+						+ dataCopy[offsetNext])		* 2
+						+ dataCopy[offset] 		* 4
+						) * weight;
+
+					data[offset+1] = (
+						/*
+						dataCopy[offsetPrev - 3]
+						+ dataCopy[offsetPrev+5] 
+						+ dataCopy[offsetNext - 3] 
+						+ dataCopy[offsetNext+5]
+						+ 
+						*/
+						(dataCopy[offsetPrev+1]
+						+ dataCopy[offset-3]
+						+ dataCopy[offset+5]
+						+ dataCopy[offsetNext+1])	* 2
+						+ dataCopy[offset+1] 		* 4
+						) * weight;
+
+					data[offset+2] = (
+						/*
+						dataCopy[offsetPrev - 2] 
+						+ dataCopy[offsetPrev+6] 
+						+ dataCopy[offsetNext - 2] 
+						+ dataCopy[offsetNext+6]
+						+ 
+						*/
+						(dataCopy[offsetPrev+2]
+						+ dataCopy[offset-2]
+						+ dataCopy[offset+6]
+						+ dataCopy[offsetNext+2])	* 2
+						+ dataCopy[offset+2] 		* 4
+						) * weight;
+
+				} while (--x);
+			} while (--y);
+
+			return true;
+
+		} else if (Pixastic.Client.isIE()) {
+			params.image.style.filter += " progid:DXImageTransform.Microsoft.Blur(pixelradius=1.5)";
+
+			if (params.options.fixMargin) {
+				params.image.style.marginLeft = (parseInt(params.image.style.marginLeft,10)||0) - 2 + "px";
+				params.image.style.marginTop = (parseInt(params.image.style.marginTop,10)||0) - 2 + "px";
+			}
+
+			return true;
+		}
+	},
+	checkSupport : function() {
+		return (Pixastic.Client.hasCanvasImageData() || Pixastic.Client.isIE());
+	}
+}
\ No newline at end of file
diff --git a/actions/blurfast.js b/actions/blurfast.js
new file mode 100755
index 0000000..411f672
--- /dev/null
+++ b/actions/blurfast.js
@@ -0,0 +1,81 @@
+/*
+ * Pixastic Lib - Blur Fast - v0.1.0
+ * Copyright (c) 2008 Jacob Seidelin, jseidelin@nihilogic.dk, http://blog.nihilogic.dk/
+ * MIT License [http://www.opensource.org/licenses/mit-license.php]
+ */
+
+Pixastic.Actions.blurfast = {
+	process : function(params) {
+
+		var amount = parseFloat(params.options.amount)||0;
+
+		amount = Math.max(0,Math.min(5,amount));
+
+		if (Pixastic.Client.hasCanvas()) {
+			var rect = params.options.rect;
+
+			var ctx = params.canvas.getContext("2d");
+			ctx.save();
+			ctx.beginPath();
+			ctx.moveTo(rect.left,rect.top);
+			ctx.lineTo(rect.left+rect.width,rect.top);
+			ctx.lineTo(rect.left+rect.width,rect.top+rect.height);
+			ctx.lineTo(rect.left,rect.top+rect.height);
+			ctx.lineTo(rect.left,rect.top);
+			ctx.closePath();
+			ctx.clip();
+
+			var scale = 2;
+			var smallWidth = Math.round(params.width / scale);
+			var smallHeight = Math.round(params.height / scale);
+
+			var copy = document.createElement("canvas");
+			copy.width = smallWidth;
+			copy.height = smallHeight;
+
+			var clear = true;
+			var steps = Math.round(amount * 20);
+
+			var copyCtx = copy.getContext("2d");
+			for (var i=0;i<steps;i++) {
+				var scaledWidth = Math.max(1,Math.round(smallWidth - i));
+				var scaledHeight = Math.max(1,Math.round(smallHeight - i));
+	
+				copyCtx.clearRect(0,0,smallWidth,smallHeight);
+	
+				copyCtx.drawImage(
+					params.canvas,
+					0,0,params.width,params.height,
+					0,0,scaledWidth,scaledHeight
+				);
+	
+				if (clear)
+					ctx.clearRect(rect.left,rect.top,rect.width,rect.height);
+	
+				ctx.drawImage(
+					copy,
+					0,0,scaledWidth,scaledHeight,
+					0,0,params.width,params.height
+				);
+			}
+
+			ctx.restore();
+
+			params.useData = false;
+			return true;
+		} else if (Pixastic.Client.isIE()) {
+			var radius = 10 * amount;
+			params.image.style.filter += " progid:DXImageTransform.Microsoft.Blur(pixelradius=" + radius + ")";
+
+			if (params.options.fixMargin || 1) {
+				params.image.style.marginLeft = (parseInt(params.image.style.marginLeft,10)||0) - Math.round(radius) + "px";
+				params.image.style.marginTop = (parseInt(params.image.style.marginTop,10)||0) - Math.round(radius) + "px";
+			}
+
+			return true;
+		}
+	},
+	checkSupport : function() {
+		return (Pixastic.Client.hasCanvas() || Pixastic.Client.isIE());
+	}
+}
diff --git a/actions/brightness.js b/actions/brightness.js
new file mode 100755
index 0000000..930a8bb
--- /dev/null
+++ b/actions/brightness.js
@@ -0,0 +1,71 @@
+/*
+ * Pixastic Lib - Brightness/Contrast filter - v0.1.0
+ * Copyright (c) 2008 Jacob Seidelin, jseidelin@nihilogic.dk, http://blog.nihilogic.dk/
+ * MIT License [http://www.opensource.org/licenses/mit-license.php]
+ */
+
+Pixastic.Actions.brightness = {
+
+	process : function(params) {
+
+		var brightness = parseInt(params.options.brightness,10) || 0;
+		var contrast = parseFloat(params.options.contrast)||0;
+		var legacy = !!(params.options.legacy);
+
+		if (legacy) {
+			brightness = Math.min(150,Math.max(-150,brightness));
+		} else {
+			var brightMul = 1 + Math.min(150,Math.max(-150,brightness)) / 150;
+		}
+		contrast = Math.max(0,contrast+1);
+
+		if (Pixastic.Client.hasCanvasImageData()) {
+			var data = Pixastic.prepareData(params);
+			var rect = params.options.rect;
+			var w = rect.width;
+			var h = rect.height;
+			var w4 = w*4;
+			var y = h;
+			do {
+				var offsetY = (y-1)*w4;
+				var x = w;
+				do {
+					var offset = offsetY + (x-1)*4;
+
+					if (legacy) {
+						var r = data[offset] + brightness;
+						var g = data[offset+1] + brightness;
+						var b = data[offset+2] + brightness;
+					} else {
+						var r = data[offset] * brightMul;
+						var g = data[offset+1] * brightMul;
+						var b = data[offset+2] * brightMul;
+					}
+
+					if (contrast != 1) {
+						r = (r - 128) * contrast + 128;
+						g = (g - 128) * contrast + 128;
+						b = (b - 128) * contrast + 128;
+					}
+
+					if (r < 0 ) r = 0;
+					if (g < 0 ) g = 0;
+					if (b < 0 ) b = 0;
+					if (r > 255 ) r = 255;
+					if (g > 255 ) g = 255;
+					if (b > 255 ) b = 255;
+
+					data[offset] = r;
+					data[offset+1] = g;
+					data[offset+2] = b;
+
+				} while (--x);
+			} while (--y);
+			return true;
+		}
+	},
+	checkSupport : function() {
+		return Pixastic.Client.hasCanvasImageData();
+	}
+}
+
diff --git a/actions/coloradjust.js b/actions/coloradjust.js
new file mode 100755
index 0000000..82dc37e
--- /dev/null
+++ b/actions/coloradjust.js
@@ -0,0 +1,54 @@
+/*
+ * Pixastic Lib - Color adjust filter - v0.1.0
+ * Copyright (c) 2008 Jacob Seidelin, jseidelin@nihilogic.dk, http://blog.nihilogic.dk/
+ * MIT License [http://www.opensource.org/licenses/mit-license.php]
+ */
+
+Pixastic.Actions.coloradjust = {
+
+	process : function(params) {
+		var red = parseFloat(params.options.red) || 0;
+		var green = parseFloat(params.options.green) || 0;
+		var blue = parseFloat(params.options.blue) || 0;
+
+		red = Math.round(red*255);
+		green = Math.round(green*255);
+		blue = Math.round(blue*255);
+
+		if (Pixastic.Client.hasCanvasImageData()) {
+			var data = Pixastic.prepareData(params);
+			var rect = params.options.rect;
+			var w = rect.width;
+			var h = rect.height;
+			var w4 = w*4;
+			var y = h;
+			do {
+				var offsetY = (y-1)*w4;
+				var x = w;
+				do {
+					var offset = offsetY + (x-1)*4;
+
+					var r = data[offset] + red;
+					var g = data[offset+1] + green;
+					var b = data[offset+2] + blue;
+
+					if (r < 0 ) r = 0;
+					if (g < 0 ) g = 0;
+					if (b < 0 ) b = 0;
+					if (r > 255 ) r = 255;
+					if (g > 255 ) g = 255;
+					if (b > 255 ) b = 255;
+
+					data[offset] = r;
+					data[offset+1] = g;
+					data[offset+2] = b;
+
+				} while (--x);
+			} while (--y);
+			return true;
+		}
+	},
+	checkSupport : function() {
+		return (Pixastic.Client.hasCanvasImageData());
+	}
+}
diff --git a/actions/crop.js b/actions/crop.js
new file mode 100755
index 0000000..81d10b1
--- /dev/null
+++ b/actions/crop.js
@@ -0,0 +1,35 @@
+/*
+ * Pixastic Lib - Crop - v0.1.0
+ * Copyright (c) 2008 Jacob Seidelin, jseidelin@nihilogic.dk, http://blog.nihilogic.dk/
+ * MIT License [http://www.opensource.org/licenses/mit-license.php]
+ */
+
+Pixastic.Actions.crop = {
+	process : function(params) {
+		if (Pixastic.Client.hasCanvas()) {
+			var rect = params.options.rect;
+
+			var copy = document.createElement("canvas");
+			copy.width = params.width;
+			copy.height = params.height;
+			copy.getContext("2d").drawImage(params.canvas,0,0);
+
+			params.canvas.width = rect.width;
+			params.canvas.height = rect.height;
+			params.canvas.getContext("2d").clearRect(0,0,rect.width,rect.height);
+
+			params.canvas.getContext("2d").drawImage(copy,
+				rect.left,rect.top,rect.width,rect.height,
+				0,0,rect.width,rect.height
+			);
+
+			params.useData = false;
+			return true;
+		}
+	},
+	checkSupport : function() {
+		return Pixastic.Client.hasCanvas();
+	}
+}
+
+
diff --git a/actions/desaturate.js b/actions/desaturate.js
new file mode 100755
index 0000000..a122137
--- /dev/null
+++ b/actions/desaturate.js
@@ -0,0 +1,39 @@
+/*
+ * Pixastic Lib - Desaturation filter - v0.1.0
+ * Copyright (c) 2008 Jacob Seidelin, jseidelin@nihilogic.dk, http://blog.nihilogic.dk/
+ * MIT License [http://www.opensource.org/licenses/mit-license.php]
+ */
+
+Pixastic.Actions.desaturate = {
+
+	process : function(params) {
+		var useAverage = !!params.options.average;
+
+		if (Pixastic.Client.hasCanvasImageData()) {
+			var data = Pixastic.prepareData(params);
+			var rect = params.options.rect;
+			var w = rect.width;
+			var h = rect.height;
+			var w4 = w*4;
+			var y = h;
+			do {
+				var offsetY = (y-1)*w4;
+				var x = w;
+				do {
+					var offset = offsetY + (x-1)*4;
+					var brightness = useAverage ?
+						(data[offset]+data[offset+1]+data[offset+2])/3
+						: (data[offset]*0.3 + data[offset+1]*0.59 + data[offset+2]*0.11);
+					data[offset] = data[offset+1] = data[offset+2] = brightness;
+				} while (--x);
+			} while (--y);
+			return true;
+		} else if (Pixastic.Client.isIE()) {
+			params.image.style.filter += " gray";
+			return true;
+		}
+	},
+	checkSupport : function() {
+		return (Pixastic.Client.hasCanvasImageData() || Pixastic.Client.isIE());
+	}
+}
\ No newline at end of file
diff --git a/actions/edges.js b/actions/edges.js
new file mode 100755
index 0000000..68d4f32
--- /dev/null
+++ b/actions/edges.js
@@ -0,0 +1,121 @@
+/*
+ * Pixastic Lib - Edge detection filter - v0.1.0
+ * Copyright (c) 2008 Jacob Seidelin, jseidelin@nihilogic.dk, http://blog.nihilogic.dk/
+ * MIT License [http://www.opensource.org/licenses/mit-license.php]
+ */
+
+Pixastic.Actions.edges = {
+	process : function(params) {
+
+		var mono = !!(params.options.mono);
+
+		var strength = 1.0;
+
+		//if (typeof params.options.strength != "undefined")
+		//	strength = parseFloat(params.options.strength)||0;
+
+		var invert = !!(params.options.invert);
+
+		if (Pixastic.Client.hasCanvasImageData()) {
+			var data = Pixastic.prepareData(params);
+			var dataCopy = Pixastic.prepareData(params, true)
+
+			var c = -strength/8;
+			var kernel = [
+				[c, 	c, 	c],
+				[c, 	1, 	c],
+				[c, 	c, 	c]
+			];
+
+			weight = 1/c;
+
+			var rect = params.options.rect;
+			var w = rect.width;
+			var h = rect.height;
+
+			var w4 = w*4;
+			var y = h;
+			do {
+				var offsetY = (y-1)*w4;
+
+				var nextY = (y == h) ? y - 1 : y;
+				var prevY = (y == 1) ? 0 : y-2;
+
+				var offsetYPrev = prevY*w*4;
+				var offsetYNext = nextY*w*4;
+
+				var x = w;
+				do {
+					var offset = offsetY + (x*4-4);
+
+					var offsetPrev = offsetYPrev + ((x == 1) ? 0 : x-2) * 4;
+					var offsetNext = offsetYNext + ((x == w) ? x-1 : x) * 4;
+	
+					var r = ((dataCopy[offsetPrev-4]
+						+ dataCopy[offsetPrev]
+						+ dataCopy[offsetPrev+4]
+						+ dataCopy[offset-4]
+						+ dataCopy[offset+4]
+						+ dataCopy[offsetNext-4]
+						+ dataCopy[offsetNext]
+						+ dataCopy[offsetNext+4]) * c
+						+ dataCopy[offset]
+						) 
+						* weight;
+	
+					var g = ((dataCopy[offsetPrev-3]
+						+ dataCopy[offsetPrev+1]
+						+ dataCopy[offsetPrev+5]
+						+ dataCopy[offset-3]
+						+ dataCopy[offset+5]
+						+ dataCopy[offsetNext-3]
+						+ dataCopy[offsetNext+1]
+						+ dataCopy[offsetNext+5]) * c
+						+ dataCopy[offset+1])
+						* weight;
+	
+					var b = ((dataCopy[offsetPrev-2]
+						+ dataCopy[offsetPrev+2]
+						+ dataCopy[offsetPrev+6]
+						+ dataCopy[offset-2]
+						+ dataCopy[offset+6]
+						+ dataCopy[offsetNext-2]
+						+ dataCopy[offsetNext+2]
+						+ dataCopy[offsetNext+6]) * c
+						+ dataCopy[offset+2])
+						* weight;
+
+					if (mono) {
+						var brightness = (r*0.3 + g*0.59 + b*0.11)||0;
+						if (invert) brightness = 255 - brightness;
+						if (brightness < 0 ) brightness = 0;
+						if (brightness > 255 ) brightness = 255;
+						r = g = b = brightness;
+					} else {
+						if (invert) {
+							r = 255 - r;
+							g = 255 - g;
+							b = 255 - b;
+						}
+						if (r < 0 ) r = 0;
+						if (g < 0 ) g = 0;
+						if (b < 0 ) b = 0;
+						if (r > 255 ) r = 255;
+						if (g > 255 ) g = 255;
+						if (b > 255 ) b = 255;
+					}
+
+					data[offset] = r;
+					data[offset+1] = g;
+					data[offset+2] = b;
+
+				} while (--x);
+			} while (--y);
+
+			return true;
+		}
+	},
+	checkSupport : function() {
+		return Pixastic.Client.hasCanvasImageData();
+	}
+}
\ No newline at end of file
diff --git a/actions/edges2.js b/actions/edges2.js
new file mode 100755
index 0000000..e3a742c
--- /dev/null
+++ b/actions/edges2.js
@@ -0,0 +1,103 @@
+/*
+ * Pixastic Lib - Edge detection 2 - v0.1.0
+ * Copyright (c) 2008 Jacob Seidelin, jseidelin@nihilogic.dk, http://blog.nihilogic.dk/
+ * MIT License [http://www.opensource.org/licenses/mit-license.php]
+ * 
+ * Contribution by Oliver Hunt (http://nerget.com/, http://nerget.com/canvas/edgeDetection.js). Thanks Oliver!
+ *
+ */
+
+Pixastic.Actions.edges2 = {
+	process : function(params) {
+
+		if (Pixastic.Client.hasCanvasImageData()) {
+			var data = Pixastic.prepareData(params);
+			var dataCopy = Pixastic.prepareData(params, true)
+
+			var rect = params.options.rect;
+			var w = rect.width;
+			var h = rect.height;
+
+			var w4 = w * 4;
+			var pixel = w4 + 4; // Start at (1,1)
+			var hm1 = h - 1;
+			var wm1 = w - 1;
+			for (var y = 1; y < hm1; ++y) {
+				// Prepare initial cached values for current row
+				var centerRow = pixel - 4;
+				var priorRow = centerRow - w4;
+				var nextRow = centerRow + w4;
+				
+				var r1 = - dataCopy[priorRow]   - dataCopy[centerRow]   - dataCopy[nextRow];
+				var g1 = - dataCopy[++priorRow] - dataCopy[++centerRow] - dataCopy[++nextRow];
+				var b1 = - dataCopy[++priorRow] - dataCopy[++centerRow] - dataCopy[++nextRow];
+				
+				var rp = dataCopy[priorRow += 2];
+				var gp = dataCopy[++priorRow];
+				var bp = dataCopy[++priorRow];
+				
+				var rc = dataCopy[centerRow += 2];
+				var gc = dataCopy[++centerRow];
+				var bc = dataCopy[++centerRow];
+				
+				var rn = dataCopy[nextRow += 2];
+				var gn = dataCopy[++nextRow];
+				var bn = dataCopy[++nextRow];
+				
+				var r2 = - rp - rc - rn;
+				var g2 = - gp - gc - gn;
+				var b2 = - bp - bc - bn;
+				
+				// Main convolution loop
+				for (var x = 1; x < wm1; ++x) {
+					centerRow = pixel + 4;
+					priorRow = centerRow - w4;
+					nextRow = centerRow + w4;
+					
+					var r = 127 + r1 - rp - (rc * -8) - rn;
+					var g = 127 + g1 - gp - (gc * -8) - gn;
+					var b = 127 + b1 - bp - (bc * -8) - bn;
+					
+					r1 = r2;
+					g1 = g2;
+					b1 = b2;
+					
+					rp = dataCopy[  priorRow];
+					gp = dataCopy[++priorRow];
+					bp = dataCopy[++priorRow];
+					
+					rc = dataCopy[  centerRow];
+					gc = dataCopy[++centerRow];
+					bc = dataCopy[++centerRow];
+					
+					rn = dataCopy[  nextRow];
+					gn = dataCopy[++nextRow];
+					bn = dataCopy[++nextRow];
+					
+					r += (r2 = - rp - rc - rn);
+					g += (g2 = - gp - gc - gn);
+					b += (b2 = - bp - bc - bn);
+
+					if (r > 255) r = 255;
+					if (g > 255) g = 255;
+					if (b > 255) b = 255;
+					if (r < 0) r = 0;
+					if (g < 0) g = 0;
+					if (b < 0) b = 0;
+
+					data[pixel] = r;
+					data[++pixel] = g;
+					data[++pixel] = b;
+					//data[++pixel] = 255; // alpha
+
+					pixel+=2;
+				}
+				pixel += 8;
+			}
+			return true;
+		}
+	},
+	checkSupport : function() {
+		return Pixastic.Client.hasCanvasImageData();
+	}
+}
\ No newline at end of file
diff --git a/actions/emboss.js b/actions/emboss.js
new file mode 100755
index 0000000..234dfe7
--- /dev/null
+++ b/actions/emboss.js
@@ -0,0 +1,134 @@
+/*
+ * Pixastic Lib - Emboss filter - v0.1.0
+ * Copyright (c) 2008 Jacob Seidelin, jseidelin@nihilogic.dk, http://blog.nihilogic.dk/
+ * MIT License [http://www.opensource.org/licenses/mit-license.php]
+ */
+
+Pixastic.Actions.emboss = {
+	process : function(params) {
+
+		var strength = parseFloat(params.options.strength)||1;
+		var greyLevel = typeof params.options.greyLevel != "undefined" ? parseInt(params.options.greyLevel) : 180;
+		var direction = params.options.direction||"topleft";
+		var blend = !!params.options.blend;
+
+		var dirY = 0;
+		var dirX = 0;
+
+		switch (direction) {
+			case "topleft":			// top left
+				dirY = -1;
+				dirX = -1;
+				break;
+			case "top":			// top
+				dirY = -1;
+				dirX = 0;
+				break;
+			case "topright":			// top right
+				dirY = -1;
+				dirX = 1;
+				break;
+			case "right":			// right
+				dirY = 0;
+				dirX = 1;
+				break;
+			case "bottomright":			// bottom right
+				dirY = 1;
+				dirX = 1;
+				break;
+			case "bottom":			// bottom
+				dirY = 1;
+				dirX = 0;
+				break;
+			case "bottomleft":			// bottom left
+				dirY = 1;
+				dirX = -1;
+				break;
+			case "left":			// left
+				dirY = 0;
+				dirX = -1;
+				break;
+		}
+
+		if (Pixastic.Client.hasCanvasImageData()) {
+			var data = Pixastic.prepareData(params);
+			var dataCopy = Pixastic.prepareData(params, true)
+
+			var invertAlpha = !!params.options.invertAlpha;
+			var rect = params.options.rect;
+			var w = rect.width;
+			var h = rect.height;
+
+			var w4 = w*4;
+			var y = h;
+			do {
+				var offsetY = (y-1)*w4;
+
+				var otherY = dirY;
+				if (y + otherY < 1) otherY = 0;
+				if (y + otherY > h) otherY = 0;
+
+				var offsetYOther = (y-1+otherY)*w*4;
+
+				var x = w;
+				do {
+						var offset = offsetY + (x-1)*4;
+
+						var otherX = dirX;
+						if (x + otherX < 1) otherX = 0;
+						if (x + otherX > w) otherX = 0;
+
+						var offsetOther = offsetYOther + (x-1+otherX)*4;
+
+						var dR = dataCopy[offset] - dataCopy[offsetOther];
+						var dG = dataCopy[offset+1] - dataCopy[offsetOther+1];
+						var dB = dataCopy[offset+2] - dataCopy[offsetOther+2];
+
+						var dif = dR;
+						var absDif = dif > 0 ? dif : -dif;
+
+						var absG = dG > 0 ? dG : -dG;
+						var absB = dB > 0 ? dB : -dB;
+
+						if (absG > absDif) {
+							dif = dG;
+						}
+						if (absB > absDif) {
+							dif = dB;
+						}
+
+						dif *= strength;
+
+						if (blend) {
+							var r = data[offset] + dif;
+							var g = data[offset+1] + dif;
+							var b = data[offset+2] + dif;
+
+							data[offset] = (r > 255) ? 255 : (r < 0 ? 0 : r);
+							data[offset+1] = (g > 255) ? 255 : (g < 0 ? 0 : g);
+							data[offset+2] = (b > 255) ? 255 : (b < 0 ? 0 : b);
+						} else {
+							var grey = greyLevel - dif;
+							if (grey < 0) {
+								grey = 0;
+							} else if (grey > 255) {
+								grey = 255;
+							}
+
+							data[offset] = data[offset+1] = data[offset+2] = grey;
+						}
+
+				} while (--x);
+			} while (--y);
+			return true;
+
+		} else if (Pixastic.Client.isIE()) {
+			params.image.style.filter += " progid:DXImageTransform.Microsoft.emboss()";
+			return true;
+		}
+	},
+	checkSupport : function() {
+		return (Pixastic.Client.hasCanvasImageData() || Pixastic.Client.isIE());
+	}
+
+}
diff --git a/actions/fliph.js b/actions/fliph.js
new file mode 100755
index 0000000..9f544e2
--- /dev/null
+++ b/actions/fliph.js
@@ -0,0 +1,33 @@
+/*
+ * Pixastic Lib - Horizontal flip - v0.1.0
+ * Copyright (c) 2008 Jacob Seidelin, jseidelin@nihilogic.dk, http://blog.nihilogic.dk/
+ * MIT License [http://www.opensource.org/licenses/mit-license.php]
+ */
+
+Pixastic.Actions.fliph = {
+	process : function(params) {
+		if (Pixastic.Client.hasCanvas()) {
+			var rect = params.options.rect;
+			var copyCanvas = document.createElement("canvas");
+			copyCanvas.width = rect.width;
+			copyCanvas.height = rect.height;
+			copyCanvas.getContext("2d").drawImage(params.image, rect.left, rect.top, rect.width, rect.height, 0, 0, rect.width, rect.height);
+
+			var ctx = params.canvas.getContext("2d");
+			ctx.clearRect(rect.left, rect.top, rect.width, rect.height);
+			ctx.scale(-1,1);
+			ctx.drawImage(copyCanvas, -rect.left-rect.width, rect.top, rect.width, rect.height)
+			params.useData = false;
+
+			return true;		
+
+		} else if (Pixastic.Client.isIE()) {
+			params.image.style.filter += " fliph";
+			return true;
+		}
+	},
+	checkSupport : function() {
+		return (Pixastic.Client.hasCanvas() || Pixastic.Client.isIE());
+	}
+}
+
diff --git a/actions/flipv.js b/actions/flipv.js
new file mode 100755
index 0000000..f52f1e4
--- /dev/null
+++ b/actions/flipv.js
@@ -0,0 +1,33 @@
+/*
+ * Pixastic Lib - Vertical flip - v0.1.0
+ * Copyright (c) 2008 Jacob Seidelin, jseidelin@nihilogic.dk, http://blog.nihilogic.dk/
+ * MIT License [http://www.opensource.org/licenses/mit-license.php]
+ */
+
+Pixastic.Actions.flipv = {
+	process : function(params) {
+		if (Pixastic.Client.hasCanvas()) {
+			var rect = params.options.rect;
+			var copyCanvas = document.createElement("canvas");
+			copyCanvas.width = rect.width;
+			copyCanvas.height = rect.height;
+			copyCanvas.getContext("2d").drawImage(params.image, rect.left, rect.top, rect.width, rect.height, 0, 0, rect.width, rect.height);
+
+			var ctx = params.canvas.getContext("2d");
+			ctx.clearRect(rect.left, rect.top, rect.width, rect.height);
+			ctx.scale(1,-1);
+			ctx.drawImage(copyCanvas, rect.left, -rect.top-rect.height, rect.width, rect.height)
+			params.useData = false;
+
+			return true;		
+
+		} else if (Pixastic.Client.isIE()) {
+			params.image.style.filter += " flipv";
+			return true;
+		}
+	},
+	checkSupport : function() {
+		return (Pixastic.Client.hasCanvas() || Pixastic.Client.isIE());
+	}
+}
+
diff --git a/actions/glow.js b/actions/glow.js
new file mode 100755
index 0000000..7ba7818
--- /dev/null
+++ b/actions/glow.js
@@ -0,0 +1,98 @@
+/*
+ * Pixastic Lib - Glow - v0.1.0
+ * Copyright (c) 2008 Jacob Seidelin, jseidelin@nihilogic.dk, http://blog.nihilogic.dk/
+ * MIT License [http://www.opensource.org/licenses/mit-license.php]
+ */
+
+
+Pixastic.Actions.glow = {
+	process : function(params) {
+
+		var amount = (parseFloat(params.options.amount)||0);
+		var blurAmount = parseFloat(params.options.radius)||0;
+
+		amount = Math.min(1,Math.max(0,amount));
+		blurAmount = Math.min(5,Math.max(0,blurAmount));
+
+		if (Pixastic.Client.hasCanvasImageData()) {
+			var rect = params.options.rect;
+
+			var blurCanvas = document.createElement("canvas");
+			blurCanvas.width = params.width;
+			blurCanvas.height = params.height;
+			var blurCtx = blurCanvas.getContext("2d");
+			blurCtx.drawImage(params.canvas,0,0);
+
+			var scale = 2;
+			var smallWidth = Math.round(params.width / scale);
+			var smallHeight = Math.round(params.height / scale);
+
+			var copy = document.createElement("canvas");
+			copy.width = smallWidth;
+			copy.height = smallHeight;
+
+			var clear = true;
+			var steps = Math.round(blurAmount * 20);
+
+			var copyCtx = copy.getContext("2d");
+			for (var i=0;i<steps;i++) {
+				var scaledWidth = Math.max(1,Math.round(smallWidth - i));
+				var scaledHeight = Math.max(1,Math.round(smallHeight - i));
+	
+				copyCtx.clearRect(0,0,smallWidth,smallHeight);
+	
+				copyCtx.drawImage(
+					blurCanvas,
+					0,0,params.width,params.height,
+					0,0,scaledWidth,scaledHeight
+				);
+	
+				blurCtx.clearRect(0,0,params.width,params.height);
+	
+				blurCtx.drawImage(
+					copy,
+					0,0,scaledWidth,scaledHeight,
+					0,0,params.width,params.height
+				);
+			}
+
+			var data = Pixastic.prepareData(params);
+			var blurData = Pixastic.prepareData({canvas:blurCanvas,options:params.options});
+			var w = rect.width;
+			var h = rect.height;
+			var w4 = w*4;
+			var y = h;
+			do {
+				var offsetY = (y-1)*w4;
+				var x = w;
+				do {
+					var offset = offsetY + (x*4-4);
+
+					var r = data[offset] + amount * blurData[offset];
+					var g = data[offset+1] + amount * blurData[offset+1];
+					var b = data[offset+2] + amount * blurData[offset+2];
+	
+					if (r > 255) r = 255;
+					if (g > 255) g = 255;
+					if (b > 255) b = 255;
+					if (r < 0) r = 0;
+					if (g < 0) g = 0;
+					if (b < 0) b = 0;
+
+					data[offset] = r;
+					data[offset+1] = g;
+					data[offset+2] = b;
+
+				} while (--x);
+			} while (--y);
+
+			return true;
+		}
+	},
+	checkSupport : function() {
+		return Pixastic.Client.hasCanvasImageData();
+	}
+}
+
+
+
diff --git a/actions/histogram.js b/actions/histogram.js
new file mode 100755
index 0000000..ab648f4
--- /dev/null
+++ b/actions/histogram.js
@@ -0,0 +1,76 @@
+/*
+ * Pixastic Lib - Histogram - v0.1.0
+ * Copyright (c) 2008 Jacob Seidelin, jseidelin@nihilogic.dk, http://blog.nihilogic.dk/
+ * MIT License [http://www.opensource.org/licenses/mit-license.php]
+ */
+
+Pixastic.Actions.histogram = {
+	process : function(params) {
+
+		var average = !!(params.options.average);
+		var paint = !!(params.options.paint);
+		var color = params.options.color || "rgba(255,255,255,0.5)";
+		var values = [];
+		if (typeof params.options.returnValue != "object") {
+			params.options.returnValue = {values:[]};
+		}
+		var returnValue = params.options.returnValue;
+		if (typeof returnValue.values != "array") {
+			returnValue.values = [];
+		}
+		values = returnValue.values;
+
+		if (Pixastic.Client.hasCanvasImageData()) {
+			var data = Pixastic.prepareData(params);
+			params.useData = false;
+
+			for (var i=0;i<256;i++) {
+				values[i] = 0;
+			}
+
+			var rect = params.options.rect;
+			var w = rect.width;
+			var h = rect.height;
+			var w4 = w*4;
+			var y = h;
+			do {
+				var offsetY = (y-1)*w4;
+				var x = w;
+				do {
+					var offset = offsetY + (x*4-4);
+					var brightness = average ? 
+						Math.round((data[offset]+data[offset+1]+data[offset+2])/3)
+						: Math.round(data[offset]*0.3 + data[offset+1]*0.59 + data[offset+2]*0.11);
+					values[brightness]++;
+
+				} while (--x);
+			} while (--y);
+
+			if (paint) {
+				var maxValue = 0;
+				for (var i=0;i<256;i++) {
+					if (values[i] > maxValue) {
+						maxValue = values[i];
+					}
+				}
+				var heightScale = params.height / maxValue;
+				var widthScale = params.width / 256;
+				var ctx = params.canvas.getContext("2d");
+				ctx.fillStyle = color;
+				for (var i=0;i<256;i++) {
+					ctx.fillRect(
+						i * widthScale, params.height - heightScale * values[i],
+						widthScale, values[i] * heightScale
+					);
+				}
+			}
+
+			returnValue.values = values;
+
+			return true;
+		}
+	},
+	checkSupport : function() {
+		return Pixastic.Client.hasCanvasImageData();
+	}
+}
diff --git a/actions/hsl.js b/actions/hsl.js
new file mode 100755
index 0000000..6f096d7
--- /dev/null
+++ b/actions/hsl.js
@@ -0,0 +1,135 @@
+/*
+ * Pixastic Lib - HSL Adjust  - v0.1.0
+ * Copyright (c) 2008 Jacob Seidelin, jseidelin@nihilogic.dk, http://blog.nihilogic.dk/
+ * MIT License [http://www.opensource.org/licenses/mit-license.php]
+ */
+
+Pixastic.Actions.hsl = {
+	process : function(params) {
+
+		var hue = parseInt(params.options.hue,10)||0;
+		var saturation = (parseInt(params.options.saturation,10)||0) / 100;
+		var lightness = (parseInt(params.options.lightness,10)||0) / 100;
+
+
+		// this seems to give the same result as Photoshop
+		if (saturation < 0) {
+			var satMul = 1+saturation;
+		} else {
+			var satMul = 1+saturation*2;
+		}
+
+		hue = (hue%360) / 360;
+		var hue6 = hue * 6;
+
+		var rgbDiv = 1 / 255;
+
+		var light255 = lightness * 255;
+		var lightp1 = 1 + lightness;
+		var lightm1 = 1 - lightness;
+		if (Pixastic.Client.hasCanvasImageData()) {
+			var data = Pixastic.prepareData(params);
+
+			var rect = params.options.rect;
+			var w = rect.width;
+			var h = rect.height;
+
+			var w4 = w*4;
+			var y = h;
+
+			do {
+				var offsetY = (y-1)*w4;
+				var x = w;
+				do {
+					var offset = offsetY + (x*4-4);
+
+					var r = data[offset];
+					var g = data[offset+1];
+					var b = data[offset+2];
+
+					if (hue != 0 || saturation != 0) {
+						// ok, here comes rgb to hsl + adjust + hsl to rgb, all in one jumbled mess. 
+						// It's not so pretty, but it's been optimized to get somewhat decent performance.
+						// The transforms were originally adapted from the ones found in Graphics Gems, but have been heavily modified.
+						var vs = r;
+						if (g > vs) vs = g;
+						if (b > vs) vs = b;
+						var ms = r;
+						if (g < ms) ms = g;
+						if (b < ms) ms = b;
+						var vm = (vs-ms);
+						var l = (ms+vs)/255 * 0.5;
+						if (l > 0) {
+							if (vm > 0) {
+								if (l <= 0.5) {
+									var s = vm / (vs+ms) * satMul;
+									if (s > 1) s = 1;
+									var v = (l * (1+s));
+								} else {
+									var s = vm / (510-vs-ms) * satMul;
+									if (s > 1) s = 1;
+									var v = (l+s - l*s);
+								}
+								if (r == vs) {
+									if (g == ms)
+										var h = 5 + ((vs-b)/vm) + hue6;
+									else
+										var h = 1 - ((vs-g)/vm) + hue6;
+								} else if (g == vs) {
+									if (b == ms)
+										var h = 1 + ((vs-r)/vm) + hue6;
+									else
+										var h = 3 - ((vs-b)/vm) + hue6;
+								} else {
+									if (r == ms)
+										var h = 3 + ((vs-g)/vm) + hue6;
+									else
+										var h = 5 - ((vs-r)/vm) + hue6;
+								}
+								if (h < 0) h+=6;
+								if (h >= 6) h-=6;
+								var m = (l+l-v);
+								var sextant = h>>0;
+								switch (sextant) {
+									case 0: r = v*255; g = (m+((v-m)*(h-sextant)))*255; b = m*255; break;
+									case 1: r = (v-((v-m)*(h-sextant)))*255; g = v*255; b = m*255; break;
+									case 2: r = m*255; g = v*255; b = (m+((v-m)*(h-sextant)))*255; break;
+									case 3: r = m*255; g = (v-((v-m)*(h-sextant)))*255; b = v*255; break;
+									case 4: r = (m+((v-m)*(h-sextant)))*255; g = m*255; b = v*255; break;
+									case 5: r = v*255; g = m*255; b = (v-((v-m)*(h-sextant)))*255; break;
+								}
+							}
+						}
+					}
+
+					if (lightness < 0) {
+						r *= lightp1;
+						g *= lightp1;
+						b *= lightp1;
+					} else if (lightness > 0) {
+						r = r * lightm1 + light255;
+						g = g * lightm1 + light255;
+						b = b * lightm1 + light255;
+					}
+
+					if (r < 0) r = 0;
+					if (g < 0) g = 0;
+					if (b < 0) b = 0;
+					if (r > 255) r = 255;
+					if (g > 255) g = 255;
+					if (b > 255) b = 255;
+
+					data[offset] = r;
+					data[offset+1] = g;
+					data[offset+2] = b;
+
+				} while (--x);
+			} while (--y);
+			return true;
+		}
+	},
+	checkSupport : function() {
+		return Pixastic.Client.hasCanvasImageData();
+	}
+
+}
diff --git a/actions/invert.js b/actions/invert.js
new file mode 100755
index 0000000..7d262cc
--- /dev/null
+++ b/actions/invert.js
@@ -0,0 +1,40 @@
+/*
+ * Pixastic Lib - Invert filter - v0.1.0
+ * Copyright (c) 2008 Jacob Seidelin, jseidelin@nihilogic.dk, http://blog.nihilogic.dk/
+ * MIT License [http://www.opensource.org/licenses/mit-license.php]
+ */
+
+Pixastic.Actions.invert = {
+	process : function(params) {
+		if (Pixastic.Client.hasCanvasImageData()) {
+			var data = Pixastic.prepareData(params);
+
+			var invertAlpha = !!params.options.invertAlpha;
+			var rect = params.options.rect;
+			var w = rect.width;
+			var h = rect.height;
+
+			var w4 = w*4;
+			var y = h;
+			do {
+				var offsetY = (y-1)*w4;
+				var x = w;
+				do {
+					var offset = offsetY + (x-1)*4;
+					data[offset] = 255 - data[offset];
+					data[offset+1] = 255 - data[offset+1];
+					data[offset+2] = 255 - data[offset+2];
+					if (invertAlpha) data[offset+3] = 255 - data[offset+3];
+				} while (--x);
+			} while (--y);
+
+			return true;
+		} else if (Pixastic.Client.isIE()) {
+			params.image.style.filter += " invert";
+			return true;
+		}
+	},
+	checkSupport : function() {
+		return (Pixastic.Client.hasCanvasImageData() || Pixastic.Client.isIE());
+	}
+}
diff --git a/actions/laplace.js b/actions/laplace.js
new file mode 100755
index 0000000..7ac1bb4
--- /dev/null
+++ b/actions/laplace.js
@@ -0,0 +1,112 @@
+/*
+ * Pixastic Lib - Laplace filter - v0.1.0
+ * Copyright (c) 2008 Jacob Seidelin, jseidelin@nihilogic.dk, http://blog.nihilogic.dk/
+ * MIT License [http://www.opensource.org/licenses/mit-license.php]
+ */
+
+Pixastic.Actions.laplace = {
+	process : function(params) {
+
+		var strength = 1.0;
+		var invert = !!(params.options.invert);
+		var contrast = parseFloat(params.options.edgeStrength)||0;
+
+		var greyLevel = parseInt(params.options.greyLevel)||0;
+
+		contrast = -contrast;
+
+		if (Pixastic.Client.hasCanvasImageData()) {
+			var data = Pixastic.prepareData(params);
+			var dataCopy = Pixastic.prepareData(params, true)
+
+			var kernel = [
+				[-1, 	-1, 	-1],
+				[-1, 	8, 	-1],
+				[-1, 	-1, 	-1]
+			];
+
+			var weight = 1/8;
+
+			var rect = params.options.rect;
+			var w = rect.width;
+			var h = rect.height;
+
+			var w4 = w*4;
+			var y = h;
+			do {
+				var offsetY = (y-1)*w4;
+
+				var nextY = (y == h) ? y - 1 : y;
+				var prevY = (y == 1) ? 0 : y-2;
+
+				var offsetYPrev = prevY*w*4;
+				var offsetYNext = nextY*w*4;
+
+				var x = w;
+				do {
+					var offset = offsetY + (x*4-4);
+
+					var offsetPrev = offsetYPrev + ((x == 1) ? 0 : x-2) * 4;
+					var offsetNext = offsetYNext + ((x == w) ? x-1 : x) * 4;
+	
+					var r = ((-dataCopy[offsetPrev-4]
+						- dataCopy[offsetPrev]
+						- dataCopy[offsetPrev+4]
+						- dataCopy[offset-4]
+						- dataCopy[offset+4]
+						- dataCopy[offsetNext-4]
+						- dataCopy[offsetNext]
+						- dataCopy[offsetNext+4])
+						+ dataCopy[offset] * 8) 
+						* weight;
+	
+					var g = ((-dataCopy[offsetPrev-3]
+						- dataCopy[offsetPrev+1]
+						- dataCopy[offsetPrev+5]
+						- dataCopy[offset-3]
+						- dataCopy[offset+5]
+						- dataCopy[offsetNext-3]
+						- dataCopy[offsetNext+1]
+						- dataCopy[offsetNext+5])
+						+ dataCopy[offset+1] * 8)
+						* weight;
+	
+					var b = ((-dataCopy[offsetPrev-2]
+						- dataCopy[offsetPrev+2]
+						- dataCopy[offsetPrev+6]
+						- dataCopy[offset-2]
+						- dataCopy[offset+6]
+						- dataCopy[offsetNext-2]
+						- dataCopy[offsetNext+2]
+						- dataCopy[offsetNext+6])
+						+ dataCopy[offset+2] * 8)
+						* weight;
+
+					var brightness = ((r + g + b)/3) + greyLevel;
+
+					if (contrast != 0) {
+						if (brightness > 127) {
+							brightness += ((brightness + 1) - 128) * contrast;
+						} else if (brightness < 127) {
+							brightness -= (brightness + 1) * contrast;
+						}
+					}
+					if (invert) {
+						brightness = 255 - brightness;
+					}
+					if (brightness < 0 ) brightness = 0;
+					if (brightness > 255 ) brightness = 255;
+
+					data[offset] = data[offset+1] = data[offset+2] = brightness;
+
+				} while (--x);
+			} while (--y);
+
+			return true;
+		}
+	},
+	checkSupport : function() {
+		return Pixastic.Client.hasCanvasImageData();
+	}
+}
+
diff --git a/actions/lighten.js b/actions/lighten.js
new file mode 100755
index 0000000..8118349
--- /dev/null
+++ b/actions/lighten.js
@@ -0,0 +1,73 @@
+/*
+ * Pixastic Lib - Lighten filter - v0.1.0
+ * Copyright (c) 2008 Jacob Seidelin, jseidelin@nihilogic.dk, http://blog.nihilogic.dk/
+ * MIT License [http://www.opensource.org/licenses/mit-license.php]
+ */
+
+Pixastic.Actions.lighten = {
+
+	process : function(params) {
+		var amount = parseFloat(params.options.amount) || 0;
+
+		if (Pixastic.Client.hasCanvasImageData()) {
+			var data = Pixastic.prepareData(params);
+			var rect = params.options.rect;
+			var w = rect.width;
+			var h = rect.height;
+			var w4 = w*4;
+			var y = h;
+			do {
+				var offsetY = (y-1)*w4;
+				var x = w;
+				do {
+					var offset = offsetY + (x-1)*4;
+
+					var r = data[offset];
+					var g = data[offset+1];
+					var b = data[offset+2];
+
+					r += r*amount;
+					g += g*amount;
+					b += b*amount;
+
+					if (r < 0 ) r = 0;
+					if (g < 0 ) g = 0;
+					if (b < 0 ) b = 0;
+					if (r > 255 ) r = 255;
+					if (g > 255 ) g = 255;
+					if (b > 255 ) b = 255;
+
+					data[offset] = r;
+					data[offset+1] = g;
+					data[offset+2] = b;
+
+				} while (--x);
+			} while (--y);
+			return true;
+
+		} else if (Pixastic.Client.isIE()) {
+			var img = params.image;
+			if (amount < 0) {
+				img.style.filter += " light()";
+				img.filters[img.filters.length-1].addAmbient(
+					255,255,255,
+					100 * -amount
+				);
+			} else if (amount > 0) {
+				img.style.filter += " light()";
+				img.filters[img.filters.length-1].addAmbient(
+					255,255,255,
+					100
+				);
+				img.filters[img.filters.length-1].addAmbient(
+					255,255,255,
+					100 * amount
+				);
+			}
+			return true;
+		}
+	},
+	checkSupport : function() {
+		return (Pixastic.Client.hasCanvasImageData() || Pixastic.Client.isIE());
+	}
+}
diff --git a/actions/mosaic.js b/actions/mosaic.js
new file mode 100755
index 0000000..09ecf5b
--- /dev/null
+++ b/actions/mosaic.js
@@ -0,0 +1,48 @@
+/*
+ * Pixastic Lib - Mosaic filter - v0.1.0
+ * Copyright (c) 2008 Jacob Seidelin, jseidelin@nihilogic.dk, http://blog.nihilogic.dk/
+ * MIT License [http://www.opensource.org/licenses/mit-license.php]
+ */
+
+Pixastic.Actions.mosaic = {
+
+	process : function(params) {
+		var blockSize = Math.max(1,parseInt(params.options.blockSize,10));
+
+		if (Pixastic.Client.hasCanvasImageData()) {
+			var rect = params.options.rect;
+			var w = rect.width;
+			var h = rect.height;
+			var w4 = w*4;
+			var y = h;
+
+			var ctx = params.canvas.getContext("2d");
+
+			var pixel = document.createElement("canvas");
+			pixel.width = pixel.height = 1;
+			var pixelCtx = pixel.getContext("2d");
+
+			var copy = document.createElement("canvas");
+			copy.width = w;
+			copy.height = h;
+			var copyCtx = copy.getContext("2d");
+			copyCtx.drawImage(params.canvas,rect.left,rect.top,w,h, 0,0,w,h);
+
+			for (var y=0;y<h;y+=blockSize) {
+				for (var x=0;x<w;x+=blockSize) {
+					pixelCtx.drawImage(copy, x, y, blockSize, blockSize, 0, 0, 1, 1);
+					var data = pixelCtx.getImageData(0,0,1,1).data;
+					ctx.fillStyle = "rgb(" + data[0] + "," + data[1] + "," + data[2] + ")";
+					ctx.fillRect(rect.left + x, rect.top + y, blockSize, blockSize);
+				}
+			}
+
+			params.useData = false;
+
+			return true;
+		}
+	},
+	checkSupport : function() {
+		return (Pixastic.Client.hasCanvasImageData());
+	}
+}
\ No newline at end of file
diff --git a/actions/noise.js b/actions/noise.js
new file mode 100755
index 0000000..1c73fa6
--- /dev/null
+++ b/actions/noise.js
@@ -0,0 +1,73 @@
+/*
+ * Pixastic Lib - Noise filter - v0.1.0
+ * Copyright (c) 2008 Jacob Seidelin, jseidelin@nihilogic.dk, http://blog.nihilogic.dk/
+ * MIT License [http://www.opensource.org/licenses/mit-license.php]
+ */
+
+Pixastic.Actions.noise = {
+
+	process : function(params) {
+		var amount = 0;
+		var strength = 0;
+		var mono = false;
+
+		if (typeof params.options.amount != "undefined")
+			amount = parseFloat(params.options.amount)||0;
+		if (typeof params.options.strength != "undefined")
+			strength = parseFloat(params.options.strength)||0;
+		if (typeof params.options.mono != "undefined")
+			mono = !!(params.options.mono);
+
+		amount = Math.max(0,Math.min(1,amount));
+		strength = Math.max(0,Math.min(1,strength));
+
+		var noise = 128 * strength;
+		var noise2 = noise / 2;
+
+		if (Pixastic.Client.hasCanvasImageData()) {
+			var data = Pixastic.prepareData(params);
+			var rect = params.options.rect;
+			var w = rect.width;
+			var h = rect.height;
+			var w4 = w*4;
+			var y = h;
+			var random = Math.random;
+
+			do {
+				var offsetY = (y-1)*w4;
+				var x = w;
+				do {
+					var offset = offsetY + (x-1)*4;
+					if (random() < amount) {
+						if (mono) {
+							var pixelNoise = - noise2 + random() * noise;
+							var r = data[offset] + pixelNoise;
+							var g = data[offset+1] + pixelNoise;
+							var b = data[offset+2] + pixelNoise;
+						} else {
+							var r = data[offset] - noise2 + (random() * noise);
+							var g = data[offset+1] - noise2 + (random() * noise);
+							var b = data[offset+2] - noise2 + (random() * noise);
+						}
+
+						if (r < 0 ) r = 0;
+						if (g < 0 ) g = 0;
+						if (b < 0 ) b = 0;
+						if (r > 255 ) r = 255;
+						if (g > 255 ) g = 255;
+						if (b > 255 ) b = 255;
+
+						data[offset] = r;
+						data[offset+1] = g;
+						data[offset+2] = b;
+					}
+				} while (--x);
+			} while (--y);
+			return true;
+		}
+	},
+	checkSupport : function() {
+		return Pixastic.Client.hasCanvasImageData();
+	}
+}
+
diff --git a/actions/pointillize.js b/actions/pointillize.js
new file mode 100755
index 0000000..d11aa80
--- /dev/null
+++ b/actions/pointillize.js
@@ -0,0 +1,71 @@
+/*
+ * Pixastic Lib - Pointillize filter - v0.1.0
+ * Copyright (c) 2008 Jacob Seidelin, jseidelin@nihilogic.dk, http://blog.nihilogic.dk/
+ * MIT License [http://www.opensource.org/licenses/mit-license.php]
+ */
+
+Pixastic.Actions.pointillize = {
+
+	process : function(params) {
+		var radius = Math.max(1,parseInt(params.options.radius,10));
+		var density = Math.min(5,Math.max(0,parseFloat(params.options.density)||0));
+		var noise = Math.max(0,parseFloat(params.options.noise)||0);
+		var transparent = !!params.options.transparent;
+
+		if (Pixastic.Client.hasCanvasImageData()) {
+			var rect = params.options.rect;
+			var w = rect.width;
+			var h = rect.height;
+			var w4 = w*4;
+			var y = h;
+
+			var ctx = params.canvas.getContext("2d");
+
+			var pixel = document.createElement("canvas");
+			pixel.width = pixel.height = 1;
+			var pixelCtx = pixel.getContext("2d");
+
+			var copy = document.createElement("canvas");
+			copy.width = w;
+			copy.height = h;
+			var copyCtx = copy.getContext("2d");
+			copyCtx.drawImage(params.canvas,rect.left,rect.top,w,h, 0,0,w,h);
+
+			var diameter = radius * 2;
+
+			if (transparent)
+				ctx.clearRect(rect.left, rect.top, rect.width, rect.height);
+
+			var noiseRadius = radius * noise;
+
+			var dist = 1 / density;
+
+			for (var y=0;y<h+radius;y+=diameter*dist) {
+				for (var x=0;x<w+radius;x+=diameter*dist) {
+					rndX = noise ? (x+((Math.random()*2-1) * noiseRadius))>>0 : x;
+					rndY = noise ? (y+((Math.random()*2-1) * noiseRadius))>>0 : y;
+
+					var pixX = rndX - radius;
+					var pixY = rndY - radius;
+					if (pixX < 0) pixX = 0;
+					if (pixY < 0) pixY = 0;
+
+					pixelCtx.drawImage(copy, pixX, pixY, diameter, diameter, 0, 0, 1, 1);
+					var data = pixelCtx.getImageData(0,0,1,1).data;
+					ctx.fillStyle = "rgb(" + data[0] + "," + data[1] + "," + data[2] + ")";
+					ctx.beginPath();
+					ctx.arc(rect.left + rndX,rect.top + rndY, radius, 0, Math.PI*2, true);
+					ctx.closePath();
+					ctx.fill();
+				}
+			}
+
+			params.useData = false;
+
+			return true;
+		}
+	},
+	checkSupport : function() {
+		return (Pixastic.Client.hasCanvasImageData());
+	}
+}
\ No newline at end of file
diff --git a/actions/posterize.js b/actions/posterize.js
new file mode 100755
index 0000000..0242104
--- /dev/null
+++ b/actions/posterize.js
@@ -0,0 +1,57 @@
+/*
+ * Pixastic Lib - Posterize effect - v0.1.0
+ * Copyright (c) 2008 Jacob Seidelin, jseidelin@nihilogic.dk, http://blog.nihilogic.dk/
+ * MIT License [http://www.opensource.org/licenses/mit-license.php]
+ */
+
+Pixastic.Actions.posterize = {
+
+	process : function(params) {
+
+		
+		var numLevels = 256;
+		if (typeof params.options.levels != "undefined")
+			numLevels = parseInt(params.options.levels,10)||1;
+
+		if (Pixastic.Client.hasCanvasImageData()) {
+			var data = Pixastic.prepareData(params);
+
+			numLevels = Math.max(2,Math.min(256,numLevels));
+	
+			var numAreas = 256 / numLevels;
+			var numValues = 256 / (numLevels-1);
+
+			var rect = params.options.rect;
+			var w = rect.width;
+			var h = rect.height;
+			var w4 = w*4;
+			var y = h;
+			do {
+				var offsetY = (y-1)*w4;
+				var x = w;
+				do {
+					var offset = offsetY + (x-1)*4;
+
+					var r = numValues * ((data[offset] / numAreas)>>0);
+					var g = numValues * ((data[offset+1] / numAreas)>>0);
+					var b = numValues * ((data[offset+2] / numAreas)>>0);
+
+					if (r > 255) r = 255;
+					if (g > 255) g = 255;
+					if (b > 255) b = 255;
+
+					data[offset] = r;
+					data[offset+1] = g;
+					data[offset+2] = b;
+
+				} while (--x);
+			} while (--y);
+			return true;
+		}
+	},
+	checkSupport : function() {
+		return Pixastic.Client.hasCanvasImageData();
+	}
+}
+
+
diff --git a/actions/removenoise.js b/actions/removenoise.js
new file mode 100755
index 0000000..4d4e0e8
--- /dev/null
+++ b/actions/removenoise.js
@@ -0,0 +1,89 @@
+/*
+ * Pixastic Lib - Remove noise - v0.1.0
+ * Copyright (c) 2008 Jacob Seidelin, jseidelin@nihilogic.dk, http://blog.nihilogic.dk/
+ * MIT License [http://www.opensource.org/licenses/mit-license.php]
+ */
+
+Pixastic.Actions.removenoise = {
+	process : function(params) {
+
+		if (Pixastic.Client.hasCanvasImageData()) {
+			var data = Pixastic.prepareData(params);
+
+			var rect = params.options.rect;
+			var w = rect.width;
+			var h = rect.height;
+
+			var w4 = w*4;
+			var y = h;
+			do {
+				var offsetY = (y-1)*w4;
+
+				var nextY = (y == h) ? y - 1 : y;
+				var prevY = (y == 1) ? 0 : y-2;
+
+				var offsetYPrev = prevY*w*4;
+				var offsetYNext = nextY*w*4;
+
+				var x = w;
+				do {
+					var offset = offsetY + (x*4-4);
+
+					var offsetPrev = offsetYPrev + ((x == 1) ? 0 : x-2) * 4;
+					var offsetNext = offsetYNext + ((x == w) ? x-1 : x) * 4;
+
+					var minR, maxR, minG, maxG, minB, maxB;
+
+					minR = maxR = data[offsetPrev];
+					var r1 = data[offset-4], r2 = data[offset+4], r3 = data[offsetNext];
+					if (r1 < minR) minR = r1;
+					if (r2 < minR) minR = r2;
+					if (r3 < minR) minR = r3;
+					if (r1 > maxR) maxR = r1;
+					if (r2 > maxR) maxR = r2;
+					if (r3 > maxR) maxR = r3;
+
+					minG = maxG = data[offsetPrev+1];
+					var g1 = data[offset-3], g2 = data[offset+5], g3 = data[offsetNext+1];
+					if (g1 < minG) minG = g1;
+					if (g2 < minG) minG = g2;
+					if (g3 < minG) minG = g3;
+					if (g1 > maxG) maxG = g1;
+					if (g2 > maxG) maxG = g2;
+					if (g3 > maxG) maxG = g3;
+
+					minB = maxB = data[offsetPrev+2];
+					var b1 = data[offset-2], b2 = data[offset+6], b3 = data[offsetNext+2];
+					if (b1 < minB) minB = b1;
+					if (b2 < minB) minB = b2;
+					if (b3 < minB) minB = b3;
+					if (b1 > maxB) maxB = b1;
+					if (b2 > maxB) maxB = b2;
+					if (b3 > maxB) maxB = b3;
+
+					if (data[offset] > maxR) {
+						data[offset] = maxR;
+					} else if (data[offset] < minR) {
+						data[offset] = minR;
+					}
+					if (data[offset+1] > maxG) {
+						data[offset+1] = maxG;
+					} else if (data[offset+1] < minG) {
+						data[offset+1] = minG;
+					}
+					if (data[offset+2] > maxB) {
+						data[offset+2] = maxB;
+					} else if (data[offset+2] < minB) {
+						data[offset+2] = minB;
+					}
+
+				} while (--x);
+			} while (--y);
+
+			return true;
+		}
+	},
+	checkSupport : function() {
+		return Pixastic.Client.hasCanvasImageData();
+	}
+}
\ No newline at end of file
diff --git a/actions/sepia.js b/actions/sepia.js
new file mode 100755
index 0000000..b662300
--- /dev/null
+++ b/actions/sepia.js
@@ -0,0 +1,60 @@
+/*
+ * Pixastic Lib - Sepia filter - v0.1.0
+ * Copyright (c) 2008 Jacob Seidelin, jseidelin@nihilogic.dk, http://blog.nihilogic.dk/
+ * MIT License [http://www.opensource.org/licenses/mit-license.php]
+ */
+
+Pixastic.Actions.sepia = {
+
+	process : function(params) {
+		var mode = (parseInt(params.options.mode,10)||0);
+		if (mode < 0) mode = 0;
+		if (mode > 1) mode = 1;
+
+		if (Pixastic.Client.hasCanvasImageData()) {
+			var data = Pixastic.prepareData(params);
+			var rect = params.options.rect;
+			var w = rect.width;
+			var h = rect.height;
+			var w4 = w*4;
+			var y = h;
+			do {
+				var offsetY = (y-1)*w4;
+				var x = w;
+				do {
+					var offset = offsetY + (x-1)*4;
+
+					if (mode) {
+						// a bit faster, but not as good
+						var d = data[offset] * 0.299 + data[offset+1] * 0.587 + data[offset+2] * 0.114;
+						var r = (d + 39);
+						var g = (d + 14);
+						var b = (d - 36);
+					} else {
+						// Microsoft
+						var or = data[offset];
+						var og = data[offset+1];
+						var ob = data[offset+2];
+	
+						var r = (or * 0.393 + og * 0.769 + ob * 0.189);
+						var g = (or * 0.349 + og * 0.686 + ob * 0.168);
+						var b = (or * 0.272 + og * 0.534 + ob * 0.131);
+					}
+
+					if (r < 0) r = 0; if (r > 255) r = 255;
+					if (g < 0) g = 0; if (g > 255) g = 255;
+					if (b < 0) b = 0; if (b > 255) b = 255;
+
+					data[offset] = r;
+					data[offset+1] = g;
+					data[offset+2] = b;
+
+				} while (--x);
+			} while (--y);
+			return true;
+		}
+	},
+	checkSupport : function() {
+		return Pixastic.Client.hasCanvasImageData();
+	}
+}
\ No newline at end of file
diff --git a/actions/sharpen.js b/actions/sharpen.js
new file mode 100755
index 0000000..05991fc
--- /dev/null
+++ b/actions/sharpen.js
@@ -0,0 +1,110 @@
+/*
+ * Pixastic Lib - Sharpen filter - v0.1.0
+ * Copyright (c) 2008 Jacob Seidelin, jseidelin@nihilogic.dk, http://blog.nihilogic.dk/
+ * MIT License [http://www.opensource.org/licenses/mit-license.php]
+ */
+
+Pixastic.Actions.sharpen = {
+	process : function(params) {
+
+		var strength = 0;
+		if (typeof params.options.amount != "undefined")
+			strength = parseFloat(params.options.amount)||0;
+
+		if (strength < 0) strength = 0;
+		if (strength > 1) strength = 1;
+
+		if (Pixastic.Client.hasCanvasImageData()) {
+			var data = Pixastic.prepareData(params);
+			var dataCopy = Pixastic.prepareData(params, true)
+
+			var mul = 15;
+			var mulOther = 1 + 3*strength;
+
+			var kernel = [
+				[0, 	-mulOther, 	0],
+				[-mulOther, 	mul, 	-mulOther],
+				[0, 	-mulOther, 	0]
+			];
+
+			var weight = 0;
+			for (var i=0;i<3;i++) {
+				for (var j=0;j<3;j++) {
+					weight += kernel[i][j];
+				}
+			}
+
+			weight = 1 / weight;
+
+			var rect = params.options.rect;
+			var w = rect.width;
+			var h = rect.height;
+
+			mul *= weight;
+			mulOther *= weight;
+
+			var w4 = w*4;
+			var y = h;
+			do {
+				var offsetY = (y-1)*w4;
+
+				var nextY = (y == h) ? y - 1 : y;
+				var prevY = (y == 1) ? 0 : y-2;
+
+				var offsetYPrev = prevY*w4;
+				var offsetYNext = nextY*w4;
+
+				var x = w;
+				do {
+					var offset = offsetY + (x*4-4);
+
+					var offsetPrev = offsetYPrev + ((x == 1) ? 0 : x-2) * 4;
+					var offsetNext = offsetYNext + ((x == w) ? x-1 : x) * 4;
+
+					var r = ((
+						- dataCopy[offsetPrev]
+						- dataCopy[offset-4]
+						- dataCopy[offset+4]
+						- dataCopy[offsetNext])		* mulOther
+						+ dataCopy[offset] 	* mul
+						);
+
+					var g = ((
+						- dataCopy[offsetPrev+1]
+						- dataCopy[offset-3]
+						- dataCopy[offset+5]
+						- dataCopy[offsetNext+1])	* mulOther
+						+ dataCopy[offset+1] 	* mul
+						);
+
+					var b = ((
+						- dataCopy[offsetPrev+2]
+						- dataCopy[offset-2]
+						- dataCopy[offset+6]
+						- dataCopy[offsetNext+2])	* mulOther
+						+ dataCopy[offset+2] 	* mul
+						);
+
+
+					if (r < 0 ) r = 0;
+					if (g < 0 ) g = 0;
+					if (b < 0 ) b = 0;
+					if (r > 255 ) r = 255;
+					if (g > 255 ) g = 255;
+					if (b > 255 ) b = 255;
+
+					data[offset] = r;
+					data[offset+1] = g;
+					data[offset+2] = b;
+
+				} while (--x);
+			} while (--y);
+
+			return true;
+
+		}
+	},
+	checkSupport : function() {
+		return Pixastic.Client.hasCanvasImageData();
+	}
+}
diff --git a/actions/solarize - Kopi.js b/actions/solarize - Kopi.js
new file mode 100755
index 0000000..7e06596
--- /dev/null
+++ b/actions/solarize - Kopi.js	
@@ -0,0 +1,56 @@
+/*
+ * Pixastic Lib - Solarize filter - v0.1.0
+ * Copyright (c) 2008 Jacob Seidelin, jseidelin@nihilogic.dk, http://blog.nihilogic.dk/
+ * MIT License [http://www.opensource.org/licenses/mit-license.php]
+ */
+
+Pixastic.Actions.solarize = {
+
+	process : function(params) {
+		var useAverage = !!params.options.average;
+
+		if (Pixastic.Client.hasCanvasImageData()) {
+			var data = Pixastic.prepareData(params);
+			var rect = params.options.rect;
+			var w = rect.width;
+			var h = rect.height;
+			var w4 = w*4;
+			var y = h;
+			do {
+				var offsetY = (y-1)*w4;
+				var x = w;
+				do {
+					var offset = offsetY + (x-1)*4;
+
+					var r = data[offset];
+					var g = data[offset+1];
+					var b = data[offset+2];
+
+					//r = (r > 127 ? 2 * (r - 127) : 2 * (127 - r));
+					//g = (g > 127 ? 2 * (g - 127) : 2 * (127 - g));
+					//b = (b > 127 ? 2 * (b - 127) : 2 * (127 - b));
+
+					r = r > 127 ? 255 - r : r;
+					g = g > 127 ? 255 - g : g;
+					b = b > 127 ? 255 - b : b;
+
+					if (r < 0 ) r = 0;
+					if (g < 0 ) g = 0;
+					if (b < 0 ) b = 0;
+					if (r > 255 ) r = 255;
+					if (g > 255 ) g = 255;
+					if (b > 255 ) b = 255;
+
+					data[offset] = r;
+					data[offset+1] = g;
+					data[offset+2] = b;
+
+				} while (--x);
+			} while (--y);
+			return true;
+		}
+	},
+	checkSupport : function() {
+		return (Pixastic.Client.hasCanvasImageData());
+	}
+}
\ No newline at end of file
diff --git a/actions/solarize.js b/actions/solarize.js
new file mode 100755
index 0000000..06f1f0e
--- /dev/null
+++ b/actions/solarize.js
@@ -0,0 +1,45 @@
+/*
+ * Pixastic Lib - Solarize filter - v0.1.0
+ * Copyright (c) 2008 Jacob Seidelin, jseidelin@nihilogic.dk, http://blog.nihilogic.dk/
+ * MIT License [http://www.opensource.org/licenses/mit-license.php]
+ */
+
+Pixastic.Actions.solarize = {
+
+	process : function(params) {
+		var useAverage = !!params.options.average;
+
+		if (Pixastic.Client.hasCanvasImageData()) {
+			var data = Pixastic.prepareData(params);
+			var rect = params.options.rect;
+			var w = rect.width;
+			var h = rect.height;
+			var w4 = w*4;
+			var y = h;
+			do {
+				var offsetY = (y-1)*w4;
+				var x = w;
+				do {
+					var offset = offsetY + (x-1)*4;
+
+					var r = data[offset];
+					var g = data[offset+1];
+					var b = data[offset+2];
+
+					if (r > 127) r = 255 - r;
+					if (g > 127) g = 255 - g;
+					if (b > 127) b = 255 - b;
+
+					data[offset] = r;
+					data[offset+1] = g;
+					data[offset+2] = b;
+
+				} while (--x);
+			} while (--y);
+			return true;
+		}
+	},
+	checkSupport : function() {
+		return (Pixastic.Client.hasCanvasImageData());
+	}
+}
\ No newline at end of file
diff --git a/actions/unsharpmask.js b/actions/unsharpmask.js
new file mode 100755
index 0000000..d41ce20
--- /dev/null
+++ b/actions/unsharpmask.js
@@ -0,0 +1,111 @@
+/*
+ * Pixastic Lib - USM - v0.1.0
+ * Copyright (c) 2008 Jacob Seidelin, jseidelin@nihilogic.dk, http://blog.nihilogic.dk/
+ * MIT License [http://www.opensource.org/licenses/mit-license.php]
+ */
+
+
+Pixastic.Actions.unsharpmask = {
+	process : function(params) {
+
+		var amount = (parseFloat(params.options.amount)||0);
+		var blurAmount = parseFloat(params.options.radius)||0;
+		var threshold = parseFloat(params.options.threshold)||0;
+
+		amount = Math.min(500,Math.max(0,amount)) / 2;
+		blurAmount = Math.min(5,Math.max(0,blurAmount)) / 10;
+		threshold = Math.min(255,Math.max(0,threshold));
+
+		threshold--;
+		var thresholdNeg = -threshold;
+
+		amount *= 0.016;
+		amount++;
+
+		if (Pixastic.Client.hasCanvasImageData()) {
+			var rect = params.options.rect;
+
+			var blurCanvas = document.createElement("canvas");
+			blurCanvas.width = params.width;
+			blurCanvas.height = params.height;
+			var blurCtx = blurCanvas.getContext("2d");
+			blurCtx.drawImage(params.canvas,0,0);
+
+			var scale = 2;
+			var smallWidth = Math.round(params.width / scale);
+			var smallHeight = Math.round(params.height / scale);
+
+			var copy = document.createElement("canvas");
+			copy.width = smallWidth;
+			copy.height = smallHeight;
+
+			var steps = Math.round(blurAmount * 20);
+
+			var copyCtx = copy.getContext("2d");
+			for (var i=0;i<steps;i++) {
+				var scaledWidth = Math.max(1,Math.round(smallWidth - i));
+				var scaledHeight = Math.max(1,Math.round(smallHeight - i));
+
+				copyCtx.clearRect(0,0,smallWidth,smallHeight);
+
+				copyCtx.drawImage(
+					blurCanvas,
+					0,0,params.width,params.height,
+					0,0,scaledWidth,scaledHeight
+				);
+	
+				blurCtx.clearRect(0,0,params.width,params.height);
+	
+				blurCtx.drawImage(
+					copy,
+					0,0,scaledWidth,scaledHeight,
+					0,0,params.width,params.height
+				);
+			}
+
+			var data = Pixastic.prepareData(params);
+			var blurData = Pixastic.prepareData({canvas:blurCanvas,options:params.options});
+			var w = rect.width;
+			var h = rect.height;
+			var w4 = w*4;
+			var y = h;
+			do {
+				var offsetY = (y-1)*w4;
+				var x = w;
+				do {
+					var offset = offsetY + (x*4-4);
+
+					var difR = data[offset] - blurData[offset];
+					if (difR > threshold || difR < thresholdNeg) {
+						var blurR = blurData[offset];
+						blurR = amount * difR + blurR;
+						data[offset] = blurR > 255 ? 255 : (blurR < 0 ? 0 : blurR);
+					}
+
+					var difG = data[offset+1] - blurData[offset+1];
+					if (difG > threshold || difG < thresholdNeg) {
+						var blurG = blurData[offset+1];
+						blurG = amount * difG + blurG;
+						data[offset+1] = blurG > 255 ? 255 : (blurG < 0 ? 0 : blurG);
+					}
+
+					var difB = data[offset+2] - blurData[offset+2];
+					if (difB > threshold || difB < thresholdNeg) {
+						var blurB = blurData[offset+2];
+						blurB = amount * difB + blurB;
+						data[offset+2] = blurB > 255 ? 255 : (blurB < 0 ? 0 : blurB);
+					}
+
+				} while (--x);
+			} while (--y);
+
+			return true;
+		}
+	},
+	checkSupport : function() {
+		return Pixastic.Client.hasCanvasImageData();
+	}
+}
+
+
+
diff --git a/pixastic.core.js b/pixastic.core.js
new file mode 100755
index 0000000..696c546
--- /dev/null
+++ b/pixastic.core.js
@@ -0,0 +1,335 @@
+/*
+ * Pixastic Lib - Core Functions - v0.1.0
+ * Copyright (c) 2008 Jacob Seidelin, cupboy@gmail.com, http://blog.nihilogic.dk/
+ * MIT License [http://www.opensource.org/licenses/mit-license.php]
+ */
+
+var Pixastic = (function() {
+
+
+
+	function addEvent(el, event, handler) {
+		if (el.addEventListener)
+			el.addEventListener(event, handler, false); 
+		else if (el.attachEvent)
+			el.attachEvent("on" + event, handler); 
+	}
+
+	function onready(handler) {
+		var handlerDone = false;
+		var execHandler = function() {
+			if (!handlerDone) {
+				handlerDone = true;
+				handler();
+			}
+		}
+		document.write("<"+"script defer src=\"//:\" id=\"__onload_ie_sumbox__\"></"+"script>");
+		var script = document.getElementById("__onload_ie_sumbox__");
+		script.onreadystatechange = function() {
+			if (script.readyState == "complete") {
+				script.parentNode.removeChild(script);
+				execHandler();
+			}
+		}
+		if (document.addEventListener)
+			document.addEventListener("DOMContentLoaded", execHandler, false); 
+		addEvent(window, "load", execHandler);
+	}
+
+
+	function init() {
+		if (!Pixastic.parseOnLoad) return;
+		var imgEls = getElementsByClass("pixastic", null, "img");
+		var canvasEls = getElementsByClass("pixastic", null, "canvas");
+		var elements = imgEls.concat(canvasEls);
+		for (var i=0;i<elements.length;i++) {
+			(function() {
+
+			var el = elements[i];
+			var actions = [];
+			var classes = el.className.split(" ");
+			for (var c=0;c<classes.length;c++) {
+				var cls = classes[c];
+				if (cls.substring(0,9) == "pixastic-") {
+					var actionName = cls.substring(9);
+					if (actionName != "")
+						actions.push(actionName);
+				}
+			}
+			if (actions.length) {
+				if (el.tagName == "IMG") {
+					var dataImg = new Image();
+					dataImg.src = el.src;
+					if (dataImg.complete) {
+						for (var a=0;a<actions.length;a++) {
+							var res = Pixastic.applyAction(el, el, actions[a], null);
+							if (res) 
+								el = res;
+						}
+					} else {
+						dataImg.onload = function() {
+							for (var a=0;a<actions.length;a++) {
+								var res = Pixastic.applyAction(el, el, actions[a], null)
+								if (res) 
+									el = res;
+							}
+						}
+					}
+				} else {
+					setTimeout(function() {
+						for (var a=0;a<actions.length;a++) {
+							var res = Pixastic.applyAction(
+								el, el, actions[a], null
+							);
+							if (res) 
+								el = res;
+						}
+					},1);
+				}
+			}
+
+			})();
+		}
+	}
+
+	onready(init);
+
+
+	// getElementsByClass by Dustin Diaz, http://www.dustindiaz.com/getelementsbyclass/
+	function getElementsByClass(searchClass,node,tag) {
+	        var classElements = new Array();
+	        if ( node == null )
+	                node = document;
+	        if ( tag == null )
+	                tag = '*';
+
+	        var els = node.getElementsByTagName(tag);
+	        var elsLen = els.length;
+	        var pattern = new RegExp("(^|\\s)"+searchClass+"(\\s|$)");
+	        for (i = 0, j = 0; i < elsLen; i++) {
+	                if ( pattern.test(els[i].className) ) {
+	                        classElements[j] = els[i];
+	                        j++;
+	                }
+	        }
+	        return classElements;
+	}
+
+	var debugElement;
+
+	function writeDebug(text, level) {
+		if (!Pixastic.debug) return;
+
+		try {
+			switch (level) {
+				case "warn" : 
+					console.warn("Pixastic:", text);
+					break;
+				case "error" :
+					console.error("Pixastic:", text);
+					break;
+				default:
+					console.log("Pixastic:", text);
+			}
+		} catch(e) {
+		}
+		if (!debugElement) {
+			
+		}
+	}
+
+
+	return {
+
+		parseOnLoad : false,
+
+		debug : false,
+		
+		applyAction : function(img, dataImg, actionName, options) {
+
+			options = options || {};
+
+			var imageIsCanvas = (img.tagName == "CANVAS");
+			if (imageIsCanvas && Pixastic.Client.isIE()) {
+				if (Pixastic.debug) writeDebug("Tried to process a canvas element but browser is IE.");
+				return false;
+			}
+
+			var canvas, ctx;
+			if (Pixastic.Client.hasCanvas()) {
+				canvas = document.createElement("canvas");
+				ctx = canvas.getContext("2d");
+			}
+
+			var w = parseInt(img.offsetWidth);
+			var h = parseInt(img.offsetHeight);
+
+			if (actionName.indexOf("(") > -1) {
+				var tmp = actionName;
+				actionName = tmp.substr(0, tmp.indexOf("("));
+				var arg = tmp.match(/\((.*?)\)/);
+				if (arg[1]) {
+					arg = arg[1].split(";");
+					for (var a=0;a<arg.length;a++) {
+						thisArg = arg[a].split("=");
+						if (thisArg.length == 2) {
+							if (thisArg[0] == "rect") {
+								var rectVal = thisArg[1].split(",");
+								options[thisArg[0]] = {
+									left : parseInt(rectVal[0],10)||0,
+									top : parseInt(rectVal[1],10)||0,
+									width : parseInt(rectVal[2],10)||0,
+									height : parseInt(rectVal[3],10)||0
+								}
+							} else {
+								options[thisArg[0]] = thisArg[1];
+							}
+						}
+					}
+				}
+			}
+
+			if (!options.rect) {
+				options.rect = {
+					left : 0, top : 0, width : w, height : h
+				};
+			}
+			var validAction = false;
+			if (Pixastic.Actions[actionName] && typeof Pixastic.Actions[actionName].process == "function") {
+				validAction = true;
+			}
+			if (!validAction) {
+				if (Pixastic.debug) writeDebug("Invalid action \"" + actionName + "\". Maybe file not included?");
+				return false;
+			}
+			if (!Pixastic.Actions[actionName].checkSupport()) {
+				if (Pixastic.debug) writeDebug("Action \"" + actionName + "\" not supported by this browser.");
+				return false;
+			}
+
+			if (Pixastic.Client.hasCanvas()) {
+				canvas.width = w;
+				canvas.height = h;
+				canvas.style.width = w+"px";
+				canvas.style.height = h+"px";
+				ctx.drawImage(dataImg,0,0,w,h);
+			}
+
+			var params = {
+				image : img,
+				canvas : canvas,
+				width : w,
+				height : h,
+				useData : true,
+				options : options
+			}
+	
+			//var time = new Date().getTime();
+	
+			var res = Pixastic.Actions[actionName].process(params);
+
+			//console.log("Time:",new Date().getTime() - time,"ms");
+
+			if (!res) {
+				return false;
+			}
+
+			if (Pixastic.Client.hasCanvas()) {
+				if (params.useData) {
+					if (Pixastic.Client.hasCanvasImageData()) {
+						canvas.getContext("2d").putImageData(params.canvasData, options.rect.left, options.rect.top);
+						// Opera doesn't seem to update the canvas until we draw something on it, lets draw a 0x0 rectangle.
+						canvas.getContext("2d").fillRect(0,0,0,0);
+					}
+				}
+				// copy properties and stuff from the source image
+				canvas.title = img.title;
+				canvas.imgsrc = img.imgsrc;
+				if (!imageIsCanvas) canvas.alt  = img.alt;
+				if (!imageIsCanvas) canvas.imgsrc = img.src;
+				canvas.className = img.className;
+				canvas.setAttribute("style", img.getAttribute("style"));
+				canvas.cssText = img.cssText;
+				canvas.name = img.name;
+				canvas.tabIndex = img.tabIndex;
+				canvas.id = img.id;
+
+				if (img.parentNode && img.parentNode.replaceChild) {
+					img.parentNode.replaceChild(canvas, img);
+				}
+
+				return canvas;
+			}
+
+			return img;
+		},
+
+		prepareData : function(params, getCopy) {
+			var ctx = params.canvas.getContext("2d");
+			var rect = params.options.rect;
+			var dataDesc = ctx.getImageData(rect.left, rect.top, rect.width, rect.height);
+			var data = dataDesc.data;
+			if (!getCopy) params.canvasData = dataDesc;
+			return data;
+		},
+
+		// load the image file
+		process : function(img, actionName, options, callback)
+		{
+			if (img.tagName == "IMG") {
+				var dataImg = new Image();
+				dataImg.src = img.src;
+				if (dataImg.complete) {
+					var res = Pixastic.applyAction(img, dataImg, actionName, options);
+					if (callback) callback(res);
+					return res;
+				} else {
+					dataImg.onload = function() {
+						var res = Pixastic.applyAction(img, dataImg, actionName, options)
+						if (callback) callback(res);
+					}
+				}
+			}
+			if (img.tagName == "CANVAS") {
+				var res = Pixastic.applyAction(img, img, actionName, options);
+				if (callback) callback(res);
+				return res;
+			}
+		},
+
+		Client : {
+			hasCanvas : (function() {
+				var c = document.createElement("canvas");
+				var val = false;
+				try {
+					val = !!((typeof c.getContext == "function") && c.getContext("2d"));
+				} catch(e) {}
+				return function() {
+					return val;
+				}
+			})(),
+
+			hasCanvasImageData : (function() {
+				var c = document.createElement("canvas");
+				var val = false;
+				var ctx;
+				try {
+					if (typeof c.getContext == "function" && (ctx = c.getContext("2d"))) {
+						val = (typeof ctx.getImageData == "function");
+					}
+				} catch(e) {}
+				return function() {
+					return val;
+				}
+			})(),
+
+			isIE : function() {
+				return !!document.all && !!window.attachEvent && !window.opera;
+			}
+		},
+
+		Actions : {}
+	}
+
+
+})();
diff --git a/pixastic.jquery.js b/pixastic.jquery.js
new file mode 100755
index 0000000..cf8f507
--- /dev/null
+++ b/pixastic.jquery.js
@@ -0,0 +1,22 @@
+
+if (typeof jQuery != "undefined" && jQuery && jQuery.fn) {
+	jQuery.fn.pixastic = function(action, options) {
+		var newElements = [];
+		this.each(
+			function () {
+				if (this.tagName == "IMG" && !this.complete) {
+					return;
+				}
+				var res = Pixastic.process(this, action, options);
+				if (res) {
+					newElements.push(res);
+				}
+			}
+		);
+		if (newElements.length > 0)
+			return jQuery(newElements);
+		else
+			return this;
+	};
+
+};