ajandClaude Fable 5.2 ddcfbce072 refactor(engine): split Irregular's frontier packer into named steps
FrontierPacker.Fill was one 165-line method: three local functions
(Track, Block, PrepareBlocks) closed over nine variables of the fill in
progress, the seated-parts pass repeated Block's parallel loop inline,
and the placement loop carried its retirement rules between them.
Choose kept its leader in seven loose variables behind a local function,
and BestVertex took twelve parameters, four of them outs that every
TryLowest threaded back out. Every pass of the engine goes through this
class, so the next change to the placement rule had to be made inside
all of that.

Fill now reads as its steps: TrackDemand, Seat, PrepareBlocks, then
Choose and Place until nothing fits. The fill in progress is a Sheet
(copies left, regions, pairs, blocks, parts placed, front) passed to
each step, the leader of a choice is a Leader that Consider updates, and
a candidate's point and scores travel as one Spot, with the inner-fit
box and the piece's box as Extents. The repeated expressions have one
definition each: the part's reach along the front axis, a region losing
what a part blocks, the parallel blocking pass, the two retirements of
emptied regions and pairs, and the "lower across, then lower leading
edge" tie-break shared by Choose and BestVertex. The tolerances and the
block limits (two preparations per fill, four types, three copies) are
named constants. PackAxis, Placed and SheetFill, which the whole engine
uses, have their own files.

The constructor keeps its shape: most call sites name its optional
arguments already. The two that passed positional nulls now name them.

No layout changes, and no change to the order work is metered or to the
parallel passes: a placement still blocks one pass per part. Traced
before and after: every progress report, plan, alternative, repeat
batch, tail re-plan (with its work-meter reading) and final result of
70 solves (one to three stocks, mixed spacings, finite stock, a sheet
cap, priorities, explicit costs with salvage and both offcut axes, clamp
rails, outlined sheets, oversize parts, all four quadrants, grouped and
banded jobs, four engine settings, seven searches until cancelled), the
poses and work-meter reading of 2,298 direct Fill calls (pairs, blocks,
type weights, group ranks, reach, within, seated parts, a starting
front, clamps, outline and cutout boundaries with obstacles, pair-only
orientations), and six cutout proposals. The traces are byte-identical.
Engine suite and the problem-nest corpus's auto-nest area pass.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-20 12:25:17 -05:00
2026-10-26 20:33:20 -04:00

OpenNest

A Windows desktop application for CNC nesting — imports DXF, DWG and SVG drawings, arranges parts on material plates, and exports layouts as DXF, SVG or G-code for cutting.

OpenNest - 137 parts nested on a 60x120 plate OpenNest - cut simulator replaying the plate in cut order

Features

  • Import / export — DXF, DWG (ACadSharp) and SVG parts, Excel BOMs, bend-line detection, built-in parametric shapes; export plates as DXF, SVG or post-processed G-code, and single drawings from the CAD Converter as DXF, DWG or SVG with their bends. SVG import and export.
  • Nesting — automatic multi-plate/multi-material jobs, interlocking pair evaluation, and built-in or plug-in engines. Choose an engine.
  • Plate operations — manual sheet cut-offs, plate- or nest-wide automatic scrap cutoffs with a minimum tail-to-keep setting, oversized-part splitting (straight, weld-gap tabs, spike-groove), interactive editing, and spacing-aware pushes that can slide along or away from touching parts.
  • Visual overlap check — highlight shared material on the active plate, rechecked automatically after edits, including containment and cutouts, with area shading, pair markers, and hover details through View > Overlap Check. Usage and limitations.
  • Cut simulator — Plate > Simulate Cutting replays the active plate in cut order: the torch traces each cut, rapid and pierce at adjustable feed, rapid and pierce settings, with play/pause, scrubbing, 1×–250× speed and previous/next part (Page Up/Down) and cutout (Ctrl+Left/Right) jumps. Parts the torch has not reached stay grayed. It and Calculate Cut Time use separate outside and hole feeds, skip etch-only contours like the CI Fiber post, and apply the chosen machine's acceleration and corner limits from Machine Configuration (placeholder values until you enter the controller's). Timing model.
  • CNC output — configurable lead-ins/outs and tabs, contour editing, user-defined G-code variables ($name → #200+ machine variables), plugin post-processors (Cincinnati CL-707/800/900/940/CLX included). Pre-post verification checks overlaps, missing lead-ins, and rapid crossings, with explicit risk acknowledgment required to bypass warnings.

Requirements

  • Windows 10+ for the desktop app; the console, API, shared desktop library (OpenNest.Desktop) and most test projects build on Linux/macOS too. OpenNest.Avalonia is an early cross-platform desktop prototype, not yet a usable replacement.
  • .NET 8 SDK to build from source.

Prebuilt Windows downloads are on GitHub Releases, or build from source to run the latest code. Release ZIPs are self-contained: extract the entire archive into a new folder and run OpenNest.exe; no separate .NET installation is needed. For automatic updates, install with OpenNest-win-Setup.exe or extract OpenNest-win-Portable.zip instead: those copies download new full releases in the background, from GitHub Releases or, in Database mode, the nest server's mirror of them first (a hand-set feed URL overrides both) and restart only when you agree (auto-update). The plain ZIP does not auto-update; to update it, close OpenNest and extract the new release into a new folder. All nesting engines (Default, Rectangles, Irregular, Circles, FlatBar and the fill strategies) are built in; see nesting engines.

Build, Test, Run

git clone https://github.com/ajisaacs/OpenNest.git
cd OpenNest
dotnet build OpenNest.sln                                       # full solution (Windows)
dotnet test OpenNest.Engine.Tests/OpenNest.Engine.Tests.csproj  # cross-platform engine tests
dotnet test OpenNest.Tests/OpenNest.Tests.csproj                # core/engine/IO/API tests
dotnet test OpenNest.Desktop.Tests/OpenNest.Desktop.Tests.csproj # shared desktop library tests
dotnet test OpenNest.FrontEnd.Tests/OpenNest.FrontEnd.Tests.csproj # console/MCP/API integration
dotnet run --project OpenNest/OpenNest.csproj                   # desktop app (Windows)
dotnet run --project OpenNest.Avalonia/OpenNest.Avalonia.csproj # cross-platform prototype

OpenNest.WinForms.Tests (desktop-assembly tests) runs on Windows only; CI runs it on a GitHub-hosted Windows runner, and OpenNest.FrontEnd.Tests on both Linux and Windows, for every master push and pull request.

Quick start

  1. File > New
  2. Import DXFs via the CAD Converter (layer/color filtering, per-entity exclude and cut/etch/display-only roles, bend detection, G-code preview) or create built-in shapes
  3. Define plate size, material, quadrant, spacing
  4. Fill — the engine arranges parts
  5. Optionally add cut-off lines, apply Part Sequencing to order crossing cut-offs before their parts, then save .nest, export DXF or SVG, or post-process to G-code

Review part spacing before cutting, especially for interlocking pairs. See pair-spacing checks and current limitations.

Command-Line Interface

dotnet run --project OpenNest.Console -- part.dxf --size 60x120               # fill one plate
dotnet run --project OpenNest.Console -- part1.dxf part2.dxf --size 60x120 --autonest
dotnet run --project OpenNest.Console -- project.zip                          # re-fill a nest file
dotnet run --project OpenNest.Console -- job.nest --no-fill --plan-cutting --all-plates
Option What it does
--size WxL Set the plate size; required for DXF-only input.
--autonest Run validated whole-job nesting; one sheet unless --max-sheets <n> allows more.
--engine <name> Choose a whole-job engine with --autonest, or a fill strategy without it.
--quantity <n> Limit parts placed (0 means unlimited). With --autonest, nest n of each drawing instead of its required quantity.
--spacing <value> Override part spacing.
--template <path> Read plate defaults from a nest file.
--output <path> Set the output nest path.
--check-overlaps Check the result for overlaps.
--no-fill Keep a loaded nest as it is, for example to plan cutting or post it.
--plan-cutting Plan and apply cutting (part order, contours, entries, lead-ins); see cut planning.
--cutting-params <path> Cutting settings JSON for --plan-cutting; otherwise the plates' saved settings are used.
--post <name> Run a post-processor after nesting.
--no-save Skip saving the nest.
--allow-invalid Explicitly keep a representable invalid --autonest result; otherwise it is rejected.

Run dotnet run --project OpenNest.Console -- --help for the complete options and their defaults.

Project Structure

Project Purpose
OpenNest WinForms desktop app
OpenNest.Core Domain model, geometry, CNC primitives; material-overlap diagnostics
OpenNest.Engine Nesting algorithms and whole-job contracts
OpenNest.IO DXF/DWG/SVG, .nest, G-code, BOM I/O; CAD import
OpenNest.Console Headless batch nesting
OpenNest.Api / .Data Programmatic pipeline; machine & cutting-parameter data
OpenNest.Gpu GPU-accelerated pair evaluation (ILGPU)
OpenNest.Benchmark Head-to-head engine comparison
OpenNest.Mcp MCP server for AI tool integration
Posts/ Post-processor plugins (Cincinnati CL / CI Fiber lasers, Gravograph IS8000)
*.Tests Cross-platform suites; WinForms tests are Windows-only

Nesting Engines

Default compares the built-in Irregular, Rectangles and Circles engines and keeps the best valid whole-job layout. Other engines and plug-ins suit particular jobs; see which engine to use. Desktop Auto Nest, console autonest, MCP autonest, and the API share an independent validation pipeline, including for plug-ins. Automatic nesting and validation explains how callers handle invalid results.

File Format

.nest files are ZIP archives containing drawing programs, metadata, plates, and placements. Saved nests retain each part's lead-ins, lead-outs, tab gaps, and locks, plus the plate's cutting settings. Changing a drawing's geometry removes obsolete cutting paths from its parts; name, quantity, and color edits preserve them. See the file-format reference for compatibility and recovery behavior.

Supported Formats

Format Import Export
DXF Yes Yes
DWG Yes Yes (single drawings, CAD Converter)
SVG Yes Yes
Excel BOM Yes No
G-code No Yes (post-processors)
.nest Yes Yes

Keyboard Shortcuts

Ctrl+F fill area · F zoom to fit · Shift+wheel / middle-click rotate · X/Y push · arrows nudge by the offset increment (F5), or with its calculated distance by the selection's own size plus part spacing, landing tight with no push back (it always moves, even off the plate) · Shift+arrow push.

Status & License

Actively developed; core workflows run end-to-end from DXF import to G-code. Contributions welcome. MIT licensed — see LICENSE.

S
Description
Read-only backup mirror of https://github.com/ajisaacs/OpenNest (GitHub is the primary). Pulled hourly.
Readme MIT
16 MiB
0 Stars 1 Watchers 0 Forks
Languages
C# 98.4%
Python 1.2%
PowerShell 0.2%
Shell 0.1%