diff --git a/export.cpp b/export.cpp
index 8a872b3..38b8d09 100644
--- a/export.cpp
+++ b/export.cpp
@@ -107,7 +107,7 @@ void SolveSpace::ExportSectionTo(char *filename) {
     bl.Clear();
 }
 
-void SolveSpace::ExportViewTo(char *filename) {
+void SolveSpace::ExportViewOrWireframeTo(char *filename, bool wireframe) {
     int i;
     SEdgeList edges;
     ZERO(&edges);
@@ -158,21 +158,42 @@ void SolveSpace::ExportViewTo(char *filename) {
         }
     }
 
-    Vector u = SS.GW.projRight,
-           v = SS.GW.projUp,
-           n = u.Cross(v),
-           origin = SS.GW.offset.ScaledBy(-1);
+    if(wireframe) {
+        VectorFileWriter *out = VectorFileWriter::ForFile(filename);
+        if(out) {
+            ExportWireframeCurves(&edges, &beziers, out);
+        }
+    } else {
+        Vector u = SS.GW.projRight,
+               v = SS.GW.projUp,
+               n = u.Cross(v),
+               origin = SS.GW.offset.ScaledBy(-1);
 
-    VectorFileWriter *out = VectorFileWriter::ForFile(filename);
-    if(out) {
-        ExportLinesAndMesh(&edges, &beziers, sm,
-                           u, v, n, origin, SS.CameraTangent()*SS.GW.scale,
-                           out);
+        VectorFileWriter *out = VectorFileWriter::ForFile(filename);
+        if(out) {
+            ExportLinesAndMesh(&edges, &beziers, sm,
+                               u, v, n, origin, SS.CameraTangent()*SS.GW.scale,
+                               out);
+        }
     }
+
     edges.Clear();
     beziers.Clear();
 }
 
+
+void SolveSpace::ExportWireframeCurves(SEdgeList *sel, SBezierList *sbl,
+                           VectorFileWriter *out)
+{
+    sbl->ScaleSelfBy(1.0/SS.exportScale);
+    SEdge *se;
+    for(se = sel->l.First(); se; se = sel->l.NextAfter(se)) {
+        se->a = (se->a).ScaledBy(1.0/SS.exportScale);
+        se->b = (se->b).ScaledBy(1.0/SS.exportScale);
+    }
+    out->Output(sel, sbl, NULL);
+}
+
 void SolveSpace::ExportLinesAndMesh(SEdgeList *sel, SBezierList *sbl, SMesh *sm,
                                     Vector u, Vector v, Vector n,
                                         Vector origin, double cameraTan,
@@ -465,7 +486,7 @@ void VectorFileWriter::Output(SEdgeList *sel, SBezierList *sbl, SMesh *sm) {
 
             DWORD rgb = Style::Color  (e->auxA, true);
             double w  = Style::WidthMm(e->auxA)*s;
-            LineSegment(rgb, w, e->a.x, e->a.y, e->b.x, e->b.y);
+            LineSegment(rgb, w, e->a, e->b);
         }
     }
     if(sbl) {
@@ -483,11 +504,10 @@ void VectorFileWriter::Output(SEdgeList *sel, SBezierList *sbl, SMesh *sm) {
 void VectorFileWriter::BezierAsPwl(DWORD rgb, double width, SBezier *sb) {
     List<Vector> lv;
     ZERO(&lv);
-    sb->MakePwlInto(&lv);
+    sb->MakePwlInto(&lv, SS.ChordTolMm() / SS.exportScale);
     int i;
     for(i = 1; i < lv.n; i++) {
-        LineSegment(rgb, width, lv.elem[i-1].x, lv.elem[i-1].y,
-                                lv.elem[i  ].x, lv.elem[i  ].y);
+        LineSegment(rgb, width, lv.elem[i-1], lv.elem[i]);
     }
     lv.Clear();
 }
diff --git a/exportvector.cpp b/exportvector.cpp
index fe6632c..bcb3f7f 100644
--- a/exportvector.cpp
+++ b/exportvector.cpp
@@ -62,9 +62,7 @@ void DxfFileWriter::StartFile(void) {
 "ENTITIES\r\n");
 }
 
-void DxfFileWriter::LineSegment(DWORD rgb, double w,
-                                    double x0, double y0, double x1, double y1)
-{
+void DxfFileWriter::LineSegment(DWORD rgb, double w, Vector ptA, Vector ptB) {
     fprintf(f,
 "  0\r\n"
 "LINE\r\n"
@@ -83,8 +81,8 @@ void DxfFileWriter::LineSegment(DWORD rgb, double w,
 "  31\r\n"    // zB
 "%.6f\r\n",
                     0,
-                    x0, y0, 0.0,
-                    x1, y1, 0.0);
+                    ptA.x, ptA.y, ptA.z,
+                    ptB.x, ptB.y, ptB.z);
 }
 
 void DxfFileWriter::Triangle(STriangle *tr) {
@@ -93,7 +91,7 @@ void DxfFileWriter::Triangle(STriangle *tr) {
 void DxfFileWriter::Bezier(DWORD rgb, double w, SBezier *sb) {
     Vector c, n = Vector::From(0, 0, 1);
     double r;
-    if(sb->IsCircle(n, &c, &r)) {
+    if(sb->IsInPlane(n, 0) && sb->IsCircle(n, &c, &r)) {
         double theta0 = atan2(sb->ctrl[0].y - c.y, sb->ctrl[0].x - c.x),
                theta1 = atan2(sb->ctrl[2].y - c.y, sb->ctrl[2].x - c.x),
                dtheta = WRAP_SYMMETRIC(theta1 - theta0, 2*PI);
@@ -169,17 +167,15 @@ void EpsFileWriter::StartFile(void) {
             MmToPts(ptMax.y - ptMin.y));
 }
 
-void EpsFileWriter::LineSegment(DWORD rgb, double w,
-                                    double x0, double y0, double x1, double y1)
-{
+void EpsFileWriter::LineSegment(DWORD rgb, double w, Vector ptA, Vector ptB) {
     fprintf(f,
 "newpath\r\n"
 "    %.3f %.3f moveto\r\n"
 "    %.3f %.3f lineto\r\n"
 "%s"
 "stroke\r\n",
-            MmToPts(x0 - ptMin.x), MmToPts(y0 - ptMin.y),
-            MmToPts(x1 - ptMin.x), MmToPts(y1 - ptMin.y),
+            MmToPts(ptA.x - ptMin.x), MmToPts(ptA.y - ptMin.y),
+            MmToPts(ptB.x - ptMin.x), MmToPts(ptB.y - ptMin.y),
             StyleString(rgb, w));
 }
 
@@ -396,17 +392,15 @@ void PdfFileWriter::FinishAndCloseFile(void) {
 
 }
 
-void PdfFileWriter::LineSegment(DWORD rgb, double w,
-                                    double x0, double y0, double x1, double y1)
-{
+void PdfFileWriter::LineSegment(DWORD rgb, double w, Vector ptA, Vector ptB) {
     fprintf(f,
 "%s"
 "%.3f %.3f m\r\n"
 "%.3f %.3f l\r\n"
 "S\r\n",
             StyleString(rgb, w),
-            MmToPts(x0 - ptMin.x), MmToPts(y0 - ptMin.y),
-            MmToPts(x1 - ptMin.x), MmToPts(y1 - ptMin.y));
+            MmToPts(ptA.x - ptMin.x), MmToPts(ptA.y - ptMin.y),
+            MmToPts(ptB.x - ptMin.x), MmToPts(ptB.y - ptMin.y));
 }
 
 void PdfFileWriter::Triangle(STriangle *tr) {
@@ -473,14 +467,12 @@ void SvgFileWriter::StartFile(void) {
     // A little bit of extra space for the stroke width.
 }
 
-void SvgFileWriter::LineSegment(DWORD rgb, double w,
-                            double x0, double y0, double x1, double y1)
-{
+void SvgFileWriter::LineSegment(DWORD rgb, double w, Vector ptA, Vector ptB) {
     // SVG uses a coordinate system with the origin at top left, +y down
     fprintf(f,
 "<polyline points='%.3f,%.3f %.3f,%.3f' %s />\r\n",
-            (x0 - ptMin.x), (ptMax.y - y0),
-            (x1 - ptMin.x), (ptMax.y - y1),
+            (ptA.x - ptMin.x), (ptMax.y - ptA.y),
+            (ptB.x - ptMin.x), (ptMax.y - ptB.y),
             StyleString(rgb, w));
 }
 
@@ -525,8 +517,7 @@ void SvgFileWriter::Bezier(DWORD rgb, double w, SBezier *sb) {
                 StyleString(rgb, w));
     } else if(!sb->IsRational()) {
         if(sb->deg == 1) {
-            LineSegment(rgb, w, sb->ctrl[0].x, sb->ctrl[0].y,
-                                sb->ctrl[1].x, sb->ctrl[1].y);
+            LineSegment(rgb, w, sb->ctrl[0], sb->ctrl[1]);
         } else if(sb->deg == 2) {
             fprintf(f,
 "<path d='M%.3f,%.3f "
@@ -567,11 +558,13 @@ void HpglFileWriter::StartFile(void) {
     fprintf(f, "SP1;\r\n");
 }
 
-void HpglFileWriter::LineSegment(DWORD rgb, double w,
-                        double x0, double y0, double x1, double y1)
-{
-    fprintf(f, "PU%d,%d;\r\n", (int)MmToHpglUnits(x0), (int)MmToHpglUnits(y0));
-    fprintf(f, "PD%d,%d;\r\n", (int)MmToHpglUnits(x1), (int)MmToHpglUnits(y1));
+void HpglFileWriter::LineSegment(DWORD rgb, double w, Vector ptA, Vector ptB) {
+    fprintf(f, "PU%d,%d;\r\n",
+        (int)MmToHpglUnits(ptA.x),
+        (int)MmToHpglUnits(ptA.y));
+    fprintf(f, "PD%d,%d;\r\n",
+        (int)MmToHpglUnits(ptB.x),
+        (int)MmToHpglUnits(ptB.y));
 }
 
 void HpglFileWriter::Triangle(STriangle *tr) {
@@ -598,11 +591,9 @@ void Step2dFileWriter::StartFile(void) {
 void Step2dFileWriter::Triangle(STriangle *tr) {
 }
 
-void Step2dFileWriter::LineSegment(DWORD rgb, double w,
-                        double x0, double y0, double x1, double y1)
+void Step2dFileWriter::LineSegment(DWORD rgb, double w, Vector ptA, Vector ptB)
 {
-    SBezier sb = SBezier::From(Vector::From(x0, y0, 0),
-                               Vector::From(x1, y1, 0));
+    SBezier sb = SBezier::From(ptA, ptB);
     Bezier(rgb, w, &sb);
 }
 
diff --git a/solvespace.cpp b/solvespace.cpp
index dfc91d0..0cfbdcc 100644
--- a/solvespace.cpp
+++ b/solvespace.cpp
@@ -415,7 +415,14 @@ void SolveSpace::MenuFile(int id) {
         case GraphicsWindow::MNU_EXPORT_VIEW: {
             char exportFile[MAX_PATH] = "";
             if(!GetSaveFile(exportFile, VEC_EXT, VEC_PATTERN)) break;
-            SS.ExportViewTo(exportFile); 
+            SS.ExportViewOrWireframeTo(exportFile, false); 
+            break;
+        }
+
+        case GraphicsWindow::MNU_EXPORT_WIREFRAME: {
+            char exportFile[MAX_PATH] = "";
+            if(!GetSaveFile(exportFile, V3D_EXT, V3D_PATTERN)) break;
+            SS.ExportViewOrWireframeTo(exportFile, true); 
             break;
         }
 
diff --git a/solvespace.h b/solvespace.h
index 52900a0..ceadee5 100644
--- a/solvespace.h
+++ b/solvespace.h
@@ -75,15 +75,20 @@ extern char RecentFile[MAX_RECENT][MAX_PATH];
 void RefreshRecentMenus(void);
 
 int SaveFileYesNoCancel(void);
+// SolveSpace native file format
 #define SLVS_PATTERN "SolveSpace Models (*.slvs)\0*.slvs\0All Files (*)\0*\0\0"
 #define SLVS_EXT "slvs"
+// PNG format bitmap
 #define PNG_PATTERN "PNG (*.png)\0*.png\0All Files (*)\0*\0\0"
 #define PNG_EXT "png"
+// Triangle mesh
 #define STL_PATTERN "STL Mesh (*.stl)\0*.stl\0All Files (*)\0*\0\0"
 #define STL_EXT "stl"
+// NURBS surfaces
 #define SRF_PATTERN "STEP File (*.step;*.stp)\0*.step;*.stp\0" \
                     "All Files(*)\0*\0\0"
 #define SRF_EXT "step"
+// 2d vector (lines and curves) format
 #define VEC_PATTERN "PDF File (*.pdf)\0*.pdf\0" \
                     "Encapsulated PostScript (*.eps;*.ps)\0*.eps;*.ps\0" \
                     "Scalable Vector Graphics (*.svg)\0*.svg\0" \
@@ -92,8 +97,15 @@ int SaveFileYesNoCancel(void);
                     "HPGL File (*.plt;*.hpgl)\0*.plt;*.hpgl\0" \
                     "All Files (*)\0*\0\0"
 #define VEC_EXT "pdf"
+// 3d vector (wireframe lines and curves) format
+#define V3D_PATTERN "STEP File (*.step;*.stp)\0*.step;*.stp\0" \
+                    "DXF File (*.dxf)\0*.dxf\0" \
+                    "All Files (*)\0*\0\0"
+#define V3D_EXT "step"
+// Comma-separated value, like a spreadsheet would use
 #define CSV_PATTERN "CSV File (*.csv)\0*.csv\0All Files (*)\0*\0\0"
 #define CSV_EXT "csv"
+// Native license file
 #define LICENSE_PATTERN \
     "License File (*.license)\0*.license\0All Files (*)\0*\0\0"
 #define LICENSE_EXT "license"
@@ -393,9 +405,6 @@ public:
     FILE *f;
     Vector ptMin, ptMax;
 
-    double width;
-    double r, g, b;
-    
     static double MmToPts(double mm);
     static bool StringEndsIn(char *str, char *ending);
 
@@ -408,16 +417,15 @@ public:
                                     SBezier *sb, int depth=0);
 
     virtual void Bezier(DWORD rgb, double width, SBezier *sb) = 0;
-    virtual void LineSegment(DWORD rgb, double width,
-                                double x0, double y0, double x1, double y1) = 0;
+    virtual void LineSegment(DWORD rgb, double width, Vector ptA, Vector ptB)
+                                                                            = 0;
     virtual void Triangle(STriangle *tr) = 0;
     virtual void StartFile(void) = 0;
     virtual void FinishAndCloseFile(void) = 0;
 };
 class DxfFileWriter : public VectorFileWriter {
 public:
-    void LineSegment(DWORD rgb, double width, 
-                        double x0, double y0, double x1, double y1);
+    void LineSegment(DWORD rgb, double width, Vector ptA, Vector ptB);
     void Triangle(STriangle *tr);
     void Bezier(DWORD rgb, double width, SBezier *sb);
     void StartFile(void);
@@ -426,8 +434,7 @@ public:
 class EpsFileWriter : public VectorFileWriter {
 public:
     static char *StyleString(DWORD rgb, double width);
-    void LineSegment(DWORD rgb, double width, 
-                        double x0, double y0, double x1, double y1);
+    void LineSegment(DWORD rgb, double width, Vector ptA, Vector ptB);
     void Triangle(STriangle *tr);
     void Bezier(DWORD rgb, double width, SBezier *sb);
     void StartFile(void);
@@ -439,8 +446,7 @@ public:
     DWORD bodyStart;
 
     static char *StyleString(DWORD rgb, double width);
-    void LineSegment(DWORD rgb, double width, 
-                        double x0, double y0, double x1, double y1);
+    void LineSegment(DWORD rgb, double width, Vector ptA, Vector ptB);
     void Triangle(STriangle *tr);
     void Bezier(DWORD rgb, double width, SBezier *sb);
     void StartFile(void);
@@ -449,8 +455,7 @@ public:
 class SvgFileWriter : public VectorFileWriter {
 public:
     static char *StyleString(DWORD rgb, double width);
-    void LineSegment(DWORD rgb, double width, 
-                        double x0, double y0, double x1, double y1);
+    void LineSegment(DWORD rgb, double width, Vector ptA, Vector ptB);
     void Triangle(STriangle *tr);
     void Bezier(DWORD rgb, double width, SBezier *sb);
     void StartFile(void);
@@ -459,8 +464,7 @@ public:
 class HpglFileWriter : public VectorFileWriter {
 public:
     static double MmToHpglUnits(double mm);
-    void LineSegment(DWORD rgb, double width, 
-                        double x0, double y0, double x1, double y1);
+    void LineSegment(DWORD rgb, double width, Vector ptA, Vector ptB);
     void Triangle(STriangle *tr);
     void Bezier(DWORD rgb, double width, SBezier *sb);
     void StartFile(void);
@@ -468,8 +472,7 @@ public:
 };
 class Step2dFileWriter : public VectorFileWriter {
     StepFileWriter sfw;
-    void LineSegment(DWORD rgb, double width, 
-                        double x0, double y0, double x1, double y1);
+    void LineSegment(DWORD rgb, double width, Vector ptA, Vector ptB);
     void Triangle(STriangle *tr);
     void Bezier(DWORD rgb, double width, SBezier *sb);
     void StartFile(void);
@@ -626,8 +629,10 @@ public:
     // And the various export options
     void ExportAsPngTo(char *file);
     void ExportMeshTo(char *file);
-    void ExportViewTo(char *file);
+    void ExportViewOrWireframeTo(char *file, bool wireframe);
     void ExportSectionTo(char *file);
+    void ExportWireframeCurves(SEdgeList *sel, SBezierList *sbl,
+                               VectorFileWriter *out);
     void ExportLinesAndMesh(SEdgeList *sel, SBezierList *sbl, SMesh *sm,
                             Vector u, Vector v, Vector n, Vector origin,
                                 double cameraTan,
diff --git a/srf/curve.cpp b/srf/curve.cpp
index 1b58128..b64a699 100644
--- a/srf/curve.cpp
+++ b/srf/curve.cpp
@@ -105,6 +105,20 @@ SBezier SBezier::TransformedBy(Vector t, Quaternion q, bool mirror) {
     return ret;
 }
 
+//-----------------------------------------------------------------------------
+// Does this curve lie entirely within the specified plane? It does if all
+// the control points lie in that plane.
+//-----------------------------------------------------------------------------
+bool SBezier::IsInPlane(Vector n, double d) {
+    int i;
+    for(i = 0; i <= deg; i++) {
+        if(fabs((ctrl[i]).Dot(n) - d) > LENGTH_EPS) {
+            return false;
+        }
+    }
+    return true;
+}
+
 //-----------------------------------------------------------------------------
 // Is this Bezier exactly the arc of a circle, projected along the specified
 // axis? If yes, return that circle's center and radius.
diff --git a/srf/ratpoly.cpp b/srf/ratpoly.cpp
index a7a32d7..5d117cd 100644
--- a/srf/ratpoly.cpp
+++ b/srf/ratpoly.cpp
@@ -226,20 +226,20 @@ void SBezier::SplitAt(double t, SBezier *bef, SBezier *aft) {
     }
 }
 
-void SBezier::MakePwlInto(SEdgeList *sel) {
+void SBezier::MakePwlInto(SEdgeList *sel, double chordTol) {
     List<Vector> lv;
     ZERO(&lv);
-    MakePwlInto(&lv);
+    MakePwlInto(&lv, chordTol);
     int i;
     for(i = 1; i < lv.n; i++) {
         sel->AddEdge(lv.elem[i-1], lv.elem[i]);
     }
     lv.Clear();
 }
-void SBezier::MakePwlInto(List<SCurvePt> *l) {
+void SBezier::MakePwlInto(List<SCurvePt> *l, double chordTol) {
     List<Vector> lv;
     ZERO(&lv);
-    MakePwlInto(&lv);
+    MakePwlInto(&lv, chordTol);
     int i;
     for(i = 0; i < lv.n; i++) {
         SCurvePt scpt;
@@ -250,11 +250,17 @@ void SBezier::MakePwlInto(List<SCurvePt> *l) {
     }
     lv.Clear();
 }
-void SBezier::MakePwlInto(List<Vector> *l) {
+void SBezier::MakePwlInto(List<Vector> *l, double chordTol) {
+    if(chordTol == 0) {
+        // Use the default chord tolerance.
+        chordTol = SS.ChordTolMm();
+    }
     l->Add(&(ctrl[0]));
-    MakePwlWorker(l, 0.0, 1.0);
+    MakePwlWorker(l, 0.0, 1.0, chordTol);
 }
-void SBezier::MakePwlWorker(List<Vector> *l, double ta, double tb) {
+void SBezier::MakePwlWorker(List<Vector> *l, double ta, double tb,
+                                double chordTol)
+{
     Vector pa = PointAt(ta);
     Vector pb = PointAt(tb);
 
@@ -269,13 +275,13 @@ void SBezier::MakePwlWorker(List<Vector> *l, double ta, double tb) {
                    pm2.DistanceToLine(pa, pb.Minus(pa)));
 
     double step = 1.0/SS.maxSegments;
-    if((tb - ta) < step || d < SS.ChordTolMm()) {
+    if((tb - ta) < step || d < chordTol) {
         // A previous call has already added the beginning of our interval.
         l->Add(&pb);
     } else {
         double tm = (ta + tb) / 2;
-        MakePwlWorker(l, ta, tm);
-        MakePwlWorker(l, tm, tb);
+        MakePwlWorker(l, ta, tm, chordTol);
+        MakePwlWorker(l, tm, tb, chordTol);
     }
 }
 
diff --git a/srf/surface.h b/srf/surface.h
index a0cabad..df3c841 100644
--- a/srf/surface.h
+++ b/srf/surface.h
@@ -77,15 +77,16 @@ public:
     Vector Start(void);
     Vector Finish(void);
     bool Equals(SBezier *b);
-    void MakePwlInto(SEdgeList *sel);
-    void MakePwlInto(List<SCurvePt> *l);
-    void MakePwlInto(List<Vector> *l);
-    void MakePwlWorker(List<Vector> *l, double ta, double tb);
+    void MakePwlInto(SEdgeList *sel, double chordTol=0);
+    void MakePwlInto(List<SCurvePt> *l, double chordTol=0);
+    void MakePwlInto(List<Vector> *l, double chordTol=0);
+    void MakePwlWorker(List<Vector> *l, double ta, double tb, double chordTol);
 
     void AllIntersectionsWith(SBezier *sbb, SPointList *spl);
     void GetBoundingProjd(Vector u, Vector orig, double *umin, double *umax);
     void Reverse(void);
 
+    bool IsInPlane(Vector n, double d);
     bool IsCircle(Vector axis, Vector *center, double *r);
     bool IsRational(void);
 
diff --git a/wishlist.txt b/wishlist.txt
index 0a30abd..04cca80 100644
--- a/wishlist.txt
+++ b/wishlist.txt
@@ -1,7 +1,6 @@
 
 multi-drag
 copy and paste
-wireframe export
 interpolating splines
 associative entities from solid model, as a special group