What's new

The unit toggle at the top of the Settings panel now offers three units: mm · cm · in.

Centimetres are a full working unit, not just a display option. Everything follows your choice — the stock and part tables, kerf and trims, the on-screen cut plan, the PDF, Excel and CSV exports, the piece labels, and the badge on each saved cut. A plan you made in centimetres reopens in centimetres.

Why we added it: plenty of you work in centimetres — furniture and glass sizes are quoted that way in most of Europe — and until now the only options were millimetres or inches. That left people either multiplying everything by ten by hand or, worse, typing centimetre numbers into a millimetre workspace and getting a plan that was wrong by a factor of ten.

A few details worth knowing:

• Switching converts your data. If your numbers are already in the tables, changing the unit converts every dimension after a quick confirmation. If the workspace is still untouched, it re-seeds with round numbers for that unit instead — in centimetres the demo sheet becomes 244 × 122 cm and the default kerf 0.3 cm.
• Centimetres keep two decimals (millimetres keep one, inches three). That is deliberate: a single decimal would put a 1 mm floor on centimetre mode, coarser than millimetre mode, so switching units could quietly cost you precision. Trailing zeros are never shown — a 244 cm board reads 244.
• A finished optimization keeps the unit it was made in. Switching afterwards never re-labels a completed plan, never invalidates it, and never costs you a run.

Millimetres remain the default, and nothing changes for existing projects unless you switch.

Your dashboard now has an Account & security section, grouped together at the bottom of the page.

From there you can change your password — after confirming your current one — and, if you created your account with Google, set a password so you can also sign in with your email address. You’ll also find Sign out of all devices, which ends every active session at once (handy on a shared or lost computer), along with your sign-in method, join date and last sign-in.

Nothing else moved: data export and account deletion stay in the Privacy & data section just below.

An independent external party has completed a full security review of CutOptim, covering the app, the account and team features, and the way your data is stored and exported.

The review flagged a small number of areas to harden, and we’ve addressed all of them. The improvements include stronger isolation of data between team workspaces (joining a shared workspace now always requires the invited person to accept first), safer exported files (names in CSV and spreadsheet exports can no longer be interpreted as formulas by Excel, Google Sheets or LibreOffice), and tighter handling of colours and labels throughout the app.

None of these required any action on your part, and there is no evidence any of them were ever used against an account. Your projects stay private to you and your team, and we will keep reviewing security as CutOptim grows.

Adding a colleague to your Team Workspace now requires their consent. Until now, typing a teammate’s email and clicking Add placed them in your workspace right away. From now on that creates a pending invitation instead — no one joins a team without agreeing to it.

The new flow: the owner invites a colleague by email address from the Dashboard. The colleague signs in and sees an Accept / Decline banner at the top of the Team management area of their own Dashboard. Only after they click Accept do they join — and only then do they get the owner’s plan and the workspace’s shared projects. They can Decline instead, and a member can leave later the same way.

There is no invitation email: tell your colleague out-of-band that you have invited them, and the invitation waits in their Dashboard until they respond. Everything else about the shared workspace is unchanged — still up to 3 members, and projects saved by an active member still belong to the organization.

See Team Workspace for the full details.

An audit of the Engine API turned up three things worth telling you about. None of them change the default engine, and no existing plan changes shape.

The max engine says what it cannot do

The asynchronous max engine packs one stock format, at full sheet size, with unlimited supply. Until now a 2D request that asked for more than that was still accepted: the extra stock format quietly disappeared, respectStock quietly became unlimited supply, and an options.trim you had reserved for the saw was quietly cut into. You got back a confident, deterministic plan for a job you had not sent, and nothing in the response said so.

Those requests are now refused at submission with 400, naming each unsupported feature — a second stock row, options.trim, options.respectStock, any material, any grainGroup. The refusal happens before a call is reserved, so it costs you nothing, and before you wait a minute for a result you would have to throw away. Send those jobs to the default heuristic engine, which models all of them.

Options that only make the plan less tuned — tolerance, minimizeCost, maxCutStages, minimizeRotations, firstCut, effort — still go through, and are now listed in warnings instead of disappearing. A max result reports no offcuts.

Validate now agrees with optimize

POST /v1/validate/2d used to reject engine: "max" with a 400 saying the engine was not available — for a body POST /v1/optimize/2d accepted. The two now give the same verdict for the same body, which is the whole point of a validate endpoint.

CSV exports quote part names

A part name containing a comma — “Door, left” — used to emit an extra field, shifting every column after it. CSV exports from the app and from the API (include: ["csv"]) are now RFC 4180 quoted. A name without a comma, quote or line break produces exactly the same bytes as before.

The API reference and the OpenAPI document describe all of this in full.

The Engine API’s default engine is fast and always saw-cuttable, and for the overwhelming majority of jobs it is exactly what you want. But on a large, valuable 2D job, the last few boards can be worth waiting for. That is what the new max engine is for.

What it does

max is a server-side tree search (2D only) that reaches the proven optimum on far more jobs than the default — the plan matches the theoretical minimum number of boards, provably. Its layouts are still guillotine-cuttable (producible on a panel saw), and it is still deterministic: the same request always returns the same plan.

The trade is time. A max solve takes seconds to a minute, where the default answers in milliseconds. So it does not hold the connection open waiting.

How you call it

Because it is slow, max is asynchronous — the one place the Engine API does not answer in the response:

• Submit. POST /v1/optimize/2d with engine: "max" returns 202 Accepted with a jobId (metered at submission).
• Poll. Call GET /v1/jobs/{id} until status is "succeeded" — the result field then holds the same 2D response a synchronous solve returns — or "failed", with the reason in error. Polling spends no quota, and you only ever see your own jobs.

It is 2D only: 1D, wood and true-shape nesting are unaffected. The default (heuristic) and the opt-in balanced engine are unchanged and still synchronous — reach for max only when a big job is worth the wait.

How to use it

It is part of the same Engine API you already call — same API key, same account, same deterministic contract. See the API reference for the engine list, the async job shape and the request and response, and the benchmarks for how we measure a plan against the theoretical minimum.

True-shape nesting was on the Engine API; now it is in the app. The optimizer gains a Nesting mode — a sub-tab under 2D, next to Panel — a genuinely different problem from the rectangular modes.

What it does

The 2D, 1D and Wood modes cut rectangles with a guillotine saw. Many jobs are not rectangles: a steel bracket, a triangular gusset, a gasket with a hole. Nesting mode packs parts by their real outline — arbitrary polygons interlock into each other’s concave pockets, so the empty air a bounding-box packer wastes is reclaimed. It is the mode for laser, plasma and waterjet cutting.

How to use it

• Import your outlines. Open the Nesting tab and click Import SVG/DXF — the app reads closed outlines from a DXF (with arcs flattened) or an SVG (paths, polygons, circles), and turns concentric outlines into holes. No file to hand? Click Demo.
• Add sheets — and exclusion zones. Add your stock sheet sizes, and on any sheet mark an exclusion zone the engine keeps every part off: a defect, a knot, a clamp footprint or a pre-printed area. This is something the rectangular modes cannot express.
• Run and export. The viewer shows every part on each sheet with the sheet count and the fill density. Export the layout as SVG, DXF, PDF or Excel from Downloads.

The honest metric

The result reports density — the placed polygon area over the used sheet area, with concave pockets counted as empty. Do not compare it to a 2D-panel yield: a bounding-box packer counts notch-air as solid and reads a higher number for a worse layout. The metric to compare on is sheet count on the same parts. The layout is deterministic, so a quote or a cut program built from a nest reproduces exactly.

See the Nesting guide for the full walkthrough.

The three optimization modes so far all cut rectangles. The Engine API now has a fourth mode for a genuinely different problem: true-shape nesting — packing arbitrary polygons onto fixed sheets, for laser, plasma and waterjet cutting.

What it does

POST /v1/optimize/nest takes parts as outlines (a polygon, with optional interior holes), not a width × height. Because it knows the real shape, parts interlock into each other’s concave pockets — the notch-air a bounding-box packer wastes is reclaimed. On a representative 272-part job it uses 6 sheets where the same parts fed to a rectangular packer by their bounding box need 9 — a third less material, from the shape alone.

It is a different class of engine (a geometric collision solver), so it runs alongside the rectangular modes rather than replacing them.

Two things the rectangular API couldn’t express

• Exclusion zones. Mark a region of a sheet as off-limits — a defect, a knot, a clamp footprint, a pre-printed area — with stock[].exclusions, and no part is placed there.
• True holes. A part with a cut-out is a real outline plus inner rings, not an approximation.

Material partition and the opaque meta passthrough work exactly as on the other modes, and the layout is deterministic: the same request always returns the same nest, so you can cache it, diff it and reproduce it.

Honest about the metric

Nesting reports sheet count, not a density percentage. A bounding-box packer counts the empty air inside each part’s rectangle as solid, so its “yield” reads higher for a worse result — the only cross-comparable number is how many sheets the same physical parts actually need.

How to use it

It’s part of the same Engine API you already call — same API key, same quota, same deterministic contract. See the API reference for the request and response shape, and the benchmarks for the measured result. True-shape nesting has since also come to the app itself, as a separate Nesting mode.

The furniture-template picker had four templates — TV stand, bookshelf, wardrobe and kitchen base cabinet. It now has a fifth: a box. It is the simplest of them, and the one people ask for most often: a storage box, a crate, a drawer box — or a cube.

What it does

You enter the outer width × height × depth and the board thickness, and choose whether the box is open or closed with a lid. The template returns the exact parts to cut, with the thickness already subtracted:

• Front and back — the two full width × height walls.
• Ends — the two side walls, sized to fit between the front and back.
• Base — sitting inside the four walls.
• Lid — added only when the box is closed.

Why a template, not mental arithmetic

Because a cube is not six identical squares. With butt joints, the walls overlap: on a cube the two front/back faces are the full size, the two ends are shorter by two board thicknesses, and the base and lid shorter on both sides. Cut six equal squares and the box will not assemble to the size you meant. Set width, height and depth equal and the template works the offsets out for you.

How to use it

In the app, click Furniture templates above the parts table, choose Box, enter your sizes, and insert — the parts drop straight into the cutting list, ready to optimize. It works on every plan.

See the furniture templates guide for the full walkthrough.

One for the people writing software against CutOptim. If you just cut in the app, nothing changed — this is all on the Engine API, and every existing call returns exactly what it did before.

Until now the Engine API was the one cutting API in the field that returned nothing but raw coordinates. Three things change that.

A drawing in the response, not just coordinates

Add an include array to any optimize request and the response carries the layout as a ready-made file, inline in the JSON — no storage, no second call:

POST /v1/optimize/2d
{ "parts": [...], "stock": [...], "include": ["svg", "csv", "dxf"] }

• svg — a self-contained 2D layout drawing you can render straight into a page or a PDF. (2D only; a 1D or wood request returns a warning instead.)
• dxf — an R12/AC1009 drawing on layers STOCK, PARTS and LABELS, ready for CAD or a CNC toolchain.
• csv — a plain cut list.

include still narrows the response too: its cutPlan and offcuts values trim those out. So ["svg"] adds svg and drops cutPlan/offcuts; ["cutPlan","offcuts","svg"] keeps everything and adds svg. Omit include and you get the default response, unchanged.

Your own identifiers, returned

Attach a meta object — an ERP article number, an order-line id, a customer reference — to any part or stock row, and it comes back verbatim on every placed piece and every sheet or bar:

{ "name": "Door", "w": 400, "h": 600, "qty": 2, "meta": { "sku": "D-400x600", "orderLine": 42 } }

It is never parsed and never affects the layout — it is there so the cut plan lines up with your own system without you having to match on names.

Validate for free, before you spend a call

Three new endpoints check a request without solving it:

POST /v1/validate/2d   ·   /v1/validate/1d   ·   /v1/validate/wood

They take the same body as the matching optimize endpoint, and they are free — no key, no quota. A malformed request comes back as a 400 naming the exact bad field; a well-formed one returns valid: true plus feasibility warnings, such as a part that fits no stock. You can validate your payloads while building the integration — before you even hold a key — and confirm a request will not be rejected without spending one of your monthly calls.

One correctness fix, for tidiness

On 1D and timber, a rod’s reported remaining (and its offcuts) is now the usable off-cut — the kerf of the cut that frees it is already deducted, so it is the reclaimable length rather than the raw gap. Yields, cut counts and prices are unchanged; only the reported leftover is a kerf smaller, and more honest.

With these, the OpenAPI document now describes eight endpoints, and the reference has the full request and response shapes.

Engine API reference · Tell us about your integration

Building a fence is a one-dimensional cutting job: posts, rails, and pickets, all cut to length from stock timber. Now CutOptim plans it for you.

The new fence template picker turns the three numbers you measure on site — run length, height, and post spacing — into the full cut list, and drops it straight into the 1D linear optimizer so you buy the fewest boards.

Three fence types

• Picket fence — vertical pickets on horizontal rails.
• Horizontal board fence — boards fixed straight to the posts.
• Post & rail fence — posts and through-rails, ranch style.

Pick one, enter your dimensions, and the tool lists every post, rail, and picket with its length and quantity. It counts the bays for you (rounding up for the short last bay), and — the part people forget — cuts each post to the height plus the length set in the ground, not just the fence height.

Two ways in

• On the new How to Build a Fence guide, an embedded widget builds the cut list and carries it into the app with one click.
• Inside the app, in the 1D linear parts section, a Fence templates button opens the same picker and inserts the pieces directly.

Fence templates are free on every plan, guests included. Set your fence up, run the optimizer, and read off exactly how much timber to buy.

We’ve retired feature-gating. The Free plan now includes the full Pro feature set — there is no longer a wall between “basic” and “pro” tools.

What Free now includes

Everything that used to require Pro is now free on every account:

• Off-cut inventory — save leftovers and reuse them automatically
• Material library and material-specific mode
• Cost mode — price per sheet and cost-minimizing optimization
• Exports: DXF, SVG and Excel (PDF and CSV were always free)
• Edge banding calculator, panel label printing
• Cutting sequence (step-by-step sawing plan) and calibration cut
• Company branding on PDFs and custom fields
• Share a plan by link

What Pro still adds

Just two things:

• Unlimited monthly runs. Free includes 3 optimizations per month; Pro removes that cap.
• Cloud project save. Saving your projects and cut layouts to the cloud — so they sync across devices and are waiting for you next time — stays a Pro feature. On Free you can use every tool; you just can’t save a project to the cloud.

If you cut occasionally, Free now gives you the complete toolset. If CutOptim becomes a weekly habit — or you want your work to persist across sessions — Pro is the upgrade.

Pay-as-you-go, without a subscription

Prefer not to subscribe? Pay-as-you-go credits buy extra runs once your 3 free monthly optimizations are used up — one credit covers one full job (no limit on parts), and each pack stays valid for 12 months. Every tool is already included on every run, so a credit is simply more runs, not a feature unlock. Good if you cut occasionally; the Pro subscription is the better value once CutOptim becomes a weekly habit.

Workshop is unchanged

The Workshop plan keeps its team and shop features — the quotation PDF, grain matching groups, a shared workspace for up to 3 people, and the machine controls (max cutting stages, rotation minimising) — and we’ll keep expanding it.

Nothing to switch on. Open the app and every tool is there.

CutOptim has always been able to optimize for the lowest total bill instead of the least material — but the goal selector was buried, and it only does anything once your stock has prices. Both were easy to miss. We’ve fixed that.

What changed

• The goal selector is promoted. Minimize waste (the default) and Minimize cost sit together in Settings, clearly labelled — both available on every plan, Free included.
• Choosing Minimize cost reveals the price columns automatically. The 💰 price column appears on the Stock and Parts tables the moment you pick the cost goal — no separate “Show price columns” step.
• A reminder when prices are missing. Minimize cost only changes the plan when your stocks have different unit prices. If you select it with none entered, CutOptim shows a one-off reminder to add them — it never blocks the run. Without prices, Minimize cost and Minimize waste produce the same plan, so your result is still correct either way.

Why it matters

Minimize cost lets you mix stock sizes to lower the bill — big parts on wide boards, small parts on cheaper narrow ones in 2D, or the cheapest bar length in 1D. It can even use a little more material to spend less; priority stars still win over price. This change is purely about making the goal easy to find and hard to trigger by accident — running the cost goal and expecting a different plan when there are no prices to optimize against.

Nothing to switch on — open Settings and the goal is right there.

We’re taking the CutOptim engine into a new domain: reinforcement steel.

The new Rebar Cutting & Bending Optimization API takes a bar bending schedule (BBS) plus your available stock and returns an optimized cutting plan, a bending schedule with cut lengths and weights, and an offcut inventory — deterministic and version-pinned, over a single REST call. It uses BS 8666:2020 shape codes with standard bending deductions.

As far as we can tell, no rebar-aware developer API exists today: generic cutting APIs know nothing about shape codes, bending deductions or machine formats, and rebar suites keep their optimizers locked inside desktop products. Optimized planning cuts steel waste from a typical 5–8% to 1–3% (published case studies report 0.9–1.5%).

It’s in development, and we’re validating it with a handful of design partners before we build the rebar layer. If your software lives in the rebar workflow — an ERP, an estimating tool, a detailing add-in or machine software — we’d love 20 minutes of your perspective. Get in touch.

Most jobs use more than one material at once. Until now, keeping them apart meant running the optimizer once per material and stitching the results together by hand. Material-specific mode does it in a single run.

Turn it on (the toggle in the Settings strip, a Pro feature), and every stock and part row gains a Material column. Tag each row, and the optimizer partitions the job by material: a part tagged “oak” is only cut from stock tagged “oak”, 18 mm only from 18 mm. It works in all three modes — 2D Panel, 1D Linear, and Wood.

What it does

• A hard partition, not a label. Tagging a material actually changes the layout — material X parts only use material X stock. That is different from naming or colouring a piece, which only affects how it reads on the diagram.
• “No matching material” instead of a wrong cut. If a part is tagged with a material you have no stock for, the plan says so, rather than quietly cutting it from another board.
• Wood tells species apart. Wood mode already separates by cross-section; with material on, an oak 50×50 and a pine 50×50 become separate sections too.
• The Material inventory now holds wood. Save sheet, bar and wood materials — each with a cross-section or size, a colour, and its own kerf and trim — and drop them onto a row with one click. Wood materials load into the Wood table (they used to land in the linear one).
• Also on the Engine API. All three endpoints accept an optional material string on parts and stock and return a per-material breakdown.

Material-specific mode is available on the Pro and Business plans. Leave it off and everything works exactly as before.

The edge banding by type update reported the linear metres you need to order. This one shows where the banding goes, piece by piece, and puts a picture of every sheet layout right inside the Excel workbook.

What’s new

• Banding on the Excel cut list. When a 2D job has edge banding, the Cut list tab gains four columns — Top, Right, Bottom, Left — naming the banding type on each edge (blank where an edge is not banded). Filter or sort the list by which edge gets which banding.
• A per-piece banding diagram in the PDF. The material-requirement page now draws each banded piece as a small figure with every edge coloured by its banding type, so the bench sees at a glance which edge of which piece gets which banding. It sits below the per-type “how much to order” table you already had.
• Layout diagrams in Excel. A new Layout tab embeds a picture of each distinct sheet layout — one image per sheet — so you can see how to cut the board without leaving the workbook. Identical layouts collapse to a single image with a ×N note, just like the PDF cutting plan. (2D jobs.)
• A real colour for each banding type. In the banding-type library the colour is now picked from a colour swatch instead of typed as text. That colour is what the new per-piece diagram uses to draw the type’s edges. Types you created before still get a stable, distinct colour automatically until you set one.

The banding diagram and columns appear only when a job actually has banding, so unbanded exports are unchanged. Everything here is on Pro (like the Excel and SVG exports), and banding is still metadata — it never changes the layout.

Have a feature request or hit a bug? Reply to any CutOptim email or use the contact form.

Edge banding used to be a simple on/off per edge. Now each edge can carry a banding type — a named reference you define once — and CutOptim totals the linear metres per type, so you order the right amount of each banding.

What’s new

• Per-edge type. In the EB dialog, each side (Top / Right / Bottom / Left) is now a dropdown: None, No type, or one of your saved types.
• A type library. Give each type a name (e.g. ABS oak 22×1), a thickness, a price per metre and a colour. Open it with Manage types in the EB dialog; your types sync across devices.
• Metres broken down by type. The optimization summary, the PDF material-requirement page and the Excel Materials tab now show a line per banding type plus an order total — exact geometry, no waste margin (add your own overage at the bench).
• CSV. The parts CSV EB column accepts typed codes: T:ABS oak 22;L:ABS white 22 assigns a type per side (or keep the old TRBL for untyped). Names resolve against your library.

Edge banding remains a Pro feature, and it’s still metadata — it never changes the layout.

For developers: on the Engine API too

The Engine API’s 2D endpoint now accepts per-edge banding. Each part in POST /v1/optimize/2d can carry an edgeBanding object naming a type reference per side; the response then returns an edgeBanding block with the linear metres per reference, per part and as an order total. It’s library-independent — send your own ERP codes. See the API reference. (1D and wood do not have edge banding.)

Have a feature request or hit a bug? Reply to any CutOptim email or use the contact form.

When you optimise with Minimize cost, the plan deliberately trades a little material for a lower invoice. Now your exported documents say so — in numbers.

What changed

The “How this was optimized” section of the PDF and Excel exports already named the optimisation goal. In cost mode it now adds one more line: how much this plan saves on the invoice compared with the least-material plan, and how much extra material that saving cost — in all three modes (panel, linear, wood).

So instead of wondering why a cost-optimised plan used an extra board or a longer bar, the reason is spelled out: “Cost mode: €X cheaper invoice than the least-material plan, using Y more material.” When cost mode happens to be cheaper and use less material, it simply says so.

Why it matters

A plan that spends more material to save money looks wrong at a glance — until you see the money it saved. Putting both halves of the trade-off in the deliverable means the shop, and the customer reading the quote, can see the decision was deliberate and worth it.

Nothing changes for Minimize waste. The explanation appears only in cost mode, only when prices are set, and only when a cheaper plan genuinely existed.

If you never touch it, nothing changes — the default is exactly today’s optimizer, giving the densest saw-cuttable plan. The new switch simply lets you trade a little of that density for a much faster solve when a job is large.

What it does

The 2D optimizer runs a multi-strategy search and keeps the best layout. Most of that search is cheap, but one step — a per-board re-search that squeezes out the last few percent on big, varied jobs — is expensive. The new Speed vs density setting lets you skip that one step:

• Balanced (default) — the full search, for the densest guillotine plan. Unchanged from before.
• Fast — skips the expensive step. Noticeably quicker on large jobs, for a few points less yield. Still fully saw-cuttable, and never denser than Balanced (it searches a subset of the same layouts).

On the small-to-medium jobs most people run, the two are usually identical — the difference only opens up on large jobs of several hundred parts.

Measured

On a demanding 1,550-part job (a 2.07 × 5.6 m board):

• Balanced: 330 boards, 80.8% yield.
• Fast: 350 boards, 76.2% yield — solved about 2.5× faster.

So Fast trades roughly 5.7% more material for a much shorter solve. Leave it on Balanced unless a very large job is slow and you want the speed.

Where to find it

• In the app: Advanced settings → Speed vs density. It’s a per-project setting, so it saves with the project like kerf and trim.
• On the Engine API: a new effort option on POST /v1/optimize/2d (values "fast" / "balanced", default "balanced" — omitting it is unchanged). See the API reference for the measured trade-off, drawn.

Have a feature request or hit a bug? Reply to any CutOptim email or use the contact form.

When you optimise with Minimize cost and your stock sizes have different unit prices, CutOptim now looks for the cheapest combination of those sizes — not just the single cheapest one.

What changed

The default goal, Minimize waste, picks the plan that uses the least material, and that is unchanged. Minimize cost (Pro) has a different job: get your total bill as low as possible. As of today it does that far better when you have several priced stock sizes:

• In 2D it mixes stock sizes on one job. Big parts go on wide, expensive boards; small parts go on cheaper, narrow ones — whichever split costs the least in total. Before, cost mode had to run the whole job on a single stock size.
• In 1D it picks the cheapest bar length, choosing a shorter, cheaper bar even when it means buying a few more.

Because cost mode optimises money, not material, the cheapest plan can use a little more material or more boards than the smallest-area plan — that is the point of the mode, and it is now stated clearly. It never leaves a part out to save money.

When it helps most

Shops that stock many board or bar sizes at different prices — especially with per-piece pricing — see the biggest saving, because that is exactly where mixing sizes beats using one size for everything. On our benchmark set of real cut lists, this closed most of the cost gap on the hardest multi-stock jobs.

Nothing changes for Minimize waste or for jobs with a single stock size. To use it, switch the optimisation goal to Minimize cost in Advanced settings (Pro), and make sure each stock row has its price.

CutOptim now speaks Croatian. Every part of the product — the app interface, all guides and calculators, the full app documentation and this what’s-new feed — is available in Croatian, served at cutoptim.com/hr and priced in euros.

This is a real translation, not a machine pass: written for a Croatian carpentry and panel-cutting audience, with the trade vocabulary a workshop actually uses — plan rezanja, ploča, žica, otpad, iskoristivost, kantiranje.

What is in Croatian

• The app — every button, setting and message in the optimizer.
• Calculators — all of them, from the board cutting calculator to the log yield calculator.
• Guides — the full library at /hr/vodici, from what a cut list is to how cutting optimization works.
• App documentation — every article at /hr/dokumentacija.

What has not changed

The optimizer, the algorithms and your data are exactly the same. Croatian is a new way in, not a different product. Prices are shown in euros, the currency the rest of the eurozone already sees.

Switch languages any time from the globe menu in the top bar. Have a feature request or spotted a translation that reads wrong? Reply to any CutOptim email or use the contact form.

When you enter more than one stock size — say a 1.5 × 5 m board and a 1.5 × 4 m board, or 6 m and 1.5 m bars — CutOptim now always picks the size that spends the least material for your parts.

What changed

The optimizer compares every stock size on its own as well as mixed together, and ranks the plans by total material used first: the total board area in 2D, the total bar length in 1D. The number of boards or bars is now only a tie-breaker.

Two things this fixes:

• Order no longer matters. The same job used to give a different plan depending on which stock row you listed first — one arrangement could quietly waste a third more material. Now you get the same, material-best plan either way.
• A big board no longer beats two small ones that hold less. The ranking used to prefer the plan with fewer boards, so a single large sheet could win over two small sheets that together used far less material. That is corrected.

The ★ star on a stock row still works — it just decides which size is consumed first, never whether a larger size wins over a materially cheaper one. In cost mode the optimizer still minimises total price, which may mean a cheaper size that is not the smallest.

Also: full precision in inch mode

Sizes in inch mode now keep their three decimals everywhere, including parts brought in from a furniture template — a value like 80.125 (an exact eighth of an inch) stays 80.125 in the tables, the results, the cut list and the exports. One template path used to round it to two decimals; that is fixed.

Nothing about your saved projects or your data changes — the optimizer simply chooses better when a job fits several stock sizes.

CutOptim now speaks Spanish. Every part of the product — the app interface, all guides and calculators, the full app documentation and this what’s-new feed — is available in Spanish (Spain), served at cutoptim.com/es and priced in euros.

This is a real translation, not a machine pass: written for a Spanish carpentry and panel-cutting audience, with the trade vocabulary a workshop actually uses — plan de corte, tablero, veta, merma, aprovechamiento, canteado.

What is in Spanish

• The app — every button, setting and message in the optimizer.
• Calculators — all of them, from the board cutting calculator to the log yield calculator.
• Guides — the full library at /es/guias, from what a cut list is to how cutting optimization works.
• App documentation — every article at /es/docs.

What has not changed

The optimizer, the algorithms and your data are exactly the same. Spanish is a new way in, not a different product. Prices are shown in euros, the currency the rest of the eurozone already sees.

Switch languages any time from the globe menu in the top bar. Have a feature request or spotted a translation that reads wrong? Reply to any CutOptim email or use the contact form.

CutOptim has always tried dozens of candidate layouts on every run and kept the best one. What it never told you is what that search is worth.

Now it does, in two places:

• In the result summary — when the optimized plan needs fewer sheets or bars than a simple layout of the same parts, the outcome line says so: how many boards fewer, how much material that is, and the money amount when your stock rows carry prices. The line carries into the PDF and Excel exports too.
• In the top bar — a running total of the material the optimizer has saved across your runs on this device.

Where the number comes from

The comparison is measured, not estimated. While searching, CutOptim computes a simple greedy layout as one of its candidates — the safety floor the final plan must beat or at least match. The meter reports what that simple layout would have consumed for the same parts, the same stock and the same settings, next to what the optimized plan actually uses. Three rules keep it honest:

• If the two plans did not place the same parts (this can happen with limited stock), no claim is made.
• If the simple layout was just as good, no line appears — a zero stays a zero.
• Demo runs never count toward your total.

On every plan

The meter is not a Free-plan teaser. On Free it shows what each of your monthly runs is worth; on Pro and Workshop it keeps counting, so the total answers a fair question: is the subscription paying for itself?

Have a feature request or hit a bug? Reply to any CutOptim email or use the contact form.

You measure the old kitchen, get 858 mm to the top of the worktop, and order the cabinet sides at 858 mm. They arrive edged and cut. Then the boxes go on their legs, the worktop drops on, and the working surface sits at 996 mm.

The new kitchen base cabinet template exists to stop that. It is the fourth furniture template, alongside the TV stand, bookshelf and wardrobe, and it is available in the app and on its own calculator page.

The plinth is not part of the carcass

The height you enter is the carcass height, and the plinth is a separate setting underneath it. Change the plinth and not one carcass part changes — which is exactly right, because the plinth is the thing you adjust once the boxes are standing on a floor that is not flat.

The widget shows the carcass top figure so you can check the sum before anything is cut:

worktop height = plinth + carcass + worktop thickness

The worktop itself is not in the cut list. It is a different material at a different thickness, usually bought cut to length, and mixing it into the board order would make both the area and the sheet count wrong.

Two rails, or a full top

A base cabinet under a worktop is normally closed with two rails rather than a panel: the worktop is already the top surface, and rails leave access for the fixing screws. You can pick either.

On the default 600 mm cabinet the difference is measured, not estimated: 2.03 m² of board with rails against 2.24 m² with a full top — 0.22 m² per cabinet. The rails are also hidden, so unlike a top panel their grain is free and the optimizer can drop them into leftover strips.

Kitchen fronts are overlay

A wardrobe door sits inside its opening. A kitchen door lies across the carcass face and covers the edges of the sides, so it comes out wider than the opening rather than narrower — 597 mm on a 600 mm cabinet.

The template sizes fronts the way kitchen fronts are actually built. Built to the inset size instead, the same door would be 558 mm: 39 mm narrower, on boards that are already edged and bored by the time anyone notices.

What it does not do

A door over a stack of drawers needs the opening split horizontally first, and the model works with one opening per compartment — so it asks you to pick one and generate the two halves separately. Drawer boxes and hinge borings stay out too, because both depend on the hardware you buy.

Full details in Furniture templates, or try it on the base cabinet cut list calculator.

Showing someone a plan used to mean exporting a PDF and attaching it to an email. Now there is a link.

Open the Projects panel, find the cut, click 🔗. The address lands on your clipboard — paste it into an email, a message, or a work order. Whoever opens it sees the plan: the summary figures and the layout diagrams, read-only, with nothing installed and no account.

It stays yours

The page shows the plan and nothing else about you — not your other projects, not your account, not your customers. It is marked noindex, so search engines are told not to list it. A shared link is unlisted, not published.

Links last 90 days. That is deliberate rather than arbitrary: a plan has to survive the real timeline of a job, but a public address to somebody’s part list should not live forever.

You can always see what is out there

Your dashboard has a Shared plans section: every live link, the cut it points at, when it expires, how many times it has been opened, and a Revoke button that takes effect immediately.

Sharing the same cut twice gives you the same link rather than a second one, so there is never an address in circulation that you cannot see and switch off.

A revoked link explains itself

If you revoke a link — or it simply expires — the page does not show an error. It says the plan is no longer shared and suggests asking you for a new one. That matters more than it sounds: the address may have been printed on a plan taped to a workshop wall months earlier, and a dead page there reads as broken software rather than an expired link.

Full details in Sharing a plan by link.

Sharing is a Pro feature. Opening a shared link never requires a plan — or even an account.

Marking which edges of a part need banding has worked for a long time. What was missing was the number you actually take to the supplier: how many metres.

It is there now, in three places:

• in the results summary, next to the sawn length;
• at the foot of the material requirement page in the PDF;
• on the Materials tab of the Excel export.

It appears only when at least one part has edges marked, so nothing changes for jobs without banding.

Four things the number does and does not say

Top and bottom follow the part’s width, left and right follow its height. A 800 × 300 shelf banded top and bottom needs 2 × 800 mm per piece, not 2 × 300.

It is exact geometry, with no waste allowance. Real banding is bought with overlap and trimmed back, and every shop’s margin is different — so we give you the true figure and let you add yours. We would rather hand you a number you can reason about than one with an invented percentage baked in.

It is a single total, not a breakdown per banding material. The marking records which edges, not which banding type, thickness or colour, so a per-material split is not something we can produce from it.

It counts the whole parts list. If some pieces did not fit on this run, their edging is still in the figure — they will need it once you have more material.

Available in 2D panel mode, on the Pro and Workshop plans, like the edge marking itself.

Again one for the people writing software against CutOptim. If you just cut in the app, nothing changed — the wood mode in the app works exactly as before, and this adds nothing you have to learn.

The Engine API shipped with two of the three modes the app has: panels and linear material. Timber — where the material has a cross-section — is now the third, in one call:

POST /v1/optimize/wood

Why it needed its own endpoint

Linear material knows one dimension, its length, so any bar can serve any part. Timber does not work that way: a 50×150 part cannot come out of a 50×100 bar, however much length is left in it.

So parts and stock both carry the two cross-section sides, the job is split by cross-section, each section is matched to its own stock and solved separately, and every section comes back with its own bars and its own totals next to the figures for the whole job.

Two things worth knowing before you wire it up:

• The two cross-section sides can be sent in either order. 50×100 and 100×50 are the same bar turned over, so they land in one section. However your data happens to be entered, material cannot disappear because of it.
• “No stock of this cross-section” and “did not fit” come back separately. The first is missing material, the second is a capacity problem, and they are fixed differently — merged into one list they would send your user looking in the wrong place.

What it replaces

You could already approximate this by grouping the parts yourself and firing one /v1/optimize/1d call per cross-section. That costs one request from your quota per section instead of one for the job, puts the stock matching in your code, and leaves you to assemble a job total by hand — one that would not necessarily agree with what the CutOptim app shows for the same job.

It now agrees, and we checked it rather than assuming: the app’s own wood demo job returns 81.0% yield across 10 bars, 19 of 19 parts, 19 cuts on screen, and the API returns the same plan bar for bar.

Speed

Measured on the same machine the API runs on: a 40-part job solves in 4.4 ms, and the worst case we could construct — 2,000 parts spread over 20 cross-sections — takes 451 ms. Every call stays synchronous: you send the job, you get the finished plan back, there is nothing to poll.

The API reference has the exact request and response shape, and the OpenAPI document now describes five endpoints instead of four, so a regenerated client picks the new one up on its own.

Have a feature request or hit a bug? Reply to any CutOptim email or use the contact form.

If you cut panels, nothing changed. This one is about linear material — bars, tubes, profiles — and timber.

CutOptim tries several strategies on every job and keeps the best plan. One of them is an exact combination search: which parts fill this bar with nothing left over? That is the strategy that drives the offcut to zero.

On jobs above 150 parts, it was switched off.

Why it was off, and why that was the wrong call

It was there as a speed guard, and the guard measured the wrong thing. The real cost of that search is driven by the length of the bar, not the number of parts: the same 501-part job takes 58 ms on a 1 m bar and around a second on a 10 m one. Counting parts meant the cheap case got skipped, while the expensive one would have been let through.

So above 150 parts the plan fell back to the coarser “fill them in order” strategies. Measured against our live API on a 501-part benchmark job whose optimum is known: it used 195 bars where 167 were provably enough.

What changed

The guard now measures the actual computation instead of counting parts. The combination search runs whenever it can afford to, which on ordinary bar lengths is nearly always.

The same job now comes back at 171 bars.

What you can expect

Honestly, it depends on the job:

• Jobs where parts combine to fill a bar exactly — cut-to-length production, framing, repeated assemblies — change the most. Those are what the old fallback handled worst.
• Small and medium jobs, up to about 150 parts, are unchanged. They were already running the full search.
• Jobs with very varied lengths change little. There is not much exact combination to find in the first place.

Across published academic benchmark instances, the average distance from the theoretical optimum on linear jobs fell from 4.9% to 2.3%. We are not going to put a percentage on your job — the only number that means anything is the one your own material list produces, and it is free to run it twice and compare.

The cost

Large jobs take longer to compute. The slowest linear job we could construct now takes about 0.44 s, and the slowest timber job about 0.5 s, where both used to be a few milliseconds. Anything under roughly 400 parts is unaffected either way.

Panel (2D) cutting is untouched, and we verified that rather than assuming it: every layout in our panel regression set comes back identical to the byte.

Have a feature request or hit a bug? Reply to any CutOptim email or use the contact form.

Two things happened, and the second one matters more than the first.

We published a benchmark

cutoptim.com/benchmarks is now live. For every job in a set of published academic test instances it computes a lower bound — a number of sheets or bars that no cutting plan can go below — and reports how far CutOptim’s plan is from it. If a plan matches the bound, it is provably optimal for that job; no better one exists.

Every job is listed. The raw results are downloadable. The instance sources are pinned by SHA-256 so a re-run can prove it measured the same bytes, and the whole thing is reproducible from our repository with two commands.

The page also states what the numbers do not say, because that seemed more useful than only showing the flattering half:

• our bound is not the strongest one in the literature, so the gap we report is an upper estimate — a job we mark “not on the bound” may actually be optimal, and we simply cannot prove it;
• relative gaps exaggerate on small jobs, so the absolute figure (sheets over the minimum) is the honest column;
• two of the generated test families are adversarial by construction — a ceiling test, not a picture of typical work.

We removed a number we should never have printed

Until today this site said CutOptim “typically reaches 88–96% material yield”, in the glossary, in the FAQ and on a feature card, in all eight languages.

Nobody had measured it.

When we finally did, the median on those academic instances came out well below it. Those instances are harder than a typical furniture job — their part sizes are random rather than repeated — so it is not that the software is worse than we thought. It is that we were quoting a number we had no basis for, and a customer comparing quotes deserves better than that.

So the claim is gone everywhere, and nothing replaced it with a friendlier range. What replaced it is the measurement, plus an honest sentence: how much of a sheet gets used depends on your piece mix, your stock sizes and your blade — and the only number that means anything is the one your own material list produces.

There is now an automated check in our build that fails if a yield percentage creeps back into the marketing copy in any of the eight languages. We removed this claim in three passes because each attempt missed a family of it; a cleanup that needs three attempts will be undone by the next edit unless something is watching.

Have a feature request or hit a bug? Reply to any CutOptim email or use the contact form.

This one is for a particular reader, so let us say who up front. If you write software — or you pay someone who does — you can now call CutOptim’s cutting engine directly from your ERP, your quoting tool or a machine’s own software, instead of having someone re-type a cut list into a browser. If you just cut panels, nothing changes for you. The app works exactly as before, and the Free, Pro and Workshop plans still include the optimizer.

What it does

Send parts and stock as JSON to https://api.cutoptim.com and the whole result comes back: every part placed with its coordinates, the guillotine cut plan, and the metrics — sheet count, yield %, cut lines, saw passes, sawn length and total price. Same engine, same numbers as the app.

Five endpoints, and that is the entire surface:

• POST /v1/optimize/2d — panels
• POST /v1/optimize/1d — bars, profiles, tube
• POST /v1/optimize/wood — timber, matched by cross-section (added 2026-08-03)
• GET /v1/usage — what this key has used this month
• GET /v1/health — whether it is up

Authentication is one header: Authorization: Bearer <key>.

The same input always gives the same answer

The engine is deterministic: no randomness, no clock in the algorithm. Send the same job twice and the layout comes back identical, down to the coordinates. So you can cache a result, and you can put a known job in a test and diff the output — which an optimizer that wanders a little on every run cannot support.

Two engines, and an honest trade-off

heuristic is the default, the same guillotine packer the app runs: highest yield, every layout cuttable edge to edge on a panel saw, always a full cut plan.

balanced is opt-in. A MaxRects free-nesting packer, measured about 25× faster on a 2,000-part job — but the yield is slightly lower, and its layouts are often not guillotine-cuttable, so it returns no cut plan. That is a speed and producibility trade-off, not a better result. Use it when a big job needs an answer fast; stay on the default when someone actually has to cut the sheet.

Limits, price, and how to get in

2,000 parts per request, 50 stock rows, 1 MB of request body. €49 per month for 10,000 requests, billed in EUR, with a 14-day trial. The 10,000 is a hard cap, not a starting point: once reached, calls stop until the month rolls over. No overage, no surprise bill.

You can subscribe on the Engine API page — it runs a trial period, and access lands on your account by itself. If you would rather describe what you are building first, the contact form is the other way in. An API keys card then appears on your dashboard: you create keys there, each one is shown exactly once (only a hash is stored, so it can never be fetched again), and its usage against the quota sits on the same card.

The rest is written down: Engine API for the overview and pricing, the API reference for every field, option, error code and both engines.

Have a feature request or hit a bug? Reply to any CutOptim email or use the contact form.

A cutting plan tells you where the parts sit. It never told you what the day at the saw looks like: how many times you set the fence, how far the blade travels, what to cut first. This update answers all three — and turns the plan into an ordered list of stop positions you can work down.

How many cuts, and how far the blade travels

Two numbers now sit in the results header of every job, on every plan, guests included.

• Cuts counts fence settings. Cutting the same measurement across three strips is one setting, so it counts once — because that is one setup at the machine.
• Saw passes appears under it whenever the two differ, and counts every strip crossed separately. That is the number blade wear and per-cut charges follow.
• Cut length is the total distance sawn — metres in mm mode, feet in inch mode. It is the same figure under either counting convention.

Neither number is the “right” one; they answer different questions. How many times do I set the fence? and how many times does the blade go through material? Quoting a job needs both.

On our standard 40-part demo job (2440 × 1220 sheets, 3 mm kerf) the plan comes out at 30 cuts, 52 saw passes and 32.88 m of sawing across 2 sheets at 83.3% yield.

Trim each edge separately

Trim per side replaces the single trim value in 2D: separate left, right, top and bottom inputs. Available on every plan, guests included.

This is not a refinement, it is a correction. A damaged or out-of-square edge needs more than the others, and trimming all four the same does not give you a slightly worse plan — it gives you a wrong one: too little on the bad edge and your first part carries the defect, too much everywhere else and you have paid for material you never had to lose.

In 1D and Wood a bar has two ends, so the Start trim / End trim pair is shown instead.

The sawing plan — now on bars as well as sheets

The Cutting Sequence used to be a 2D feature. It now runs in 2D Panel, 1D Linear and Wood, on the Pro plan.

On a sheet the plan walks the board down stage by stage: one step per fence setting, with the cut direction and the position, so a cross-cut is never asked for before its strip has been ripped off.

On a bar there is no cut tree — the timber is crossed end to end — so the plan is the running offset: after each part the blade drops at that mark, then advances by the kerf. Each bar reads as the calibration skim (if switched on), then the start-trim head cut (if set), then one step after each part, except a last part that finishes flush with the usable end when there is nothing to trim off it.

Every step gives a stop position measured from the head of the bar. That is the point: a number you can set on a stop, instead of adding part lengths and kerfs in your head twenty times down a six-metre length.

Two ways to use it:

• The player now sits directly above the sheet or bar diagrams it steps through, rather than at the top of the results. Controls are ◀ Previous, the step readout, ▶ Next, the new ⏮ Restart, and ▶ Play. Restart pauses playback and takes you back to step 1 — for the second board, or the second run of a job.
• The table below the cut list is the whole plan on one screen: the order, the sheet or bar, the direction or the part, and the position. Click any row and the player jumps to that step, with the row highlighted. It is what gets read before starting, and what gets screenshotted and sent to the saw.

One honest limit: 1D Linear reports positions but no cut length, because linear stock carries no cross-section for the blade to cross. Wood mode does know the section, so it reports a sawn length there. We would rather leave a figure out than invent one.

The calibration cut, on bars too

The calibration cut skims a thin strip off the material before any part is cut. You measure the strip, compare it with what you asked for, and correct the fence or stop by the difference — so the first real part is already accurate, instead of being the one you sacrifice to find out the setup was off. It is a Pro feature.

It now runs in every mode. On a sheet you pick which of the four edges is skimmed. On a bar the skim always comes off the head, and the side picker is hidden — a bar has one head, and offering four edges would be a control the plan could not honour.

It rides on the start trim: the material reserved at the head is start trim plus calibration. With both set, the head is crossed twice — once for the strip you measure, once to take the rest of the trim off — and the sawing plan lists both passes, in that order.

Two controls that describe your machine

Both are 2D, and both are on the Workshop plan.

• Max. cutting stages. A stage is a run of parallel cuts between two turns of the material — which is exactly how panel saws are specified, as 2-, 3- or 4-stage machines. Tell CutOptim what yours allows and the plan respects it where the job permits — and where a job cannot be sawn within the limit, it warns you instead of handing back an unsawable plan. All without giving away yield or a board.
• Minimise rotation. Prefers layouts that turn fewer parts, but only when that costs no extra sheet. A sheet is money, a rotation is seconds, so yield is never traded for it.

If a limit cannot be met, you still get the plan. The optimizer returns it and warns which boards need extra setups at the saw — a usable plan with a caveat, never an error.

In the PDF and in Excel

• A Sawing plan page in the PDF, on its own page, in all three modes. On a sheet: board, stage, direction, position and cut length. On a bar: bar, the part the cut frees, and the stop position. The counting convention is printed under the title, and a framed strip of key figures — cuts, saw passes, cut length, stages — sits under the table. Pro.
• A Cutting Sequence tab in the Excel workbook, inserted straight after the Cut list, because it is what the operator works from. The totals are repeated at the bottom, so the tab stands alone when it is the only page taken to the saw. Pro.
• Sheet layouts at full size. In 2D, every board is now repeated on its own landscape page at the back of the PDF, drawn as large as the paper allows. Inline in the portrait flow a 2800 × 2070 board printed at roughly 1:16 — fine as a picture, useless to work from. A landscape page gives about three times the area, and keeps the reading part of the document continuous instead of interleaved with full-page artwork.
• The waste list says whether a leftover is worth keeping. It now starts on its own page and carries a Reusable column, Yes or No, with the keepers listed first — and a line under the table stating the rule in your own numbers: in 2D both sides must clear your minimum offcut size (a long thin strip is not useful), in 1D and Wood the leftover length must clear it.

What’s next

Off-cut auto-include and assembly groups are still on the list, along with a dedicated place for the sawing plan in the label and quotation exports.

Have a feature request or hit a bug? Reply to any CutOptim email or use the contact form.

Two things in this update were wrong, and one of them was costing paying customers something they had already bought. That one comes first, along with the feature it was holding up.

Your Workshop seats now grant Workshop

If you are on the Workshop plan and added colleagues under Team management, they were not getting the plan you were paying for. An invited member was treated as a free user at every check: three optimizations a month, room for a single saved project, and none of the Pro or Workshop exports. You paid for three seats and two of the three people on them had a free account.

That was a bug, not a policy. An invited member now gets the plan the owner is paying for, everywhere the plan is read.

There is nothing for you to do. No re-inviting, no re-saving, no setting to switch on — the colleagues already in your organization pick it up on their own. And it only ever lifts: a member who has their own Pro subscription is raised to Workshop while the seat covers them, never dropped. If the Workshop subscription lapses, the seat stops granting anything and each person falls back to the plan they hold themselves.

And the workspace those seats sit in is now genuinely shared

The other half of the same story. Until now the three of you had three private project lists, which made “shared workspace” a roster and not much else.

A project saved by any member while they are in the organization now belongs to the organization. Everyone sees it, opens it, renames it, and adds and edits the cuts inside it — including the per-sheet progress markers, which is the part that actually earns its keep: it is what stops two people cutting the same board twice.

Two limits, stated plainly rather than buried:

• Nothing was shared retroactively. Projects saved before this update stay personal and stay invisible to your colleagues. If you are wondering whether your old quotes just became visible to your employees — they did not. Only newly saved projects join the organization.
• Deleting stays with the owner. A member can edit a colleague’s project but cannot remove it. In the projects panel a colleague’s project carries a 👥 marker and has no delete button.

Full detail on the Team Workspace page.

“Too large for your sheets” no longer says that about a part that simply cannot turn

Reported by a user: a 2440 × 1220 board in stock, and the result said 550 × 1964 — too large for your stock sheets, with advice to add a bigger format or split the part. Turn that piece and it fits with room to spare.

The packer was right that the piece could not be placed — the Rot. box on that row was unticked, so it was only allowed to go on upright, and upright it does not fit. The message and the advice were the wrong ones. They would have sent someone to the merchant for a board already leaning against their wall.

The two cases are now told apart. A part that fails upright but fits turned is reported as would fit rotated, but Rot. is switched off, and the hint names the Rot. column and the row to tick in the Parts (2D) table. It also says to leave it off if the grain direction is why the part was locked — that is a legitimate choice, not a mistake to correct. Parts that really are bigger than your biggest sheet keep the old message and the old advice, which are right for them.

The PDF carries the new wording too, since the printed plan is the one that reaches the merchant.

1D Linear can tell you the sawn length — if you tell it the profile width

Linear stock is a length and nothing else. There is no section for the blade to cross, so the sawing plan could give you stop positions but never a sawn distance — and we would rather leave a figure out than invent one.

So instead of a guess, there is now an input. Profile width sits in Advanced settings and appears only in 1D Linear: the width of the material the blade crosses on one cut. Fill it in and Cut length joins the results header and the summary, and appears on the sawing-plan page of the PDF and in its Cutting Sequence tab in Excel.

Leave it at 0 and nothing changes — positions, no length, exactly as before. That default is deliberate: a job that never says what section it is cutting still gets no number rather than a plausible one.

Wood mode already knows its cross-section per material and never shows the field. For a job that mixes several sections, Wood mode is the answer — it tracks them material by material.

The sawing plan in the PDF and the Excel tab are Pro features; the Cut length figure on screen is not.

Materials remember the blade and trim they are cut with

Kerf and edge trim belong to the material, not to the job. The 3.2 mm blade belongs to the 18 mm board; the 12 mm trim belongs to the rough-edged plank. Until now you dialled them in again for every material, and forgetting produced a plan that only turned out to be wrong at the saw.

A material in your Material inventory now carries its own Blade kerf and trim — a sheet stores four edges, a bar stores its two ends.

• Nothing new to fill in. Whatever you have set is what gets saved with the material, on the same Save current and Add buttons you already use.
• You can see what it holds. The material row shows a small settings badge with the kerf and trim it carries, so the capture is visible rather than magic.
• Loading it says what moved. Load the material and those values go back into Settings, and the confirmation names the fields that actually changed. A setting that moves itself without telling you is worse than one you set by hand.

A material you saved before this update carries nothing, and loading it changes nothing. It will not quietly reset the kerf and trim you have dialled in for the job in front of you. Empty is not zero here: empty means the material says nothing about it, while 0 is a real answer meaning no trim.

Material inventory is a Pro feature.

What’s next

Both halves of the team gap are closed with this update — the seats grant the plan, and the projects are shared. Assembly groups are still on the list.

Have a feature request or hit a bug? Reply to any CutOptim email or use the contact form.

The cheapest board is the one you already own. This update makes CutOptim reach for your saved leftovers before it opens anything new — and then tells you, in plain terms, what you actually have to buy.

Automatic off-cut reuse

With Use off-cuts automatically switched on — it is on by default — every optimization now runs in two passes. First it packs your parts onto the off-cuts already in your Offcut Inventory, then it sends whatever is left to the normal optimizer on new stock.

• All three modes. 2D panels, 1D linear and wood profiles.
• Each piece is used at most once. Off-cuts are never cloned the way a stock format can be, because there is only one of each on your rack.
• The plan names them. A sheet or bar that came from your inventory is marked ♻ and carries the name you gave it, so the person at the saw knows to fetch it rather than open a new board.
• The results tell you what it saved. How many off-cuts were used, how much material that is, and — when the job is small enough to check — how many fewer new sheets or bars you needed.
• Your inventory stays honest. Saving the run deducts what it consumed: a fully used off-cut leaves the list, a partly used one is replaced by its remainder.

Turn the checkbox off for a new-stock-only run — useful when you are quoting fresh material and do not want leftovers folded into the price.

Off-cut inventory is a Pro feature.

A material requirements summary you can shop from

Every result now carries a Material requirements summary, in all three modes, right before the cut list. It answers the one question you ask before starting: what do I have to buy?

It splits the job in two:

• New stock — what you still need to purchase, by size, with quantity and total area or length.
• Re-used off-cuts — what you already own, with a line telling you how many pieces to pull off the rack before you start.

The same split appears in the PDF and in the Excel workbook, so the merchant and the workshop are reading the same numbers.

Quotations that bill the finished piece

The quotation now offers two pricing modes. Margin on cost bills the boards the job consumed, as before. Product prices bills the finished pieces instead, at the selling price you set per part — the way most workshops actually quote a kitchen.

Alongside it: customer details, a tax rate, a validity date, a labour line and an optional per-cut charge. Your margin is folded into the unit prices rather than printed as a line, so the customer sees a clean document. If you want the margin spelled out, switch the document dropdown to Internal report — that one shows cost, revenue and gross margin, and never leaves your desk.

Quotations and the internal report are Business features.

Grain matching now shapes the layout

Grain matching groups no longer just record an intention. Grouped panels are held together on one sheet where the packer can manage it, their rotation is locked so the grain runs the same way, and they are kept out of the off-cut pass so a matched set never ends up split between a leftover and a new board. If a group genuinely cannot fit on one sheet, the result says so rather than silently splitting it.

Grain matching is a Business feature and applies to 2D panel mode.

Prices where you need them

• Cost and selling price columns on the stock and parts tables, revealed by the Show price columns checkbox.
• They travel with your data. Both columns are in the CSV templates, the CSV import and the Excel paste, so a priced cut list survives a round trip through a spreadsheet.
• Material inventory now stores price and thickness alongside the size, and rows load into the job with one click.

Price columns and the material inventory are Pro features.

Exports

• Cover page in every mode. Previously only wood plans got one. It now leads 2D and linear plans too, and lists the cut count alongside yield, sheets and waste.
• Identical sheets are merged. A job that is twenty copies of one layout used to print twenty near-identical pages; 2D now collapses them into one diagram with a repeat: N× badge, as 1D has done for a while. The cut list gained the matching column.
• Wood plans are grouped by material. One section per stock item and one per re-used off-cut, instead of everything under a single heading.
• Names throughout. 2D stock rows can be named, and those names now appear on the sheet headers, in the Excel materials and waste tabs, and in the DXF.

Fixes worth knowing about

• Excel’s separator. CSV import now detects comma, semicolon or tab from the file itself. If you are on a European Windows locale, where Excel writes semicolons, your file imports as it is.
• Selling prices no longer default to 1. Clearing the cell used to store 1, so a part you deliberately left unpriced was quoted at one unit each — and slipped past the “items with no price” warning.
• Pasting wood from Excel. The header row the paste hint itself suggests was being misread and the whole paste rejected. Both it and a related column-shift on blank cells are fixed.

What’s next

Closing the gaps in the Business team workspace: a shared project library, and members inheriting the owner’s plan.

Have a feature request or hit a bug? Reply to any CutOptim email or use the contact form.

Better cut plans mean less wasted material and fewer boards bought. This update rebuilds the engine behind linear and wood cutting, packs 2D sheets more tightly, and makes sure the PDF tells the whole story.

Smarter linear and wood cutting

• Several strategies, best result wins. The linear and wood optimizer now runs multiple packing strategies for each job and keeps the one that uses the least material — instead of relying on a single approach.
• Strong on repetitive jobs. For orders with many identical pieces, a new pattern-based method finds near-optimal layouts that were previously out of reach.
• The same job, fewer offcuts. In practice this means shorter bars and boards left over, and often one less length to buy.

Fuller sheets in 2D

• No more wasted edges. The 2D packer now fills in pieces that span the full width or full height of a sheet, using space along the edges that used to go to waste.
• A real example. A layout that previously needed two sheets — each barely half used — now fits on a single sheet at 94% utilisation.

Nothing gets lost in the PDF

• Every part accounted for. If a piece doesn’t fit or you run short of stock, the exported PDF now lists it clearly in all three modes (2D, linear and wood), so nothing quietly disappears between the screen and the workshop.
• Faster, more private exports. PDF generation is now fully self-hosted — no third-party CDN — so exports are quicker and load nothing from outside CutOptim.

What’s next

Off-cut auto-include and assembly groups are next on the list.

Have a feature request or hit a bug? Reply to any CutOptim email or use the contact form.

Sometimes you just want a quick answer without digging through the docs. CutOptim now has a built-in assistant that can explain features, clarify pricing and point you to the right guide — right where you are, in your language.

Ask anything, in your language

• Available where you need it. A small chat bubble sits in the corner of the marketing pages, the documentation and inside the app. Open it, ask a question, and get a straight answer.
• Speaks all eight CutOptim languages. Ask in English, Hungarian, German, Italian, French, Romanian, Polish or Czech — the assistant replies in the same language.
• Points you to the source. Answers link to the relevant guide or doc page, so you can read the full details when you want them.

Grounded and honest by design

• Answers from the real documentation. The assistant is grounded in CutOptim’s own guides, pricing and help articles — it doesn’t make up features that don’t exist, and it declines questions that aren’t about CutOptim.
• It doesn’t see your project data. The helper answers general “how do I…” and “what does this do…” questions. It has no access to your saved projects or cut lists.
• A human is one click away. If the assistant can’t help, it offers a direct link to reach a real person, and each answer has a quick 👍 / 👎 so you can tell us what landed.

On your terms

• Keeps its place as you browse. Your conversation carries over from page to page, so you don’t lose the thread.
• Hide it whenever you like. A toggle in your dashboard — and a “don’t show again” link in the widget — keeps it out of the way if you’d rather work in silence.

What’s next

A data-aware in-app helper that can reason about your actual cut list is on the roadmap.

Have a feature request or hit a bug? Reply to any CutOptim email or use the contact form.

This update is about staying in control when material is tight. A new Limited stock mode treats your quantities as a hard limit and mixes the formats you actually own, and Priority pieces let you guarantee the cuts you can’t afford to drop. Both work across 2D panels, linear and wood — alongside editable piece colours and clearer PDFs.

Limited stock, honest plans

By default, CutOptim assumes you can get as many boards as a plan needs. Now you can tell it what’s really on your shelf.

• Switch supply to Limited. A new Unlimited | Limited toggle sits in the stock section, in every mode. In Limited mode, the quantities you enter become a hard cap.
• Your real formats, mixed for you. Instead of leaning on the single biggest format, the optimizer combines the sheet and bar sizes you actually stock to fit as much as possible — and shows the exact breakdown of formats used.
• An honest shortage notice. If you run short, a clear “Not enough stock” panel lists what’s missing, and separates a part that’s simply too big for any format from stock you’ve genuinely run out of — so you know whether to buy more or rethink the part.

Priority cuts come first

When not everything fits, you decide what’s guaranteed — not the algorithm.

• Flag the must-haves with ⚑. In Limited mode, a priority (⚑) column appears in the parts table. Mark the pieces that absolutely have to be cut for this order.
• Priority pieces get first pick of the material, so the urgent parts are cut and low-priority filler is what drops.
• A clear result. A green ✓ confirms every priority piece was cut, or a red ⚠ tells you exactly how many didn’t fit — in 2D, linear and wood alike.

Your colours, clearer PDFs

• Editable piece colours in every mode. Each part now has its own colour picker — including linear cutting, which never had one. Your colours flow through the on-screen diagram, the legend and every export.
• Priority pieces stand out in the PDF. Must-cut parts get a clear (!) marker and a footnote in the cut list, plus a dedicated “Priority pieces” block right under the optimization summary — so whoever’s at the saw sees what matters first.

What’s next

Off-cut auto-include and assembly groups are next on the list.

Have a feature request or hit a bug? Reply to any CutOptim email or use the contact form.

This batch is more than polish. Imperial units arrive across the entire app, the 2D panel optimizer was rebuilt to waste less material, it now tells you when something doesn’t fit, and your unsaved work is protected from accidental loss.

Work in millimetres — or inches

CutOptim now speaks imperial as fluently as metric.

• A simple mm / in switch sits right in the Settings row. Flip it and every measurement converts instantly — no need to re-enter your numbers.
• Your choice is remembered on this device and on your account, so it carries across sessions and computers.
• Every export is unit-aware. PDF cutting plans, CSV, DXF (with the correct $INSUNITS flag for CAD), labels and quotations all print in your chosen unit; 2D waste is shown in ft² in imperial mode.
• Sensible imperial defaults. The demo data and starting values use round imperial sizes (96×48 sheet, 2×4 lumber) instead of awkward conversions, and each saved cut shows a small mm / in badge.
• Switching units never re-runs the optimizer, so it won’t cost you a quota.

A smarter 2D panel optimizer

The 2D panel packer was rebuilt around how sheets are actually cut, and it wastes noticeably less material.

• More on fewer sheets. A real job that used to spill across two sheets at 39% now fits on a single sheet at 77%. The new shelf/column packer keeps clean rows of same-width parts together, the way a real cut does.
• It tries every stock format. If you stock more than one sheet size, the optimizer now compares running the job on each format and keeps the best result, instead of using them in the order you listed.
• Tighter packing on hard jobs. A new “gap-reclaiming” strategy recovers the strip above a short part, so awkward mixes leave less offcut.
• “First cut direction” now works in 2D. Choosing a horizontal or vertical first cut finally changes the layout the way you’d expect.

2D now tells you what didn’t fit

Previously, if a panel was too large or you ran short on sheets, it just quietly disappeared from the plan. Now you get an honest answer:

• A red “unplaced panels” notice lists any part that is too big for any sheet you stock, with its name and size.
• A yellow “not enough stock” notice tells you, per format, how many sheets the plan needs versus how many you have on hand — so you know exactly how many more to buy.
• The piece count turns red whenever not everything was placed, so a short plan can’t slip by unnoticed.

Never lose an unsaved optimization

Running an optimization and then navigating away used to throw the result away. Not anymore.

• A save prompt appears before you leave a page (or switch modes) with unsaved results, so you can keep your work with one click.
• Automatic draft restore brings your last run back when you return — without spending another optimization.
• A proper save-destination picker lets you choose the project, and either overwrite the loaded cut or save it as a new one (like “Save” vs “Save as”).
• Cut names are now unique within a project, and deletions use a clear in-app confirmation dialog instead of a browser pop-up.

What’s next

Off-cut auto-include and assembly groups (Feature Pack 2 Phase 2) are next, along with an optional “use only the stock I have” mode for 2D.

Have a feature request or hit a bug? Reply to any CutOptim email or use the contact form.

This update is all about polish: the documents you print and the tables you read on screen now look the way they should.

Print-friendly PDF exports

We audited every PDF the app produces — the 2D / 1D / wood cutting plans, panel labels and the quotation — against typography and print best practices:

• Readable everywhere. No more sub-6 pt micro-text; diagram labels now use a dark, high-contrast colour instead of the piece’s own (sometimes pale) hue, so part names stay legible on any colour.
• Print-friendly contrast. Section headers and the footer were darkened to clear accessibility contrast ratios — easier on the eyes and on the toner.

Roomier, well-paginated 1D plans

The 1D plans (linear and wood) got the biggest cleanup:

• Breathing room between each bar diagram and the cut list below it — no more text glued to the bar.
• Larger fonts throughout the diagrams, tables and summary box, so a printed sheet is comfortable to read at arm’s length on the workshop bench.
• Logical page breaks. Each bar’s header, diagram and cut list are now kept together on one page whenever they fit, so you never get an orphaned header at the bottom of a page.

Redesigned cut-list tables — now in 2D too

The result cut-list table was rebuilt from scratch:

• Columns now size to their content and the table is centred, so the part name finally gets the room it needs while the rod / order / length columns stay compact.
• A small colour dot before each part name ties the row back to its piece in the diagram.
• 2D mode now has a cut-list table too (Sheet / Order / Part / Size), matching the 1D and wood views.

Text fixes

• No more double colons in the PDF summary (Useful:: → Useful:).
• The “Order” column is spelled out in full instead of being abbreviated.
• Central-European characters (Hungarian ő/ű, Polish ł/ą/ż, Czech ř/ě/ů, Romanian ș/ț/ă) used to break in the PDF font; they now render as readable letters.
• CSV import correctly handles quoted fields that contain commas.

What’s next

A fully embedded Unicode font for pixel-perfect diacritics in PDFs is on the list, along with Feature Pack 2 Phase 2 (off-cut auto-include and assembly groups).

Have a feature request or hit a bug? Reply to any CutOptim email or use the contact form.

We have shipped two large sprints worth of improvements over the past three weeks. This post bundles the user-facing changes you can use right now.

Workshop-grade precision

Every cutting plan now respects three new physical-shop realities:

• Kerf tolerance (±mm) — Free+. The optimizer first tries an exact-fit placement; only when nothing fits does it allow up to ±tolerance of give. Useful when your blade jitters between 3.0 and 3.2 mm or when imported demand sizes have rounding noise.
• Start / End trim (mm) — Free+. The effective length of every bar or sheet is reduced by start_trim + end_trim. The damaged clamped edge stops being treated as offcut material, so your scrap reports match what the workshop actually keeps.
• Cost per cut (€) — Pro+. Each piece adds 1 cut (1D) or 2 cuts (2D) to the project total, multiplied by your blade-and-time cost. The new “Cuts” and “Cut cost” stat cards make the trade-off between a tighter layout and an extra blade pass visible.

All three settings travel with the project. The dedicated Kerf tolerance article walks through a 5-step measurement protocol and a workshop-tolerance reference table (CNC 0 mm → hand-fed bandsaw 2–3 mm).

Workshop-grade exports

• DXF + SVG export is now a stand-alone Pro feature on the landing page. The DXF target is R12, so it opens in AutoCAD LT, Inkscape, OnShape, Fusion, and every mainstream CNC post-processor without conversion.
• SVG files now include an xmlns declaration and an <?xml ... ?> prologue so the downloaded file opens correctly in Inkscape and any standalone SVG viewer.
• CSV files prepend a UTF-8 BOM so Excel automatically detects the encoding — no more garbled diacritics.
• Filename pattern is unified across PDF / CSV / DXF / SVG: <company-slug>-cutting-plan-<timestamp>.<ext>.

Saved offcuts go cross-device

Pro and Business users no longer lose their offcut inventory when they switch browsers. The “Saved offcuts” list now lives in the database (/api/offcuts-inventory), with a one-time silent migration from your existing localStorage on your next visit. Free users keep their browser-local storage as before.

Settings audit + 5 real bug fixes

We audited the entire /app Settings sidebar against the running optimizer code. Five settings looked like they did something but actually had no effect on the result:

• Stock prioritization (★ icon per row) now actually sorts the stock list before optimization.
• Min. offcut size advanced inputs (W / H / L) are now actually consulted by the inline optimizer.
• Cost minimization mode now sorts stock by _price ascending — pick the cheapest sheet first.
• Cut type and Unit (mm/cm) selects were phantoms — the code never read them. They have been removed. Cut type stays guillotine in 2D Panel mode; true-shape nesting later shipped as a separate Nesting mode. Unit stays in millimetres; cm / inch is planned for v2.

Faster perceived UX with skeleton loading

We added a reusable Skeleton placeholder and wired it into five async paths so you no longer stare at empty space while data loads:

• The optimization run paints a stats-and-sheet skeleton before computing, so the layout shift is gone on big jobs.
• The PDF dropdown shows a busy state while jsPDF lazy-loads.
• The dashboard billing-history list, project-delete card, and Pro offcut inventory load all show structured placeholders during their network round-trip.

Login and accessibility polish

• Show / hide password toggle on Login + Register, with a Caps Lock warning.
• Inline per-field validation with role="alert" for screen readers.
• Public accessibility statement is now available in all 8 languages — see accessibility.

What’s next

Sprint 6 picks up Feature Pack 2 Phase 2 (P1): off-cut auto-include, assembly groups, and a richer Material Library. Sprint 7 brings the first Pillar A2 export (G-code).

Have a feature request or hit a bug? Reply to any CutOptim email or use the contact form.