LEparagliding Studio 0.4.1

LEparagliding Studio is a free, cross-platform design tool for paragliders — a modern Qt / Open CASCADE port of Pere Casellas' LEparagliding 3.28. Draw your wing with live curve editors, preview the exact 3D shape (NURBS/STEP, DXF, STL), analyse airfoils with the built-in XFLR5, test the design in the Playground's soft-body wind tunnel, and nest its flat parts in the Print/Cut tab. 0.4.1 finishes that last step: the nested layout now leaves the screen as a file you can print or cut.

What's new in 0.4.1

0.4.0 shipped the Print/Cut tab with the parts, the nesting and the live packing — and said tiling to PDF was the next step. This is that step.

Print: tiled PDF at true size

Export PDF… writes one page per sheet, drawn at 1:1, ready to print and tape together.

• Registration crosses on a 100 mm grid, each labelled with its coordinate on the canvas. Neighbouring sheets share the same crosses in their overlap band, so sheets are aligned by laying one over the other until the marks coincide — not by butting edges and hoping.
• Overlap guides mark which strip is repeated from the previous sheet and which sheet covers it next, so it is unambiguous what goes on top of what.
• A 100 mm measuring bar on every sheet. Print dialogs scale to fit by default, and a pattern printed at 97% looks entirely plausible until the wing is sewn. Put a ruler on the bar; if it reads short, the printer scaled the page.
• A header on every sheet naming the wing, the sheet's place in the grid, and the scale it was drawn at.
• Empty sheets are skipped. A nested canvas routinely leaves a corner bare, and that corner is not worth a sheet of paper.

Cut lines, stitch lines and marks are separated by weight and dash pattern as well as colour, so the sheets stay readable on a monochrome laser.

Cut: layered DXF for a plotter or cutting table

Export DXF… writes the nested layout as DXF R12 — the dialect plotters and cutting tables actually accept — with the geometry split across layers so the operator can drive the blade from CUT alone and keep SEAM, MARK and TEXT as reference.

In machine-bed mode each bed load becomes its own file in that load's own coordinates, with the bed outlined on its own layer.

Choose what goes on the sheet

Three switches: stitch lines, marks and part numbers, and the sheet furniture (border, registration marks, ruler and header). Turn everything off and you get cut outlines and nothing else.

Pack and both export buttons now sit pinned below the options rather than at the bottom of the scrolling sidebar, so the thing the tab is for is always in view.

Part numbers now land on the part

Worth calling out, because it would have been discovered with scissors in hand. The original core anchors each part's number where it sits in the plan's drawing box — every rib's number is placed 635 mm to the left of the rib it names. That is fine on the original plan and meaningless once the parts are nested, where the number would have printed on top of whichever unrelated part happened to be packed in that spot. Numbers are now re-anchored onto the part they name.

The same release fixes a bed-mode export that could write a part into two adjacent bed loads — which a machine would have cut twice.

Known limitation, stated plainly

The nester positions each part by a single traced outline, and on some designs a few parts carry cut geometry that outline does not quite cover — a handful of millimetres reaching past the packed sheets, which the export would clip away. Rather than let that happen silently, the tab now says so after packing: "N part(s) have cut geometry reaching past the sheets." On the reference gnuA7/24 wing it is four parts out of 103, by 2 to 8 mm. Check those parts against the plan before cutting them. The proper fix changes how every design packs, so it is queued rather than rushed.

Unchanged from 0.4.0: the original core records no fabric grain, so the exported orientation of a part says nothing about which way the weave should run. Quarter-turn packing reliably avoids the bias; it cannot tell you a part was laid out the way the designer intended.

Install

Platform	How
Windows	Download LEparagliding_v0.4.1_winx64.zip, unzip anywhere, run LEparagliding.exe. Everything is bundled — no installer, no Qt to install.
Linux	Download LEparagliding_v0.4.1_linux-x86_64.AppImage, then chmod +x it and run it.
macOS	Download LEparagliding_v0.4.1_macos-universal.dmg, open it and drag the app to Applications. The build is unsigned, so the first launch needs right-click → Open rather than a double-click.

LEparagliding Studio 0.4.0

LEparagliding Studio is a free, cross-platform design tool for paragliders — a modern Qt / Open CASCADE port of Pere Casellas' LEparagliding 3.28. Draw your wing with live curve editors, preview the exact 3D shape (NURBS/STEP, DXF, STL), analyse airfoils with the built-in XFLR5, test the design in the Playground's soft-body wind tunnel — and now take it to the workshop: 0.4.0 turns your design into cut-ready parts.

What's new in 0.4.0

A new Print/Cut tab that takes the design's 2D flat patterns, nests them, and lays them out either for printing at 1:1 across tiled paper or for cutting on a machine bed.

Real parts, not a drawing

The 2D plan has always been a single flat DXF — tens of thousands of unlabelled line segments spread over a grid of drawing boxes, with no notion of "part" anywhere in it. The engine now tags its drawing as it happens and exports lep-2d-parts.json: every piece of fabric as a separate outline in its own frame, with its cut edge, stitch line and marks distinguished.

Twelve categories are recognised — extrados and intrados panels, ribs, middle unloaded ribs, mini-ribs, V-ribs (types 2, 3, 5 and 6), VH-ribs, H-ribs and straps, nylon rod pockets and nose mylars. Panels split chordwise into their real pieces, and a part's marks follow it: anchor points, air intakes, V-rib positions and equidistant seam marks all land on the part they belong to.

None of this changes a single number the engine calculates.

Packing

• Pick what you want — a part tree grouped by category with counts and true sizes; select a category, a handful of parts, or everything.
• Press Pack and watch it work — nesting runs on a worker thread and the layout fills in live, page count dropping as the search finds better arrangements. It keeps improving for as long as you let it and stops when you say so, keeping the best layout found.
• Page count is the objective, not density: a tiled canvas rounds up in both directions, so the search weighs canvas width against height rather than chasing local tightness.
• Machine-bed mode — set a custom bed (a 3 × 6 m laser, say) and no part will cross a bed boundary, because a bed is cut in one pass and a part spanning two loads is cut in half.
• Rotation is a fabric decision. Quarter turns keep the weave square to the part. Any other angle lays it on the bias, where woven fabric stretches — so free rotation is offered, clearly marked as suitable for paper templates only.
• Scale the output — as a percentage, or by naming the flat area you want (type 22 m² and it works out ×1.106). Useful for RC-scale prints and test sheets; for a genuinely larger wing, set Wing scale in Section 1 and rebuild so the engine recomputes allowances and line lengths properly.

Known limitation, stated plainly

The original core records no fabric grain. Parts are drawn wherever the plan's layout puts them, so the exported orientation says nothing about which way the weave should run. Quarter-turn packing reliably avoids bias, but it cannot establish that a part is oriented the way the designer intended. The export marks its orientation field as assumed rather than measured, and docs/flat-part-orientation.md sets out what a future C++ core needs to provide — including a proposed editor for drawing the fibre direction on each piece.

Tiling to PDF with registration marks is the next step; this release gets the parts, the nesting and the layout right first.

Elsewhere

• The window now opens maximised.

Install

Platform	How
Windows	Download LEparagliding_v0.4.0_winx64.zip, unzip anywhere, run LEparagliding.exe. Everything is bundled — no installer, no Qt to install.
Linux	Download LEparagliding_v0.4.0_linux-x86_64.AppImage, then chmod +x it and run it.
macOS	Download LEparagliding_v0.4.0_macos-universal.dmg, open it and drag the app to Applications. The build is unsigned, so the first launch needs right-click → Open rather than a double-click.

LEparagliding Studio 0.3.5

LEparagliding Studio is a free, cross-platform design tool for paragliders — a modern Qt / Open CASCADE port of Pere Casellas' LEparagliding 3.28. Draw your wing with live curve editors, preview the exact 3D shape (NURBS/STEP, DXF, STL), analyse airfoils with the built-in XFLR5, and test the design in the Playground: a soft-body simulation that inflates your actual wing and measures how well it holds its designed shape under flight load.

What's new in 0.3.5

This release rebuilds the Playground from a toy into a wind-tunnel instrument — and, separately, teaches the wing to fly.

The wind tunnel

• Flight load — the tethered wing is loaded with a realistic ~1.5 kN wing-level resultant (imposed as pressure, anchored on the designed hang line), so line loads and shape response mean something. On by default; the load is prescribed by the Angle slider, and the angle the rigging actually holds is an output you read, not an input you fight.
• Live shape instruments — the wing is measured continuously against its design shape (the mesh samples the exact ballooning law, so the rest pose is the design): per-section deviation and washout change, leading-edge dent, slack fabric, span/area/volume retention, mirror asymmetry, and per-row line loads (A/B/C/D, left/right) read from the exact solver multipliers. A compact HUD carries it all.
• "Anything weird" flags — heuristic tripwires (FrontTuckRisk, ProfileDistortion, WashoutChange, SlackFabric, SpanLoss, UnderInflated, Asymmetry, SlackRow, Unsettled) calibrated across three dissimilar wings, with every dimensional threshold relative to the wing's own chord/span/airspeed so the calibration carries across sizes.
• Analyse… — sweeps the tunnel across an angle-of-attack range on a background thread (a fresh wing per point, settled to convergence) and reports shape integrity vs α: plots, the full table, every flag with its onset angle, CSV export.
• Settle — steps the live wing at the Accurate solver setting (60×4), unpaced, until the measurement converges — watch it happen under any heatmap — then pauses at the converged pose with a Done line carrying the numbers that matter (L/D, lift, worst deviation, flags).
• Pull any line — Ctrl-click a line junction and drag: a force-instrumented kinematic grab (pull distance and newtons in the HUD) for inducing collapses and probing recovery.
• Headless twins of every GUI number: softwing-bench --shape and --shape-sweep (CSV).

Ways of looking

• Four heatmaps, smoothly vertex-shaded: Stress (edge stretch), Shape deviation (mm from the aligned design shape), Slack fabric (compression — the wrinkle map) and Pressure (the pressure difference on every cell face, deliberately un-smoothed so the cell-by-cell inflation structure is visible — watch the wing inflate).
• A calibrated legend inside the viewport — the exact colour ramp with units, numeric ticks and a live peak marker; a peak beyond the scale parks at the top with its true value printed, so saturation reads as saturation.
• Strain maps measure fabric, not solver residual: pinning ties and sub-scale edges are excluded, and strains aggregate as length-weighted means.

The page

• Everything in a left panel, the viewport at full height (a wing is ~1:1; the window is ~2:1 — chrome belongs beside the picture, not above it), Design-style view buttons under it (Fit, Iso, Front, Back, Left, Right, Top, Bottom), one status line across the bottom. Fit frames the whole system — canopy and lines.
• Sliders that explain themselves — live readouts (Pressure in Pa and km/h, Angle in degrees, brakes in cm), and an angle-of-attack dial showing the set angle, the angle the wing actually holds, and the computed lift in newtons. Default tunnel speed 36 km/h.
• Simulation on its own thread — the camera, colour modes and sliders stay fluid at any mesh density; the picture updates whenever the solver delivers; rebuilds no longer freeze the app. Hardened by an adversarial concurrency review.

Free flight and structure

• The wing actually flies — free flight with a pilot slung under the risers, trimming at the angle the lines were designed for, launching on its glide. Steer with the brakes; a little symmetric brake steadies it. (Experimental, off by default.)
• Fly mode — the mouse is the brake input: top-centre hands-up, straight down both brakes, sideways releases the opposite brake. Esc exits. Also fixed: the Left brake slider used to pull the wing's right side.
• Detailed ribs (preference) — ribs meshed as real holed sheets instead of hub-and-spokes, so rib load means something; a dropped centreline rib fixed; a Reset button returns the wing to its rest pose.
• Dark-theme polish: check-box indicators and buttons are properly visible, with hover/checked/disabled states.

The claim boundary is documented in docs/playground-shape-analysis.md: relative, structural signals of one design and comparisons between revisions — not certified absolute aerodynamics.

Install

Platform	How
Windows	Download the winx64 zip, unzip anywhere, run LEparagliding.exe — self-contained, no install needed.
Linux	Download the AppImage, chmod +x it, run.
macOS	Download the DMG (signed and notarized), open it, drag the app to Applications.

LEparagliding Studio 0.3.0

LEparagliding Studio 0.3.0 — a Playground tab with a live, inflatable wing.

A Qt 6 / Open CASCADE desktop port of Pere Casellas' LEparagliding 3.28 "Jardins" paraglider design program (GPL-3.0): the complete calculation engine, mechanically translated from Fortran and validated byte-for-byte against the original, wrapped in a modern design studio — with a full XFLR5 integrated for aerodynamic analysis of the wing you are designing.

What's new in 0.3.0

The Playground tab — a live soft-body wing. ⚠️ This is a very early experiment and cannot be used for anything real. It makes no engineering claims of any kind: it is a physics toy, tuned for stability and fun, not accuracy. Do not use it to judge a design, and certainly not to build or fly one.

With that said: after any preview or export, the Playground tab assembles your calculated wing into a real-time XPBD cloth simulation —

• The wing skin (with correct fabric widths from the ballooning law), the ribs, the V/H/VH-rib and mini-rib diagonals, and the full labelled line cascade down to the carabiners.
• Internal pressure inflates the cells; a fake lift, applied along the top surface's own normals, tensions the lines and holds the canopy's arc open.
• Brake sliders pull synthesized brake handles and crumple the trailing edge per side — expect dramatic swings; there is no pilot mass and no aerodynamics, so the wing reacts like a kite in still air.
• Drag to orbit, wheel to zoom. The simulation core is vendored from the author's SoftWingLab project.

Also in this release: the engine writes a small companion simulation mesh alongside every calculation, and --playground <lep-sim.json> opens the app straight onto the tab.

Downloads

Platform	File	Install
Windows x64	LEparagliding_v0.3.0_winx64.zip	Unzip anywhere, run LEparagliding.exe (self-contained)
Linux x86-64	LEparagliding_v0.3.0_linux-x86_64.AppImage	chmod +x, then run — needs glibc 2.35+ (Ubuntu 22.04+, Debian 12+, Mint 21+)
macOS (universal)	LEparagliding_v0.3.0_macos-universal.dmg	Drag to Applications; unsigned build — right-click → Open on first launch

LEparagliding Studio 0.2.3

LEparagliding Studio 0.2.3 — trailing-edge "fin" artifacts in the 3D panel surfaces fixed.

A Qt 6 / Open CASCADE desktop port of Pere Casellas' LEparagliding 3.28 "Jardins" paraglider design program (GPL-3.0): the complete calculation engine, mechanically translated from Fortran and validated byte-for-byte against the original, wrapped in a modern design studio — with a full XFLR5 integrated for aerodynamic analysis of the wing you are designing.

What's new in 0.2.3

Fixed: spurious "fins" on the panel surfaces at the trailing edge. On some wings the 3D preview and the exported STEP model grew spanwise spikes at the rib stations near the trailing edge — small near the wing center, up to several centimetres at the tips (visible e.g. on the Swoop preset). The wing data was never wrong: the artifact came from the OCCT surface-fitting routine used to loft each panel, which rang where the flat trailing-edge spans meet the curved ballooning arcs. The panel loft is now built by exact interpolation of the section curves instead:

• Panel surfaces still reproduce the analytical ballooning law exactly at every station (max deviation unchanged, ~1e-5 mm across all bundled presets), and the sewn shell topology is unchanged.
• The model builder now also validates the loft between chord stations, so this class of artifact can no longer pass undetected.
• Neighbouring panels now share a bit-identical boundary curve along their common rib.

Downloads

Platform	File	Install
Windows x64	LEparagliding_v0.2.3_winx64.zip	Unzip anywhere, run LEparagliding.exe (self-contained)
Linux x86-64	LEparagliding_v0.2.3_linux-x86_64.AppImage	chmod +x, then run — needs glibc 2.35+ (Ubuntu 22.04+, Debian 12+, Mint 21+)
macOS (universal)	LEparagliding_v0.2.3_macos-universal.dmg	Drag to Applications; unsigned build — right-click → Open on first launch

LEparagliding Studio 0.2.2

LEparagliding Studio 0.2.2 — the complete LEparagliding manual, bundled offline.

A Qt 6 / Open CASCADE desktop port of Pere Casellas' LEparagliding 3.28 "Jardins" paraglider design program (GPL-3.0): the complete calculation engine, mechanically translated from Fortran and validated byte-for-byte against the original, wrapped in a modern design studio — with a full XFLR5 integrated for aerodynamic analysis of the wing you are designing.

What's new in 0.2.2

The official manual ships inside the app. The complete LEparagliding manual (original documentation by Pere Casellas, Laboratori d'envol) is now bundled with the Studio and works fully offline:

• Per-section help — every section's help dialog ("?") now appends the matching chapter from the official manual, with its figures, below the Studio's own explanation.
• Manual button — opens the complete manual in a resizable, non-modal window with a working table of contents, so it can stay open beside the section editors while you design.

This release also includes everything from 0.2.1 (released earlier today): V-ribs, H-ribs, VH-ribs and trailing-edge mini-ribs exported as named ruled surfaces in the STEP model, and the Preferences toggle for construction-curve export.

Downloads

Platform	File	Install
Windows x64	LEparagliding_v0.2.2_winx64.zip	Unzip anywhere, run LEparagliding.exe (self-contained)
Linux x86-64	LEparagliding_v0.2.2_linux-x86_64.AppImage	chmod +x, then run — needs glibc 2.35+ (Ubuntu 22.04+, Debian 12+, Mint 21+)
macOS (universal)	LEparagliding_v0.2.2_macos-universal.dmg	Drag to Applications; unsigned build — right-click → Open on first launch

LEparagliding Studio 0.2.1

LEparagliding Studio 0.2.1 — the wing's internal structure arrives in the 3D model.

A Qt 6 / Open CASCADE desktop port of Pere Casellas' LEparagliding 3.28 "Jardins" paraglider design program (GPL-3.0): the complete calculation engine, mechanically translated from Fortran and validated byte-for-byte against the original, wrapped in a modern design studio — with a full XFLR5 integrated for aerodynamic analysis of the wing you are designing.

What's new in 0.2.1

Diagonal ribs are now real surfaces. V-ribs, H-ribs and VH-ribs (section 12, all types including the percent variants) were missing from the exported STEP model — the original program only ever drew them as line segments in the 3D DXF, and most types not even that far into the OCCT model. Every row of the H/V rib table now becomes a named part ("V-rib 7", "H-rib 2", …) in the Diagonals assembly group, built as an exact ruled surface: both boundary curves interpolate every point the legacy engine computes, so the sheet follows the curvature of the top and bottom skin it attaches to, and every strap line of the original 3D output lies exactly on the face.

Trailing-edge mini-ribs join the model. The mini-ribs defined in section 2 (including full unloaded middle ribs at 100%) never existed in 3D at all — the original program only produces their 2D cutting patterns. They are now derived from the mid-cell section, cut at the configured percent of chord ahead of the trailing edge, and appear as surfaces under Ribs → Mini-ribs, sharing the rib color and visibility toggle in the Studio and in exported STEP assemblies.

Construction curves are now optional in STEP exports. A new Preferences checkbox (on by default) controls whether exported STEP files include the extrados/vent/intrados surface-wireframe curve groups. Suspension lines and part outlines are always exported, and the 3D preview keeps its curves either way. Headless users can pass --no-construction-curves to leparagliding-engine.

Downloads

Platform	File	Install
Windows x64	LEparagliding_v0.2.1_winx64.zip	Unzip anywhere, run LEparagliding.exe (self-contained)
Linux x86-64	LEparagliding_v0.2.1_linux-x86_64.AppImage	chmod +x, then run — needs glibc 2.35+ (Ubuntu 22.04+, Debian 12+, Mint 21+)
macOS (universal)	LEparagliding_v0.2.1_macos-universal.dmg	Drag to Applications; unsigned build — right-click → Open on first launch

LEparagliding Studio 0.2.0

LEparagliding Studio 0.2.0 — graphical curve editing and a much faster 3D preview.

A Qt 6 / Open CASCADE desktop port of Pere Casellas' LEparagliding 3.28 "Jardins" paraglider design program (GPL-3.0): the complete calculation engine, mechanically translated from Fortran and validated byte-for-byte against the original, wrapped in a modern design studio — with a full XFLR5 integrated for aerodynamic analysis of the wing you are designing.

What's new in 0.2.0

Design sections become graphical. The biggest change in this release: key sections can now be edited by dragging curves and shapes instead of (not in place of — alongside) the raw text.

• Section 1 (Geometry) — every column of the rib matrix is drawn as a selectable curve under the text editor: drag or arrow-nudge points, with a real value axis for the selected parameter, and only the rows you actually change are patched back into the text.
• B-spline truth mode — optionally convert Section 1 curves to clamped cubic B-splines through a live-preview dialog with a tolerance slider and fit summary. After conversion the spline is the source of truth: you drag its control points and the rib matrix is regenerated by sampling it, so the design stays smooth by construction. Spline definitions are stored in the design file's Studio trailer — the engine-visible format is unchanged, and manual matrix edits are detected as "stale spline" with re-fit / re-apply offered inline.
• Section 2 (Airfoils) — referenced airfoil files are shown aspect-true and can be converted to parametric 2D B-splines (fitted per extrados/intake/intrados segment) and edited by dragging control points. Edits are written to a regenerated <name>-spline.txt next to the design; your original airfoil files are never touched.
• Section 4 (Airfoil holes) — lightening holes are drawn inside the airfoil of their rib group with move and resize grips, using exactly the engine's coordinate conventions (including its radians-for-ellipses, degrees-for-polygons quirk).
• Sections 3 and 30 get read-along curve views, with curves the engine currently ignores greyed out and a tooltip explaining why.
• Graphical undo — every graphical editor has its own Ctrl+Z/Ctrl+Y stack that restores section text, stored splines, and regenerated airfoil files together, independent of the text editors' undo.

3× faster 3D preview. A preview rebuild dropped from ~6 s to under 2 s of engine time: rib faces are validated once instead of after every hole cut, ribs are built in parallel, and the preview hands the model to the viewport as compact binary XCAF instead of a STEP write/parse round-trip. Explicit exports still produce the same AP242 STEP assembly — the generated geometry is identical to 0.1.0.

Platform fixes. The macOS DMG is now a single universal app for Apple Silicon and Intel (macOS 13+), presets moved inside the bundle where code signing expects them, and the Linux AppImage is built on Ubuntu 22.04 so the stated glibc 2.35+ baseline actually holds.

Downloads

Platform	File	Install
Windows x64	LEparagliding_v0.2.0_winx64.zip	Unzip anywhere, run LEparagliding.exe (self-contained)
Linux x86-64	LEparagliding_v0.2.0_linux-x86_64.AppImage	chmod +x, then run — needs glibc 2.35+ (Ubuntu 22.04+, Debian 12+, Mint 21+)
macOS (universal)	LEparagliding_v0.2.0_macos-universal.dmg	Drag to Applications; unsigned build — right-click → Open on first launch

LEparagliding Studio 0.1.0

LEparagliding Studio 0.1.0 — first public release.

A Qt 6 / Open CASCADE desktop port of Pere Casellas' LEparagliding 3.28 "Jardins" paraglider design program (GPL-3.0): the complete calculation engine, mechanically translated from Fortran and validated byte-for-byte against the original, wrapped in a modern design studio — with a full XFLR5 integrated for aerodynamic analysis of the wing you are designing.

Highlights

• Integrated XFLR5 — the complete XFLR5 v6.62 runs inside the application as an Aerodynamics tab, and the calculated wing is transferred to it automatically: design the glider and analyze its aerodynamics in one program, with no export/import round-trip.
• Full LEparagliding 3.28 compatibility — existing design files work unchanged, and 3.17 designs that end at section 32 load with disabled defaults for the newer sections. The original design file is never rewritten.
• Design studio — every input section has its own syntax-highlighted editor with independent undo/redo; each Save embeds the complete whole-wing version history in the design file, so any earlier state can be restored later.
• Exact 3D model — the wing is rebuilt as exact rational B-spline surfaces with Open CASCADE and exported as an AP242 STEP assembly (named panels, ribs with cut-out holes, diagonals, and suspension lines tagged with their section-34 line types), alongside the classic DXF plans, line reports, STL and XFLR5 outputs.
• Presets — wing designs from laboratoridenvol.com ship with the app and calculate out of the box.
• Validated numerics — against native gfortran output: both DXFs, lines.txt, and run-log.txt match byte-for-byte; the calculation report matches field-by-field.

Downloads

Platform	File	Install
Windows x64	LEparagliding_v0.1.0_winx64.zip	Unzip anywhere, run LEparagliding.exe (self-contained)
Linux x86-64	LEparagliding_v0.1.0_linux-x86_64.AppImage	chmod +x, then run — needs glibc 2.35+ (Ubuntu 22.04+, Debian 12+, Mint 21+)
macOS (Apple Silicon)	LEparagliding_v0.1.0_macos-arm64.dmg	Drag to Applications; unsigned build — right-click → Open on first launch