diff --git a/src/dxf/Entity.h b/src/dxf/Entity.h
index 9bf56bda..34e6c0d3 100644
--- a/src/dxf/Entity.h
+++ b/src/dxf/Entity.h
@@ -40,7 +40,7 @@ namespace DXF {
     virtual ~Entity() {}
 
     virtual type_t getType() const = 0;
-    virtual void addVertex(const cb::Vector3D &v) {THROW("Cannot add vertex");}
+    virtual void addVertex(const cb::Vector3D &v, double weight = 0.0) {THROW("Cannot add vertex");}
     virtual void addKnot(double k) {THROW("Cannot add knot");}
   };
 }
diff --git a/src/dxf/PolyLine.h b/src/dxf/PolyLine.h
index 53659f6d..efcb450d 100644
--- a/src/dxf/PolyLine.h
+++ b/src/dxf/PolyLine.h
@@ -28,15 +28,27 @@
 
 namespace DXF {
   class PolyLine : public Entity {
+    /* Polyline flag (bit-coded; default = 0):
+     * 1 = This is a closed polyline (or a polygon mesh closed in the M direction)
+     * 2 = Curve-fit vertices have been added
+     * 4 = Spline-fit vertices have been added
+     * 8 = This is a 3D polyline
+     * 16 = This is a 3D polygon mesh
+     * 32 = The polygon mesh is closed in the N direction
+		 * 64 = The polyline is a polyface mesh
+		 * 128 = The linetype pattern is generated continuously around the vertices of this polyline
+		 */
+    unsigned flags;
     std::vector<cb::Vector3D> vertices;
 
   public:
-    PolyLine() {}
+    PolyLine(unsigned flags) : flags(flags) {}
 
     const std::vector<cb::Vector3D> &getVertices() const {return vertices;}
 
     // From Entity
-    void addVertex(const cb::Vector3D &v) {vertices.push_back(v);}
+    void addVertex(const cb::Vector3D &v, double weight = 0.0) {vertices.push_back(v);}
+    unsigned getFlags() const {return flags;}
     type_t getType() const {return DXF_POLYLINE;}
   };
 }
diff --git a/src/dxf/Reader.cpp b/src/dxf/Reader.cpp
index 7fd03916..471a9ee2 100644
--- a/src/dxf/Reader.cpp
+++ b/src/dxf/Reader.cpp
@@ -85,7 +85,7 @@ void Reader::addCircle(const DL_CircleData &circle) {
 
 void Reader::addPolyline(const DL_PolylineData &polyline) {
   if (!entity.isNull()) THROW("DXF Already in DXF entity");
-  addEntity(entity = new PolyLine);
+  addEntity(entity = new PolyLine(polyline.flags));
 }
 
 
@@ -97,12 +97,12 @@ void Reader::addVertex(const DL_VertexData &vertex) {
 
 void Reader::addSpline(const DL_SplineData &spline) {
   if (!entity.isNull()) THROW("DXF Already in DXF entity");
-  addEntity(entity = new Spline(spline.degree));
+  addEntity(entity = new Spline(spline.degree, spline.flags));
 }
 
 
 void Reader::addControlPoint(const DL_ControlPointData &ctrlPt) {
-  entity->addVertex(cb::Vector3D(ctrlPt.x, ctrlPt.y, ctrlPt.z));
+  entity->addVertex(cb::Vector3D(ctrlPt.x, ctrlPt.y, ctrlPt.z), ctrlPt.w);
 }
 
 
diff --git a/src/dxf/Spline.h b/src/dxf/Spline.h
index 5eb80d7c..e749ab7d 100644
--- a/src/dxf/Spline.h
+++ b/src/dxf/Spline.h
@@ -28,19 +28,30 @@
 namespace DXF {
   class Spline : public Entity {
     unsigned degree;
+    /* Spline flag (bit coded):
+     * 1 = Closed spline
+     * 2 = Periodic spline
+     * 4 = Rational spline
+     * 8 = Planar
+     * 16 = Linear (planar bit is also set)
+     */
+    unsigned flags;
     std::vector<cb::Vector3D> ctrlPts;
+    std::vector<double> weights;
     std::vector<double> knots;
 
   public:
-    Spline(unsigned degree) : degree(degree) {}
+    Spline(unsigned degree, unsigned flags) : degree(degree), flags(flags) {}
 
     unsigned getDegree() const {return degree;}
+    unsigned getFlags() const {return flags;}
     const std::vector<cb::Vector3D> &getControlPoints() const {return ctrlPts;}
+    const std::vector<double> &getWeights() const {return weights;}
     const std::vector<double> &getKnots() const {return knots;}
 
     // From Entity
     void addKnot(double k) {knots.push_back(k);}
-    void addVertex(const cb::Vector3D &v) {ctrlPts.push_back(v);}
+    void addVertex(const cb::Vector3D &v, double weight = 1.0) {ctrlPts.push_back(v); weights.push_back(weight);}
     type_t getType() const {return DXF_SPLINE;}
   };
 }
diff --git a/src/tplang/DXFModule.cpp b/src/tplang/DXFModule.cpp
index da59d15a..52ef5b4a 100644
--- a/src/tplang/DXFModule.cpp
+++ b/src/tplang/DXFModule.cpp
@@ -110,6 +110,8 @@ void DXFModule::openCB(const js::Value &args, js::Sink &sink) {
       case DXF::Entity::DXF_POLYLINE: {
         const DXF::PolyLine &polyLine =
           dynamic_cast<const DXF::PolyLine &>(entity);
+				/* TODO: expose other flags. */
+				sink.insertBoolean("isClosed", (polyLine.getFlags()&(1<<0))!=0 );
         const vector<Vector3D> &vertices = polyLine.getVertices();
         sink.insertList("vertices");
 
@@ -130,9 +132,15 @@ void DXFModule::openCB(const js::Value &args, js::Sink &sink) {
         const DXF::Spline &spline = dynamic_cast<const DXF::Spline &>(entity);
 
         sink.insert("degree", spline.getDegree());
+        sink.insertBoolean("isClosed",     (spline.getFlags()&(1<<0))!=0 );
+        sink.insertBoolean("isPeriodical", (spline.getFlags()&(1<<1))!=0 );
+        sink.insertBoolean("isRational",   (spline.getFlags()&(1<<2))!=0 );
+        sink.insertBoolean("isPlanar",     (spline.getFlags()&(1<<3))!=0 );
+        sink.insertBoolean("isLinear",     (spline.getFlags()&(1<<4))!=0 );
 
         // Control points
         const vector<Vector3D> &ctrlPts = spline.getControlPoints();
+        const std::vector<double> &weights = spline.getWeights();
         sink.insertList("ctrlPts");
 
         for (unsigned k = 0; k < ctrlPts.size(); k++) {
@@ -140,6 +148,7 @@ void DXFModule::openCB(const js::Value &args, js::Sink &sink) {
           sink.insert("x", ctrlPts[k].x());
           sink.insert("y", ctrlPts[k].y());
           sink.insert("z", ctrlPts[k].z());
+          sink.insert("w", weights[k]);
           sink.insert("type", DXF::Entity::DXF_POINT);
           sink.endDict();
         }
diff --git a/tpl_lib/dxf/dxf.tpl b/tpl_lib/dxf/dxf.tpl
index 7bc8125c..e8480d1f 100644
--- a/tpl_lib/dxf/dxf.tpl
+++ b/tpl_lib/dxf/dxf.tpl
@@ -68,7 +68,7 @@ function dtoa(n, width) {
 
 
 function str(x) {
-  return (typeof x == 'string') ? x : JSON.stringify(x);
+  return (typeof x == 'string') ? x : JSON.stringify(x, null, '  ');
 }
 
 
@@ -149,50 +149,161 @@ function bounds_center(bounds) {
 }
 
 
-function quad_bezier(p, t) {
-  var c = [sqr(1 - t), 2 * (1 - t) * t, sqr(t)];
+function get_segment_index(knots, t, degree, is_closed) {
+  // find the spline segment for the t value provided
 
-  return {
-    x: c[0] * p[0].x + c[1] * p[1].x + c[2] * p[2].x,
-    y: c[0] * p[0].y + c[1] * p[1].y + c[2] * p[2].y
+  /* TODO: can this be unified? */
+  if(is_closed) {
+    for(var segment = 0; segment<knots.length; segment++) {
+      if(knots[segment]>t) return segment-1;
+    }
+  } else {
+    for(var segment = degree; segment<knots.length; segment++) {
+      if(t >= knots[segment] && t <= knots[segment+1]) {
+        return segment;
+      }
+    }
   }
+
+  throw new Error('segment not found');
 }
 
 
-function quad_bezier_length(p) {
-  var l = 0;
-  var v = p[0];
+function nurbs_build_verts(spl) {
+  var degree = spl.degree;
+  var npts = spl.ctrlPts.length;
 
-  for (var i = 1; i <= 100; i++) {
-    var u = quad_bezier(p, 0.01 * i);
-    l += distance2D(v, u);
-    v = u;
+  if(degree < 1) throw new Error('degree must be at least 1 (linear)');
+  if(degree > (npts-1)) throw new Error('degree must be less than or equal to point count - 1');
+
+  // convert spl.ctrlPts to homogeneous coordinates
+  var verts = [];
+  if(spl.isClosed) {
+    for(var i=0; i<npts+degree*2; i++) {
+      verts[i] = [];
+      var j = (npts + i - degree) % npts;
+      verts[i][3] = spl.isRational ? spl.ctrlPts[j].w : 1.0;
+      verts[i][0] = spl.ctrlPts[j].x * verts[i][3];
+      verts[i][1] = spl.ctrlPts[j].y * verts[i][3];
+      verts[i][2] = spl.ctrlPts[j].z * verts[i][3];
+    }
+    npts = npts+degree*2;
+  } else {
+    for(var i=0; i<npts; i++) {
+      verts[i] = [];
+      verts[i][3] = spl.isRational ? spl.ctrlPts[i].w : 1.0;
+      verts[i][0] = spl.ctrlPts[i].x * verts[i][3];
+      verts[i][1] = spl.ctrlPts[i].y * verts[i][3];
+      verts[i][2] = spl.ctrlPts[i].z * verts[i][3];
+    }
   }
 
-  return l;
+  return verts;
 }
 
 
-function cubic_bezier(p, t) {
-  var c = [cube(1 - t), 3 * sqr(1 - t) * t, 3 * (1 - t) * sqr(t), cube(t)];
+function nurbs_build_knots(spl) {
+  var degree = spl.degree;
+  var npts = spl.ctrlPts.length;
+  var knots = [];
+  if(spl.isClosed) {
+      /* TODO: is it right to rewrite the knots values? */
+      npts = npts+degree*2;
+      var delta = 1.0/(npts+degree+1);
+      var knot = 0.0;
+      for(var i=0; i<npts+degree; i++) {
+        knots.push(knot);
+        knot+=delta;
+      }
+      knots.push(1.0);
+  } else {
+    if(!knots) {
+      // build knot vector of length [npts + degree + 1]
+      for(var i=0; i<npts+degree+1; i++) {
+        knots.push(i);
+      }
+    } else {
+      for(var i=0; i<spl.knots.length; i++) {
+        knots.push(spl.knots[i]);
+      }
+      if(knots.length !== npts+degree+1) {
+        throw new Error('bad knot vector length');
+      }
+    }
+  }
 
-  return {
-    x: c[0] * p[0].x + c[1] * p[1].x + c[2] * p[2].x + c[3] * p[3].x,
-    y: c[0] * p[0].y + c[1] * p[1].y + c[2] * p[2].y + c[3] * p[3].y
+  return knots;
+}
+
+
+function nurbs_interpolate(t, spl, vertices, knots) {
+
+  var degree = spl.degree;
+  var npts = spl.ctrlPts.length;
+  if(spl.isClosed) {
+    npts = npts+degree*2;
+  }
+
+  if(t < knots[0] || t > knots[knots.length-1]) {
+    throw new Error('t out of bounds');
   }
+
+  if(spl.isClosed) {
+    var min = knots[degree+1];
+    var max = knots[knots.length-degree-1];
+    t = min + (max-min) * t;
+  } else {
+    var min = knots[degree];
+    var max = knots[knots.length-degree];
+    t = min + (max-min) * t;
+  }
+
+  var segment = get_segment_index(knots, t, degree, spl.isClosed);
+
+	/* Only deep copy the vertices that we are going to modify */
+  var verts = [];
+	for(var j=segment; j>segment-degree-1; j--) {
+		var i = (npts+j)%npts;
+		verts[i] = [];
+		verts[i][0] = vertices[i][0];
+		verts[i][1] = vertices[i][1];
+		verts[i][2] = vertices[i][2];
+		verts[i][3] = vertices[i][3];
+	}
+
+  for(var level=1; level<=degree+1; level++) {
+    // build level of the pyramid
+    for(var i=segment; i>segment-degree-1+level; i--) {
+			var klen = knots.length;
+      var vai_1 = knots[(i+klen)%klen];
+      var vaip_r = knots[(i+degree+1-level+klen)%klen];
+      var alpha = (t - vai_1) / (vaip_r - vai_1);
+
+      // interpolate each component
+      var components = 4; // x, y, z, w
+      for(var j=0; j<components; j++) {
+        verts[(npts+i)%npts][j] = (1 - alpha) * verts[(i-1+npts)%npts][j] + alpha * verts[(npts+i)%npts][j];
+      }
+    }
+  }
+
+  return {
+    x: verts[segment%npts][0] / verts[segment%npts][3],
+    y: verts[segment%npts][1] / verts[segment%npts][3],
+    z: verts[segment%npts][2] / verts[segment%npts][3]
+  } 
 }
 
 
-function cubic_bezier_length(p) {
+function nurbs_length(spl, verts, knots) {
   var l = 0;
-  var v = p[0];
+  var v = nurbs_interpolate(0.0, spl, verts, knots);
 
   for (var i = 1; i <= 100; i++) {
-    var u = cubic_bezier(p, 0.01 * i);
+    var u = nurbs_interpolate(0.01*i, spl, verts, knots);
     l += distance2D(v, u);
     v = u;
   }
-
   return l;
 }
 
@@ -308,17 +419,28 @@ module.exports = extend({
   polyline_flip: function(pl) {
     return {
       type: _dxf.POLYLINE,
+      isClosed: pl.isClosed,
       vertices: [].concat(pl.vertices).reverse()
     }
   },
 
 
   spline_flip: function(s) {
+		ik = [];
+		for(var i=0; i<s.knots.length; i++) {
+			ik[i] = 1.0 - s.knots[i];
+		}
+
     return {
       type: _dxf.SPLINE,
       degree: s.degree,
+      isClosed: s.isClosed,
+      isPeriodical: s.isPeriodical,
+      isRational: s.isRational,
+      isPlanar: s.isPlanar,
+      isLinear: s.isLinear,
       ctrlPts: [].concat(s.ctrlPts).reverse(),
-      knots: s.knots
+      knots: [].concat(ik).reverse()
     }
   },
 
@@ -359,7 +481,19 @@ module.exports = extend({
   },
 
 
-  line_cut: function(l) {cut(l.end.x, l.end.y);},
+  point_cut: function(p, zCut) {
+    var v = first(this.element_vertices(p));
+    cut({z: zCut});
+    cut(v.x, v.y);
+  },
+
+
+  line_cut: function(l, zCut) {
+    var v = first(this.element_vertices(l));
+    cut({z: zCut});
+    cut(v.x, v.y);
+    cut(l.end.x, l.end.y);
+  },
 
 
   arc_angle: function(a) {
@@ -371,7 +505,11 @@ module.exports = extend({
   },
 
 
-  arc_cut: function(a) {
+  arc_cut: function(a, zCut) {
+    var v = first(this.element_vertices(a));
+    cut({z: zCut});
+    cut(v.x, v.y);
+
     var p = position();
 
     var offset = {
@@ -383,49 +521,53 @@ module.exports = extend({
   },
 
 
-  polyline_cut: function(pl) {
+  polyline_cut: function(pl, zCut) {
+    var v = first(this.element_vertices(pl));
+    cut({z: zCut});
+    cut(v.x, v.y);
+
     for (var i = 1; i < pl.vertices.length; i++)
       cut(pl.vertices[i].x, pl.vertices[i].y);
 
-    if (pl.vertices.length) cut(pl.vertices[0].x, pl.vertices[0].y);
+    if (pl.isClosed) cut(pl.vertices[0].x, pl.vertices[0].y);
   },
 
 
-  spline_cut: function(s, res) {
-    if (typeof res == 'undefined') res = units() == METRIC ? 1 : 1 / 25.4;
-
-    if (s.degree == 2) {
-      var steps = Math.ceil(quad_bezier_length(s.ctrlPts) / res);
-      var delta = 1 / steps;
+  spline_cut: function(s, zCut, res) {
+    var verts = nurbs_build_verts(s);
+    var knots = nurbs_build_knots(s);
 
-      for (var i = 0; i < steps; i++) {
-        v = quad_bezier(s.ctrlPts, delta * (i + 1));
-        cut(v.x, v.y);
-      }
+    if (typeof res == 'undefined') res = units() == METRIC ? 1 : 1 / 25.4;
+    var steps = Math.ceil(nurbs_length(s, verts, knots) / res);
+    var delta = 1.0 / steps;
 
+    // Move to the exact beginning of the spline and start cutting
+    var v = nurbs_interpolate(0.0, s, verts, knots);
+    rapid (v.x, v.y);
+    cut({z: zCut});
 
-    } else if (s.degree == 3) {
-      var steps = Math.ceil(cubic_bezier_length(s.ctrlPts) / res);
-      var delta = 1 / steps;
+    var t = delta;
 
-      for (var i = 0; i < steps; i++) {
-        var v = cubic_bezier(s.ctrlPts, delta * (i + 1));
-        cut(v.x, v.y);
-      }
+    // Cut the spline at delta increments
+    while(t<1.0) {
+      v = nurbs_interpolate(t, s, verts, knots);
+      cut(v.x, v.y);
+      t += delta;
+    }
 
-    } else
-      for (var i = 1; i < s.ctrlPts.length; i++)
-        cut(s.ctrlPts[i].x, s.ctrlPts[i].y);
+    // Make sure to cut until exactly t=1.0
+    v = nurbs_interpolate(1.0, s, verts, knots);
+    cut(v.x, v.y);
   },
 
 
-  element_cut: function(e, res) {
+  element_cut: function(e, zCut, res) {
     switch (e.type) {
-    case _dxf.POINT:    return;
-    case _dxf.LINE:     return this.line_cut(e);
-    case _dxf.ARC:      return this.arc_cut(e);
-    case _dxf.POLYLINE: return this.polyline_cut(e);
-    case _dxf.SPLINE:   return this.spline_cut(e, res);
+    case _dxf.POINT:    return this.point_cut(e, zCut);
+    case _dxf.LINE:     return this.line_cut(e, zCut);
+    case _dxf.ARC:      return this.arc_cut(e, zCut);
+    case _dxf.POLYLINE: return this.polyline_cut(e, zCut);
+    case _dxf.SPLINE:   return this.spline_cut(e, zCut, res);
     default: throw 'Unsupported DXF element type ' + e.type;
     }
   },
@@ -450,10 +592,7 @@ module.exports = extend({
         rapid(v.x, v.y);
       }
 
-      cut({z: zCut});
-      cut(v.x, v.y);
-
-      this.element_cut(e, res);
+      this.element_cut(e, zCut, res);
 
       layer.splice(match.i, 1);
     }