Vector Paths

The Pen Tool

Pick the Pen / Vector Path tool (the pen-nib icon) from the toolbar, then build a path point by point. Click to drop corner points; click-and-drag to drop a smooth point with curve handles that follow your drag.

You always see what you are drawing. While a path is under construction the Pen draws a thin blue guide through the anchors, with a square on each one and a rubber-band segment running to the cursor. That guide is independent of the shape's own paint, which matters when you are building a filled shape with no stroke: set the stroke to None, and the object itself is invisible until it closes — the blue guide is what you draw against in the meantime. The guide is construction chrome only; it disappears the moment the path is finished and it never appears in an export.

Editing Nodes

Nodes belong to the Node tool, not the Select tool — the same split every other vector editor makes (Illustrator V vs A, Inkscape S vs N). Press N, or simply double-click the path, to reveal its anchors (squares) and Bézier handles (circles). Drag to reshape; use the modifiers below to restructure.

On a tablet (no keyboard)

Every node-editing action above has a touch equivalent, so you never need a modifier key on an iPad or touch device:

The Node tool (Illustrator's “Direct Selection”)

Everything above edits one anchor at a time. Press N — double-click a path, or Command Palette (Ctrl+K) → Node Tool / Direct Selection, or the Vector Tools palette → Nodes — to switch into the dedicated Node tool, which edits many anchors at once. It's the same thing Illustrator calls Direct Selection (the white arrow) and Inkscape calls the Node tool; Yappy uses Inkscape's N because A is already the Arrow tool.

Select a path first — the tool draws anchors for the selected path, so with nothing selected there's nothing to edit. You don't have to leave the tool to move on: click another shape and it becomes the one you're editing, Shift-click to edit several paths at once, and with nothing selected a drag picks shapes rather than anchors. Clicking empty space lets go in two stages — the first click drops the selected anchors, a second drops the path — so missing an anchor by a few pixels doesn't cost you your place.

Convert to Path

Turn any shape into an editable vector path in place — same position, z-order, style, and connections. Select one or more shapes, right-click, and choose Path → Convert to Path.

• Rectangles → 4 corner anchors (rounded corners keep their arcs)
• Circles / ellipses → 4 smooth Bézier anchors
• Polygons & stars → exact corner anchors
• Curved shapes (database, cloud, capsule, lightbulb, …) → the outline is converted command by command, so arcs come through as real Bézier curves rather than being sampled into a polygon. A database becomes six anchors — two straight sides and two arcs — not thirty flat chords.
• Shapes whose outline has more than one contour stay compound (their subpaths are kept).
• 3D solids (isometric cube, solid block, perspective block, open box, cylinder) convert to their silhouette — the union of their faces. The interior edges that make them read as 3D are shading, not outline, so they do not survive; you get one editable outline of the whole solid. This also means the Node tool, Warp, Turntable, the Knife and the Pathfinder now work on 3D blocks, which previously refused them outright.

Once converted, every node is editable with the gestures above.

Pathfinder (Boolean Operations)

Combine two or more overlapping shapes into a new path. Select the shapes, right-click, and open the Pathfinder submenu. Order matters for Subtract — the back-most (lowest) shape is the base that the others are removed from.

Outline Stroke & Offset Path

Both live in the right-click Path submenu.

Outline Stroke

Converts a stroked line or path into a filled shape of the stroke itself (thickness = the current stroke width). The original element is replaced; the new path is filled with the old stroke color. Great for giving a brush-like outline real, editable geometry you can then recolor or combine.

Offset Path

Creates a parallel copy of the path, expanded or contracted by a fixed distance, while keeping the original. Offset Path (+10) grows the outline outward by 10px; Offset Path (−10) shrinks it inward. Handy for concentric outlines, padding, and inset/outset effects.

Stroke Alignment, Corners & End Caps

Three controls in the Properties panel decide how a stroke is actually painted around its outline. They apply to shapes and Pen tool paths, in both the sketch and architectural draw styles.

Stroke Align — Center / Inside / Outside

By default a stroke straddles the outline: half its width falls inside the shape, half outside. That's Center. Switch to:

• Inside — the whole stroke sits within the outline, so the shape never grows past the box you drew. A border stops eating into the space around it.
• Outside — the whole stroke sits outside the outline, so a thick border never covers the artwork or fill it frames.

This is what you want when a region has to line up exactly with a grid or a neighbouring shape — a 12px map border on Center silently overhangs its region by 6px.

Corner Style — Sharp / Round / Bevel

How the stroke turns a corner. Miter (Sharp) extends both edges to a crisp point; Round arcs them; Bevel (Flat) cuts the corner off square. Sharp suits technical and architectural work, Round softens icons and routes, Bevel keeps very thick strokes from growing long spikes at tight angles.

End Cap — Butt / Round / Square

How an open path ends — Pen paths, lines and freehand strokes. Butt (Flat) stops the line dead at its last point; Round finishes with a half-circle; Square with a flat extension. Round and Square both push the line past its final point by half the stroke width, so Butt is the one to use when a route must terminate exactly on a coordinate.

const Y = window.Yappy;

// A region whose 12px border stays entirely inside its bounds
Y.createRectangle(100, 100, 200, 140, {
  strokeColor: '#1d4ed8', strokeWidth: 12,
  backgroundColor: '#bfdbfe', fillStyle: 'solid',
  strokeAlign: 'inside',        // 'center' (default) | 'inside' | 'outside'
  strokeLineJoin: 'miter',      // 'round' (default) | 'miter' | 'bevel'
});

// A map route that terminates exactly on its end points
Y.createPath([{ x: 100, y: 300 }, { x: 260, y: 340 }, { x: 400, y: 300 }], {
  strokeColor: '#0f766e', strokeWidth: 14,
  strokeLineCap: 'butt',        // 'round' (default) | 'butt' | 'square'
  strokeLineJoin: 'bevel',
});

All three survive SVG export: corners and caps map straight onto stroke-linejoin / stroke-linecap, and alignment is reproduced with a clipPath (SVG has no stroke-alignment attribute of its own).

Simplify & Compound Paths

In the right-click Path submenu:

const Y = window.Yappy;
Y.simplifyPath();          // selection; auto-converts non-paths first
Y.smoothPath();            // same, but rounds corners instead of dropping anchors

Exporting as Vector

Export to SVG (Export dialog → SVG) writes every shape and path as a real, scalable <path> — including compound holes (even-odd), rotation, and flips. Sketch-style shapes export as vector rough strokes; architectural shapes export as clean paths. The result opens losslessly in Illustrator, Inkscape, or any browser, with no pixelation.

Holes & Compound Paths

A single path can hold multiple subpaths — letting it have holes (a donut, the counter of an “O”) or several disjoint islands. Holes are produced automatically:

• Subtract a shape from the middle of another → the result keeps the hole.
• Outline Stroke on a closed loop → keeps the inner edge as a hole.

Compound paths fill with the even-odd rule, so overlapping closed subpaths punch holes. Clicking inside a hole clicks through it (it selects whatever is behind, not the path) — matching what you see. Resize, rotate, and both drawing styles work on compound paths just like simple ones.

Scripting (API)

Everything the Pen tool and the right-click Path menu do is also available programmatically. The global entry point is window.Yappy (usable as Yappy in the console or a script block). Anchors use the PathAnchor shape { x, y, kind?: 'corner' | 'smooth', inX?, inY?, outX?, outY? }, where the handle offsets are relative to the anchor.

Create & read paths

// A closed triangle from three corner anchors
const tri = Yappy.createPath([
  { x: 100, y: 100, kind: 'corner' },
  { x: 260, y: 140, kind: 'corner' },
  { x: 140, y: 260, kind: 'corner' },
], { closed: true, strokeColor: '#1e1e1e', strokeWidth: 2 });

// A smooth curve (Bezier handles via out/in offsets)
Yappy.createPath([
  { x: 100, y: 300, kind: 'smooth', outX: 60, outY: -60 },
  { x: 300, y: 300, kind: 'smooth', inX: -60, inY: -60 },
], { closed: false });

// Read an editable path back
const data = Yappy.getPath(tri); // { anchors, closed } or { subpaths }

Holes & compound paths

// A donut: outer ring + inner hole (even-odd fill)
Yappy.createMultiPath([
  { closed: true, anchors: [
    { x: 0, y: 0 }, { x: 200, y: 0 }, { x: 200, y: 200 }, { x: 0, y: 200 },
  ] },
  { closed: true, anchors: [
    { x: 60, y: 60 }, { x: 140, y: 60 }, { x: 140, y: 140 }, { x: 60, y: 140 },
  ] },
], { backgroundColor: '#4dabf7' });

// Or build/release a compound from existing selected shapes
Yappy.makeCompoundPath([idA, idB]);
Yappy.releaseCompoundPath([compoundId]);

Convert, combine & derive

// Any shape -> editable path (in place)
Yappy.convertToPath([shapeId]);

// Boolean (Pathfinder) ops on 2+ ids
Yappy.pathfinder([a, b], 'union');    // 'union' | 'subtract' | 'intersect' | 'exclude'
Yappy.pathfinderRegion([a, b], 'divide'); // 'divide' | 'trim' | 'merge' | 'crop' | 'outline'

// Stroke -> filled outline shape
Yappy.outlineStroke([lineId]);

// Parallel copy, +grows / -shrinks
Yappy.offsetPath([pathId], 10);

// Chain open paths into one (auto-closes if ends meet)
Yappy.joinPaths([p1, p2]);

Tidy up

// Reduce anchor count while keeping the shape
Yappy.simplifyPath([pathId]);

// Smooth anchors (strength 0..1, iterations). No ids -> current selection.
Yappy.smoothPath([pathId], 0.5, 2);

Node editing

The Node tool is scriptable as well as clickable. An anchor is addressed by a NodeRef — { id, sub, i }: the element id, which subpath (0 for a simple path), and the anchor's index within it. Operations act on the current anchor selection, which is separate from the element selection.

const Y = window.Yappy;

Y.select(pathId);
Y.toggleNodeTool(true);              // show the anchors

// Take every anchor of the selected path(s), then round them all off.
Y.setNodeSelection(Y.allNodesOfSelection());
Y.setSelectedNodesKind('smooth');

// Nudge just the anchors you pick (element-origin units).
Y.setNodeSelection([{ id: pathId, sub: 0, i: 2 }]);
Y.moveSelectedNodes(0, -20);

// Read positions in WORLD space, e.g. to drive your own layout.
Y.getPathNodes();    // [{ ref, x, y, kind }, ...]
Y.getNodeHandles();  // [{ h, x, y, ax, ay }, ...] for the selected anchors

Y.deleteSelectedNodes();             // a subpath is never taken below 2 anchors
Y.toggleNodeTool(false);