diff --git a/context.cc b/context.cc
index 83fa424c..59c263a1 100644
--- a/context.cc
+++ b/context.cc
@@ -90,7 +90,7 @@ Value Context::evaluate_function(QString name, const QVector<QString> &argnames,
 	return Value();
 }
 
-AbstractNode *Context::evaluate_module(const ModuleInstanciation *inst) const
+AbstractNode *Context::evaluate_module(const ModuleInstantiation *inst) const
 {
 	if (modules_p && modules_p->contains(inst->modname))
 		return modules_p->value(inst->modname)->evaluate(this, inst);
diff --git a/control.cc b/control.cc
index 6cae8eb6..c898dfc9 100644
--- a/control.cc
+++ b/control.cc
@@ -36,10 +36,10 @@ class ControlModule : public AbstractModule
 public:
 	control_type_e type;
 	ControlModule(control_type_e type) : type(type) { }
-	virtual AbstractNode *evaluate(const Context *ctx, const ModuleInstanciation *inst) const;
+	virtual AbstractNode *evaluate(const Context *ctx, const ModuleInstantiation *inst) const;
 };
 
-void for_eval(AbstractNode *node, int l, const QVector<QString> &call_argnames, const QVector<Value> &call_argvalues, const QVector<ModuleInstanciation*> arg_children, const Context *arg_context)
+void for_eval(AbstractNode *node, int l, const QVector<QString> &call_argnames, const QVector<Value> &call_argvalues, const QVector<ModuleInstantiation*> arg_children, const Context *arg_context)
 {
 	if (call_argnames.size() > l) {
 		QString it_name = call_argnames[l];
@@ -71,7 +71,7 @@ void for_eval(AbstractNode *node, int l, const QVector<QString> &call_argnames,
 			for_eval(node, l+1, call_argnames, call_argvalues, arg_children, &c);
 		}
 	} else {
-		foreach (ModuleInstanciation *v, arg_children) {
+		foreach (ModuleInstantiation *v, arg_children) {
 			AbstractNode *n = v->evaluate(arg_context);
 			if (n != NULL)
 				node->children.append(n);
@@ -79,7 +79,7 @@ void for_eval(AbstractNode *node, int l, const QVector<QString> &call_argnames,
 	}
 }
 
-AbstractNode *ControlModule::evaluate(const Context*, const ModuleInstanciation *inst) const
+AbstractNode *ControlModule::evaluate(const Context*, const ModuleInstantiation *inst) const
 {
 	AbstractNode *node;
 
@@ -108,7 +108,7 @@ AbstractNode *ControlModule::evaluate(const Context*, const ModuleInstanciation
 			if (!inst->argnames[i].isEmpty())
 				c.set_variable(inst->argnames[i], inst->argvalues[i]);
 		}
-		foreach (ModuleInstanciation *v, inst->children) {
+		foreach (ModuleInstantiation *v, inst->children) {
 			AbstractNode *n = v->evaluate(&c);
 			if (n != NULL)
 				node->children.append(n);
@@ -123,7 +123,7 @@ AbstractNode *ControlModule::evaluate(const Context*, const ModuleInstanciation
 	if (type == IF)
 	{
 		if (inst->argvalues.size() > 0 && inst->argvalues[0].type == Value::BOOL && inst->argvalues[0].b)
-			foreach (ModuleInstanciation *v, inst->children) {
+			foreach (ModuleInstantiation *v, inst->children) {
 				AbstractNode *n = v->evaluate(inst->ctx);
 				if (n != NULL)
 					node->children.append(n);
diff --git a/csgops.cc b/csgops.cc
index f4e945d4..5e55ed1d 100644
--- a/csgops.cc
+++ b/csgops.cc
@@ -34,14 +34,14 @@ class CsgModule : public AbstractModule
 public:
 	csg_type_e type;
 	CsgModule(csg_type_e type) : type(type) { }
-	virtual AbstractNode *evaluate(const Context *ctx, const ModuleInstanciation *inst) const;
+	virtual AbstractNode *evaluate(const Context *ctx, const ModuleInstantiation *inst) const;
 };
 
 class CsgNode : public AbstractNode
 {
 public:
 	csg_type_e type;
-	CsgNode(const ModuleInstanciation *mi, csg_type_e type) : AbstractNode(mi), type(type) { }
+	CsgNode(const ModuleInstantiation *mi, csg_type_e type) : AbstractNode(mi), type(type) { }
 #ifdef ENABLE_CGAL
 	virtual CGAL_Nef_polyhedron render_cgal_nef_polyhedron() const;
 #endif
@@ -49,10 +49,10 @@ public:
 	virtual QString dump(QString indent) const;
 };
 
-AbstractNode *CsgModule::evaluate(const Context*, const ModuleInstanciation *inst) const
+AbstractNode *CsgModule::evaluate(const Context*, const ModuleInstantiation *inst) const
 {
 	CsgNode *node = new CsgNode(inst, type);
-	foreach (ModuleInstanciation *v, inst->children) {
+	foreach (ModuleInstantiation *v, inst->children) {
 		AbstractNode *n = v->evaluate(inst->ctx);
 		if (n != NULL)
 			node->children.append(n);
diff --git a/dxflinextrude.cc b/dxflinextrude.cc
index 1e8bb2e6..28ea0047 100644
--- a/dxflinextrude.cc
+++ b/dxflinextrude.cc
@@ -31,7 +31,7 @@ class DxfLinearExtrudeModule : public AbstractModule
 {
 public:
 	DxfLinearExtrudeModule() { }
-	virtual AbstractNode *evaluate(const Context *ctx, const ModuleInstanciation *inst) const;
+	virtual AbstractNode *evaluate(const Context *ctx, const ModuleInstantiation *inst) const;
 };
 
 class DxfLinearExtrudeNode : public AbstractPolyNode
@@ -42,7 +42,7 @@ public:
 	double origin_x, origin_y, scale;
 	bool center, has_twist;
 	QString filename, layername;
-	DxfLinearExtrudeNode(const ModuleInstanciation *mi) : AbstractPolyNode(mi) {
+	DxfLinearExtrudeNode(const ModuleInstantiation *mi) : AbstractPolyNode(mi) {
 		convexity = slices = 0;
 		fn = fs = fa = height = twist = 0;
 		origin_x = origin_y = scale = 0;
@@ -52,7 +52,7 @@ public:
 	virtual QString dump(QString indent) const;
 };
 
-AbstractNode *DxfLinearExtrudeModule::evaluate(const Context *ctx, const ModuleInstanciation *inst) const
+AbstractNode *DxfLinearExtrudeModule::evaluate(const Context *ctx, const ModuleInstantiation *inst) const
 {
 	DxfLinearExtrudeNode *node = new DxfLinearExtrudeNode(inst);
 
@@ -107,7 +107,7 @@ AbstractNode *DxfLinearExtrudeModule::evaluate(const Context *ctx, const ModuleI
 	}
 
 	if (node->filename.isEmpty()) {
-		foreach (ModuleInstanciation *v, inst->children) {
+		foreach (ModuleInstantiation *v, inst->children) {
 			AbstractNode *n = v->evaluate(inst->ctx);
 			if (n)
 				node->children.append(n);
diff --git a/dxfrotextrude.cc b/dxfrotextrude.cc
index 9855b91f..27f2f060 100644
--- a/dxfrotextrude.cc
+++ b/dxfrotextrude.cc
@@ -31,7 +31,7 @@ class DxfRotateExtrudeModule : public AbstractModule
 {
 public:
 	DxfRotateExtrudeModule() { }
-	virtual AbstractNode *evaluate(const Context *ctx, const ModuleInstanciation *inst) const;
+	virtual AbstractNode *evaluate(const Context *ctx, const ModuleInstantiation *inst) const;
 };
 
 class DxfRotateExtrudeNode : public AbstractPolyNode
@@ -41,7 +41,7 @@ public:
 	double fn, fs, fa;
 	double origin_x, origin_y, scale;
 	QString filename, layername;
-	DxfRotateExtrudeNode(const ModuleInstanciation *mi) : AbstractPolyNode(mi) {
+	DxfRotateExtrudeNode(const ModuleInstantiation *mi) : AbstractPolyNode(mi) {
 		convexity = 0;
 		fn = fs = fa = 0;
 		origin_x = origin_y = scale = 0;
@@ -50,7 +50,7 @@ public:
 	virtual QString dump(QString indent) const;
 };
 
-AbstractNode *DxfRotateExtrudeModule::evaluate(const Context *ctx, const ModuleInstanciation *inst) const
+AbstractNode *DxfRotateExtrudeModule::evaluate(const Context *ctx, const ModuleInstantiation *inst) const
 {
 	DxfRotateExtrudeNode *node = new DxfRotateExtrudeNode(inst);
 
diff --git a/dxftess.cc b/dxftess.cc
index 00a2f0e7..a2c3c31a 100644
--- a/dxftess.cc
+++ b/dxftess.cc
@@ -123,6 +123,44 @@ static void STDCALL tess_error(GLenum errno)
 	PRINTF("GLU tesselation error %d!", errno);
 }
 
+static void STDCALL tess_begin_data()
+{
+	PRINTF("GLU tesselation BEGIN_DATA\n");
+}
+
+static void STDCALL tess_edge_flag(GLboolean flag)
+{
+//	PRINTF("GLU tesselation EDGE_FLAG\n");
+}
+
+static void STDCALL tess_edge_flag_data(GLboolean flag, void *polygon_data)
+{
+	PRINTF("GLU tesselation EDGE_FLAG_DATA\n");
+}
+static void STDCALL tess_vertex_data(void *vertex_data, void *polygon_data)
+{
+	PRINTF("GLU tesselation VERTEX_DATA\n");
+}
+static void STDCALL tess_end_data(void *polygon_data)
+{
+	PRINTF("GLU tesselation END_DATA\n");
+}
+static void STDCALL tess_combine(GLdouble coords[3], void *vertex_data[4],
+                               GLfloat weight[4], void **outData )
+{
+	PRINTF("GLU tesselation COMBINE\n");
+}
+static void STDCALL tess_combine_data(GLdouble coords[3], void *vertex_data[4],
+                                    GLfloat weight[4], void **outData,
+                                    void *polygon_data)
+{
+	PRINTF("GLU tesselation COMBINE_DATA\n");
+}
+static void STDCALL tess_error_data(GLenum errno, void *polygon_data )
+{
+	PRINTF("GLU tesselation ERROR_DATA\n");
+}
+
 static bool point_on_line(double *p1, double *p2, double *p3)
 {
 	if (fabs(p1[0] - p2[0]) < 0.00001 && fabs(p1[1] - p2[1]) < 0.00001)
@@ -170,6 +208,17 @@ void dxf_tesselate(PolySet *ps, DxfData *dxf, double rot, bool up, bool do_trian
 	gluTessCallback(tobj, GLU_TESS_END, (void(STDCALL *)())&tess_end);
 	gluTessCallback(tobj, GLU_TESS_ERROR, (void(STDCALL *)())&tess_error);
 
+	gluTessCallback(tobj, GLU_TESS_EDGE_FLAG, (void(STDCALL *)())&tess_edge_flag);
+	gluTessCallback(tobj, GLU_TESS_COMBINE, (void(STDCALL *)())&tess_combine);
+
+/* 	gluTessCallback(tobj, GLU_TESS_BEGIN_DATA, (void(STDCALL *)())&tess_begin_data); */
+/* 	gluTessCallback(tobj, GLU_TESS_EDGE_FLAG_DATA, (void(STDCALL *)())&tess_edge_flag_data); */
+/* 	gluTessCallback(tobj, GLU_TESS_VERTEX_DATA, (void(STDCALL *)())&tess_vertex_data); */
+/* 	gluTessCallback(tobj, GLU_TESS_END_DATA, (void(STDCALL *)())&tess_end_data); */
+/* 	gluTessCallback(tobj, GLU_TESS_COMBINE_DATA, (void(STDCALL *)())&tess_combine_data); */
+/* 	gluTessCallback(tobj, GLU_TESS_ERROR_DATA, (void(STDCALL *)())&tess_error_data); */
+
+
 	tess_tri.clear();
 	QList<tess_vdata> vl;
 
@@ -204,7 +253,7 @@ void dxf_tesselate(PolySet *ps, DxfData *dxf, double rot, bool up, bool do_trian
 	gluTessEndPolygon(tobj);
 	gluDeleteTess(tobj);
 
-#if 0
+#if 1
 	for (int i = 0; i < tess_tri.count(); i++) {
 		printf("~~~\n");
 		printf("  %f %f %f\n", tess_tri[i].p[0][0], tess_tri[i].p[0][1], tess_tri[i].p[0][2]);
@@ -219,6 +268,7 @@ void dxf_tesselate(PolySet *ps, DxfData *dxf, double rot, bool up, bool do_trian
 		if (point_on_line(tess_tri[i].p[0], tess_tri[i].p[1], tess_tri[i].p[2]) ||
 				point_on_line(tess_tri[i].p[1], tess_tri[i].p[2], tess_tri[i].p[0]) ||
 				point_on_line(tess_tri[i].p[2], tess_tri[i].p[0], tess_tri[i].p[1])) {
+			printf("DEBUG: Removed triangle\n");
 			tess_tri.remove(i--);
 		}
 	}
diff --git a/import.cc b/import.cc
index 3bdad66a..c4dd6899 100644
--- a/import.cc
+++ b/import.cc
@@ -38,7 +38,7 @@ class ImportModule : public AbstractModule
 public:
 	import_type_e type;
 	ImportModule(import_type_e type) : type(type) { }
-	virtual AbstractNode *evaluate(const Context *ctx, const ModuleInstanciation *inst) const;
+	virtual AbstractNode *evaluate(const Context *ctx, const ModuleInstantiation *inst) const;
 };
 
 class ImportNode : public AbstractPolyNode
@@ -50,12 +50,12 @@ public:
 	int convexity;
 	double fn, fs, fa;
 	double origin_x, origin_y, scale;
-	ImportNode(const ModuleInstanciation *mi, import_type_e type) : AbstractPolyNode(mi), type(type) { }
+	ImportNode(const ModuleInstantiation *mi, import_type_e type) : AbstractPolyNode(mi), type(type) { }
 	virtual PolySet *render_polyset(render_mode_e mode) const;
 	virtual QString dump(QString indent) const;
 };
 
-AbstractNode *ImportModule::evaluate(const Context *ctx, const ModuleInstanciation *inst) const
+AbstractNode *ImportModule::evaluate(const Context *ctx, const ModuleInstantiation *inst) const
 {
 	ImportNode *node = new ImportNode(inst, type);
 
diff --git a/mainwin.cc b/mainwin.cc
index c34cce96..cb733a8c 100644
--- a/mainwin.cc
+++ b/mainwin.cc
@@ -519,7 +519,7 @@ void MainWindow::compile(bool procevents)
 
 	AbstractNode::idx_counter = 1;
 	{
-		ModuleInstanciation root_inst;
+		ModuleInstantiation root_inst;
 		absolute_root_node = root_module->evaluate(&root_ctx, &root_inst);
 	}
 
diff --git a/module.cc b/module.cc
index 84db4a47..b02ce782 100644
--- a/module.cc
+++ b/module.cc
@@ -27,11 +27,11 @@ AbstractModule::~AbstractModule()
 {
 }
 
-AbstractNode *AbstractModule::evaluate(const Context*, const ModuleInstanciation *inst) const
+AbstractNode *AbstractModule::evaluate(const Context*, const ModuleInstantiation *inst) const
 {
 	AbstractNode *node = new AbstractNode(inst);
 
-	foreach (ModuleInstanciation *v, inst->children) {
+	foreach (ModuleInstantiation *v, inst->children) {
 		AbstractNode *n = v->evaluate(inst->ctx);
 		if (n)
 			node->children.append(n);
@@ -45,15 +45,15 @@ QString AbstractModule::dump(QString indent, QString name) const
 	return QString("%1abstract module %2();\n").arg(indent, name);
 }
 
-ModuleInstanciation::~ModuleInstanciation()
+ModuleInstantiation::~ModuleInstantiation()
 {
 	foreach (Expression *v, argexpr)
 		delete v;
-	foreach (ModuleInstanciation *v, children)
+	foreach (ModuleInstantiation *v, children)
 		delete v;
 }
 
-QString ModuleInstanciation::dump(QString indent) const
+QString ModuleInstantiation::dump(QString indent) const
 {
 	QString text = indent;
 	if (!label.isEmpty())
@@ -81,13 +81,13 @@ QString ModuleInstanciation::dump(QString indent) const
 	return text;
 }
 
-AbstractNode *ModuleInstanciation::evaluate(const Context *ctx) const
+AbstractNode *ModuleInstantiation::evaluate(const Context *ctx) const
 {
 	AbstractNode *node = NULL;
 	if (this->ctx) {
 		PRINTA("WARNING: Ignoring recursive module instanciation of '%1'.", modname);
 	} else {
-		ModuleInstanciation *that = (ModuleInstanciation*)this;
+		ModuleInstantiation *that = (ModuleInstantiation*)this;
 		that->argvalues.clear();
 		foreach (Expression *v, that->argexpr) {
 			that->argvalues.append(v->evaluate(ctx));
@@ -108,11 +108,11 @@ Module::~Module()
 		delete v;
 	foreach (AbstractModule *v, modules)
 		delete v;
-	foreach (ModuleInstanciation *v, children)
+	foreach (ModuleInstantiation *v, children)
 		delete v;
 }
 
-AbstractNode *Module::evaluate(const Context *ctx, const ModuleInstanciation *inst) const
+AbstractNode *Module::evaluate(const Context *ctx, const ModuleInstantiation *inst) const
 {
 	Context c(ctx);
 	c.args(argnames, argexpr, inst->argnames, inst->argvalues);
@@ -131,7 +131,7 @@ AbstractNode *Module::evaluate(const Context *ctx, const ModuleInstanciation *in
 			node->children.append(n);
 	}
 
-	foreach(ModuleInstanciation *v, inst->children) {
+	foreach(ModuleInstantiation *v, inst->children) {
 		AbstractNode *n = v->evaluate(inst->ctx);
 		if (n != NULL)
 			node->children.append(n);
@@ -207,7 +207,7 @@ void destroy_builtin_modules()
 
 int AbstractNode::idx_counter;
 
-AbstractNode::AbstractNode(const ModuleInstanciation *mi)
+AbstractNode::AbstractNode(const ModuleInstantiation *mi)
 {
 	modinst = mi;
 	idx = idx_counter++;
diff --git a/openscad.cc b/openscad.cc
index edc94b47..20243896 100644
--- a/openscad.cc
+++ b/openscad.cc
@@ -163,7 +163,7 @@ int main(int argc, char **argv)
 		root_ctx.set_variable("$vpr", zero3);
 
 		AbstractModule *root_module;
-		ModuleInstanciation root_inst;
+		ModuleInstantiation root_inst;
 		AbstractNode *root_node;
 
 		handle_dep(filename);
diff --git a/openscad.h b/openscad.h
index e93b5db3..25624dc0 100644
--- a/openscad.h
+++ b/openscad.h
@@ -58,7 +58,7 @@ class BuiltinFunction;
 class Function;
 
 class AbstractModule;
-class ModuleInstanciation;
+class ModuleInstantiation;
 class Module;
 
 class Context;
@@ -327,11 +327,11 @@ class AbstractModule
 {
 public:
 	virtual ~AbstractModule();
-	virtual AbstractNode *evaluate(const Context *ctx, const ModuleInstanciation *inst) const;
+	virtual AbstractNode *evaluate(const Context *ctx, const ModuleInstantiation *inst) const;
 	virtual QString dump(QString indent, QString name) const;
 };
 
-class ModuleInstanciation
+class ModuleInstantiation
 {
 public:
 	QString label;
@@ -339,15 +339,15 @@ public:
 	QVector<QString> argnames;
 	QVector<Expression*> argexpr;
 	QVector<Value> argvalues;
-	QVector<ModuleInstanciation*> children;
+	QVector<ModuleInstantiation*> children;
 
 	bool tag_root;
 	bool tag_highlight;
 	bool tag_background;
 	const Context *ctx;
 
-	ModuleInstanciation() : tag_root(false), tag_highlight(false), tag_background(false), ctx(NULL) { }
-	~ModuleInstanciation();
+	ModuleInstantiation() : tag_root(false), tag_highlight(false), tag_background(false), ctx(NULL) { }
+	~ModuleInstantiation();
 
 	QString dump(QString indent) const;
 	AbstractNode *evaluate(const Context *ctx) const;
@@ -365,12 +365,12 @@ public:
 	QHash<QString, AbstractFunction*> functions;
 	QHash<QString, AbstractModule*> modules;
 
-	QVector<ModuleInstanciation*> children;
+	QVector<ModuleInstantiation*> children;
 
 	Module() { }
 	virtual ~Module();
 
-	virtual AbstractNode *evaluate(const Context *ctx, const ModuleInstanciation *inst) const;
+	virtual AbstractNode *evaluate(const Context *ctx, const ModuleInstantiation *inst) const;
 	virtual QString dump(QString indent, QString name) const;
 };
 
@@ -408,7 +408,7 @@ public:
 	Value lookup_variable(QString name, bool silent = false) const;
 
 	Value evaluate_function(QString name, const QVector<QString> &argnames, const QVector<Value> &argvalues) const;
-	AbstractNode *evaluate_module(const ModuleInstanciation *inst) const;
+	AbstractNode *evaluate_module(const ModuleInstantiation *inst) const;
 };
 
 class DxfData
@@ -627,7 +627,7 @@ class AbstractNode
 {
 public:
 	QVector<AbstractNode*> children;
-	const ModuleInstanciation *modinst;
+	const ModuleInstantiation *modinst;
 
 	int progress_mark;
 	void progress_prepare();
@@ -637,7 +637,7 @@ public:
 	static int idx_counter;
 	QString dump_cache;
 
-	AbstractNode(const ModuleInstanciation *mi);
+	AbstractNode(const ModuleInstantiation *mi);
 	virtual ~AbstractNode();
 	virtual QString mk_cache_id() const;
 #ifdef ENABLE_CGAL
@@ -656,7 +656,7 @@ public:
 class AbstractIntersectionNode : public AbstractNode
 {
 public:
-	AbstractIntersectionNode(const ModuleInstanciation *mi) : AbstractNode(mi) { };
+	AbstractIntersectionNode(const ModuleInstantiation *mi) : AbstractNode(mi) { };
 #ifdef ENABLE_CGAL
 	virtual CGAL_Nef_polyhedron render_cgal_nef_polyhedron() const;
 #endif
@@ -671,13 +671,13 @@ public:
 		RENDER_CGAL,
 		RENDER_OPENCSG
 	};
-	AbstractPolyNode(const ModuleInstanciation *mi) : AbstractNode(mi) { };
+	AbstractPolyNode(const ModuleInstantiation *mi) : AbstractNode(mi) { };
 	virtual PolySet *render_polyset(render_mode_e mode) const;
 #ifdef ENABLE_CGAL
 	virtual CGAL_Nef_polyhedron render_cgal_nef_polyhedron() const;
 #endif
 	virtual CSGTerm *render_csg_term(double m[16], QVector<CSGTerm*> *highlights, QVector<CSGTerm*> *background) const;
-	static CSGTerm *render_csg_term_from_ps(double m[16], QVector<CSGTerm*> *highlights, QVector<CSGTerm*> *background, PolySet *ps, const ModuleInstanciation *modinst, int idx);
+	static CSGTerm *render_csg_term_from_ps(double m[16], QVector<CSGTerm*> *highlights, QVector<CSGTerm*> *background, PolySet *ps, const ModuleInstantiation *modinst, int idx);
 };
 
 extern int progress_report_count;
diff --git a/parser.y b/parser.y
index 61a672a1..f1c103c2 100644
--- a/parser.y
+++ b/parser.y
@@ -53,7 +53,7 @@ public:
 	double number;
 	class Value *value;
 	class Expression *expr;
-	class ModuleInstanciation *inst;
+	class ModuleInstantiation *inst;
 	class ArgContainer *arg;
 	class ArgsContainer *args;
 }
@@ -84,9 +84,9 @@ public:
 %type <expr> expr
 %type <expr> vector_expr
 
-%type <inst> module_instantciation
-%type <inst> module_instantciation_list
-%type <inst> single_module_instantciation
+%type <inst> module_instantiation
+%type <inst> module_instantiation_list
+%type <inst> single_module_instantiation
 
 %type <args> arguments_call
 %type <args> arguments_decl
@@ -105,7 +105,7 @@ input:
 statement:
 	';' |
 	'{' input '}' |
-	module_instantciation {
+	module_instantiation {
 		if ($1) {
 			module->children.append($1);
 		} else {
@@ -150,11 +150,11 @@ statement:
 		delete $4;
 	} ';' ;
 
-module_instantciation:
-	single_module_instantciation ';' {
+module_instantiation:
+	single_module_instantiation ';' {
 		$$ = $1;
 	} |
-	single_module_instantciation '{' module_instantciation_list '}' {
+	single_module_instantiation '{' module_instantiation_list '}' {
 		$$ = $1;
 		if ($$) {
 			$$->children = $3->children;
@@ -165,7 +165,7 @@ module_instantciation:
 		$3->children.clear();
 		delete $3;
 	} |
-	single_module_instantciation module_instantciation {
+	single_module_instantiation module_instantiation {
 		$$ = $1;
 		if ($$) {
 			if ($2)
@@ -175,11 +175,11 @@ module_instantciation:
 		}
 	} ;
 
-module_instantciation_list:
+module_instantiation_list:
 	/* empty */ {
-		$$ = new ModuleInstanciation();
+		$$ = new ModuleInstantiation();
 	} |
-	module_instantciation_list module_instantciation {
+	module_instantiation_list module_instantiation {
 		$$ = $1;
 		if ($$) {
 			if ($2)
@@ -189,37 +189,37 @@ module_instantciation_list:
 		}
 	} ;
 
-single_module_instantciation:
+single_module_instantiation:
 	TOK_ID '(' arguments_call ')' {
-		$$ = new ModuleInstanciation();
+		$$ = new ModuleInstantiation();
 		$$->modname = QString($1);
 		$$->argnames = $3->argnames;
 		$$->argexpr = $3->argexpr;
 		free($1);
 		delete $3;
 	} |
-	TOK_ID ':' single_module_instantciation {
+	TOK_ID ':' single_module_instantiation {
 		$$ = $3;
 		if ($$)
 			$$->label = QString($1);
 		free($1);
 	} |
-	'!' single_module_instantciation {
+	'!' single_module_instantiation {
 		$$ = $2;
 		if ($$)
 			$$->tag_root = true;
 	} |
-	'#' single_module_instantciation {
+	'#' single_module_instantiation {
 		$$ = $2;
 		if ($$)
 			$$->tag_highlight = true;
 	} |
-	'%' single_module_instantciation {
+	'%' single_module_instantiation {
 		$$ = $2;
 		if ($$)
 			$$->tag_background = true;
 	} |
-	'*' single_module_instantciation {
+	'*' single_module_instantiation {
 		delete $2;
 		$$ = NULL;
 	};
diff --git a/polyset.cc b/polyset.cc
index d11f958a..ab8e4041 100644
--- a/polyset.cc
+++ b/polyset.cc
@@ -454,7 +454,7 @@ CSGTerm *AbstractPolyNode::render_csg_term(double m[16], QVector<CSGTerm*> *high
 	return render_csg_term_from_ps(m, highlights, background, ps, modinst, idx);
 }
 
-CSGTerm *AbstractPolyNode::render_csg_term_from_ps(double m[16], QVector<CSGTerm*> *highlights, QVector<CSGTerm*> *background, PolySet *ps, const ModuleInstanciation *modinst, int idx)
+CSGTerm *AbstractPolyNode::render_csg_term_from_ps(double m[16], QVector<CSGTerm*> *highlights, QVector<CSGTerm*> *background, PolySet *ps, const ModuleInstantiation *modinst, int idx)
 {
 	CSGTerm *t = new CSGTerm(ps, m, QString("n%1").arg(idx));
 	if (modinst->tag_highlight && highlights)
diff --git a/primitives.cc b/primitives.cc
index 90a22baa..8e9df2db 100644
--- a/primitives.cc
+++ b/primitives.cc
@@ -36,7 +36,7 @@ class PrimitiveModule : public AbstractModule
 public:
 	primitive_type_e type;
 	PrimitiveModule(primitive_type_e type) : type(type) { }
-	virtual AbstractNode *evaluate(const Context *ctx, const ModuleInstanciation *inst) const;
+	virtual AbstractNode *evaluate(const Context *ctx, const ModuleInstantiation *inst) const;
 };
 
 class PrimitiveNode : public AbstractPolyNode
@@ -47,12 +47,12 @@ public:
 	double fn, fs, fa;
 	primitive_type_e type;
 	Value points, triangles;
-	PrimitiveNode(const ModuleInstanciation *mi, primitive_type_e type) : AbstractPolyNode(mi), type(type) { }
+	PrimitiveNode(const ModuleInstantiation *mi, primitive_type_e type) : AbstractPolyNode(mi), type(type) { }
 	virtual PolySet *render_polyset(render_mode_e mode) const;
 	virtual QString dump(QString indent) const;
 };
 
-AbstractNode *PrimitiveModule::evaluate(const Context *ctx, const ModuleInstanciation *inst) const
+AbstractNode *PrimitiveModule::evaluate(const Context *ctx, const ModuleInstantiation *inst) const
 {
 	PrimitiveNode *node = new PrimitiveNode(inst, type);
 
diff --git a/render.cc b/render.cc
index 190bce55..1fe2e802 100644
--- a/render.cc
+++ b/render.cc
@@ -31,14 +31,14 @@ class RenderModule : public AbstractModule
 {
 public:
 	RenderModule() { }
-	virtual AbstractNode *evaluate(const Context *ctx, const ModuleInstanciation *inst) const;
+	virtual AbstractNode *evaluate(const Context *ctx, const ModuleInstantiation *inst) const;
 };
 
 class RenderNode : public AbstractNode
 {
 public:
 	int convexity;
-	RenderNode(const ModuleInstanciation *mi) : AbstractNode(mi), convexity(1) { }
+	RenderNode(const ModuleInstantiation *mi) : AbstractNode(mi), convexity(1) { }
 #ifdef ENABLE_CGAL
 	virtual CGAL_Nef_polyhedron render_cgal_nef_polyhedron() const;
 #endif
@@ -46,7 +46,7 @@ public:
 	virtual QString dump(QString indent) const;
 };
 
-AbstractNode *RenderModule::evaluate(const Context *ctx, const ModuleInstanciation *inst) const
+AbstractNode *RenderModule::evaluate(const Context *ctx, const ModuleInstantiation *inst) const
 {
 	RenderNode *node = new RenderNode(inst);
 
@@ -60,7 +60,7 @@ AbstractNode *RenderModule::evaluate(const Context *ctx, const ModuleInstanciati
 	if (v.type == Value::NUMBER)
 		node->convexity = (int)v.num;
 
-	foreach (ModuleInstanciation *v, inst->children) {
+	foreach (ModuleInstantiation *v, inst->children) {
 		AbstractNode *n = v->evaluate(inst->ctx);
 		if (n != NULL)
 			node->children.append(n);
diff --git a/surface.cc b/surface.cc
index ebf720f2..4dc3d985 100644
--- a/surface.cc
+++ b/surface.cc
@@ -29,7 +29,7 @@ class SurfaceModule : public AbstractModule
 {
 public:
 	SurfaceModule() { }
-	virtual AbstractNode *evaluate(const Context *ctx, const ModuleInstanciation *inst) const;
+	virtual AbstractNode *evaluate(const Context *ctx, const ModuleInstantiation *inst) const;
 };
 
 class SurfaceNode : public AbstractPolyNode
@@ -38,12 +38,12 @@ public:
 	QString filename;
 	bool center;
 	int convexity;
-	SurfaceNode(const ModuleInstanciation *mi) : AbstractPolyNode(mi) { }
+	SurfaceNode(const ModuleInstantiation *mi) : AbstractPolyNode(mi) { }
 	virtual PolySet *render_polyset(render_mode_e mode) const;
 	virtual QString dump(QString indent) const;
 };
 
-AbstractNode *SurfaceModule::evaluate(const Context *ctx, const ModuleInstanciation *inst) const
+AbstractNode *SurfaceModule::evaluate(const Context *ctx, const ModuleInstantiation *inst) const
 {
 	SurfaceNode *node = new SurfaceNode(inst);
 	node->center = false;
diff --git a/transform.cc b/transform.cc
index f06e8417..5e86bde0 100644
--- a/transform.cc
+++ b/transform.cc
@@ -35,14 +35,14 @@ class TransformModule : public AbstractModule
 public:
 	transform_type_e type;
 	TransformModule(transform_type_e type) : type(type) { }
-	virtual AbstractNode *evaluate(const Context *ctx, const ModuleInstanciation *inst) const;
+	virtual AbstractNode *evaluate(const Context *ctx, const ModuleInstantiation *inst) const;
 };
 
 class TransformNode : public AbstractNode
 {
 public:
 	double m[16];
-	TransformNode(const ModuleInstanciation *mi) : AbstractNode(mi) { }
+	TransformNode(const ModuleInstantiation *mi) : AbstractNode(mi) { }
 #ifdef ENABLE_CGAL
 	virtual CGAL_Nef_polyhedron render_cgal_nef_polyhedron() const;
 #endif
@@ -50,7 +50,7 @@ public:
 	virtual QString dump(QString indent) const;
 };
 
-AbstractNode *TransformModule::evaluate(const Context *ctx, const ModuleInstanciation *inst) const
+AbstractNode *TransformModule::evaluate(const Context *ctx, const ModuleInstantiation *inst) const
 {
 	TransformNode *node = new TransformNode(inst);
 
@@ -174,7 +174,7 @@ AbstractNode *TransformModule::evaluate(const Context *ctx, const ModuleInstanci
 		}
 	}
 
-	foreach (ModuleInstanciation *v, inst->children) {
+	foreach (ModuleInstantiation *v, inst->children) {
 		AbstractNode *n = v->evaluate(inst->ctx);
 		if (n != NULL)
 			node->children.append(n);