Features
The full system, organised around the job: import and creation, vector and raster processing, preview, placement, material testing and repeat workflows.
The controller-aware core
The software asks the machine what it can do, rather than assuming
On connect, the core reads the machine's own $30 and $31 registers and scales every emitted power value to that machine's real range, then queries $110 and $111 to derive and validate the effective maximum feed rate. One internal, dialect-neutral motion program is emitted into GRBL, Marlin, Smoothieware and Generic, each with its own laser-on command, travel strategy, power scale, precision and streaming discipline. The heat map preview shows the toolpath the core will actually generate, colour coded by power, so a setting is checked on screen rather than on the workpiece.
- Power scaling is four quantisations of one physical intent: an internal 0 to 10000 range mapped onto the GRBL $30 value read live off the controller at connect time, the Marlin 0 to 255 integer, Smoothieware 0 to 1.0 at four decimal places, and Generic 0 to 1000
- A golden fixture suite holds emitted machine output stable across three dialects, 42 fixtures across two images and seven processing variants, with a conformance validator checking output against the dialect rules
- Ten stage vector optimisation published with its tolerances, and a ten stage raster pipeline built on Rec.709 luminance rather than a brightness slider
One core, and the scope label that travels with every figure
Every figure on this page belongs to the controller-aware core as it ships in the desktop application, and the scope label travels with it deliberately. Where a capability is specified and commissioned on a line rather than installed from a download, this page says so in the same breath.
The industrial marking layer is where a mark is composed for the individual part arriving at the head. There, the Light Lane Control Layer reads the PLC tag that identifies the part, pulls the job, batch or serial from the system that already owns it, generates Data Matrix to ISO/IEC 16022 graded to ISO/IEC 15415, fires inside the window the part spends in the field of view, and writes the completion back against the job with timestamp, operator, machine and station. Those are marking station capabilities, specified and commissioned on a line.
The desktop application drives one machine directly. It carries the geometry engine, the ten stage vector and raster pipelines, the controller adapters and power mapping, code generation for QR and five linear symbologies, the framing pass, the streaming and recovery discipline, and licensing that completes every state transition offline. Both bodies of engineering share one geometry engine and one code generator, which is why a parameter established on a production line and a job run on a bench come out of the same arithmetic.
From artwork to emitted motion, stage by stage
Six stages. Each one is a place where the result is decided before the beam fires, and each one publishes what it does to the geometry.
- Step 1
Connect, and read the machine's own registers
The core reads $30 and $31 at connect time and scales every emitted power value to that machine's real range, then queries $110 and $111 to derive and validate the effective maximum feed rate. The machine profile holds the dialect, the travel strategy and the work envelope, so the controller decision is settled before any artwork is placed.
Why it matters: A profile built on an assumed power scale sends a value the machine reads as something else entirely. The core asks the machine for its own scale before a single move is emitted.
- Step 2
Bring the artwork in, and edit it without mutating it
PNG, JPEG, BMP and SVG import, plus text, shapes, QR codes and linear barcodes built directly in the app. An imported SVG is parsed into a hierarchical sublayer tree, and every element is individually shown, hidden, nudged, scaled or made semi-transparent, with each edit stored in a separate dictionary and merged at render time. The original markup is never mutated, tracking identifiers are auto-injected so edits survive re-rendering, parsing runs asynchronously on idle callbacks with per-image caching, and positions are clamped against the viewBox.
Why it matters: The merged result is what the generator consumes, so what you edited is exactly what the laser cuts. That is an audit statement as much as a usability one.
- Step 3
Decide how the geometry is processed
Vector work runs a ten stage optimisation with its tolerances published: normalisation, undirected edge dedup at 0.01 mm, short segment removal below 0.03 mm, connected path building with a 0.20 mm snap and greedy head and tail extension, and collinear merging by cross product. Then come the two stages where a single tolerance decides whether a contour survives: Douglas-Peucker thins a polyline only while every vertex it discards stays within 0.05 mm of the line left behind, and loop detection joins a path whose two ends sit within 0.20 mm of each other, so an open polyline out of an SVG still cuts as a closed contour. Ordering follows, with closed paths by descending signed area so outer contours run first and open paths by nearest neighbour with direction-aware reversal, then closed path rotation to the nearest approach point, then travel insertion. Raster work runs bilinear resize to target DPI, then sRGB to linear luminance on the Rec.709 weights 0.2126, 0.7152 and 0.0722 applied to R, G and B, because green carries roughly seven tenths of what the eye reads as brightness and the beam is being asked for energy rather than for a picture. Subject statistics then set the tonal range by percentile clipping at the 0.5th and 99.5th, followed by auto levels, exposure, contrast around the 0.5 midpoint, gamma, optional invert, mode-specific conversion, and emission.
Why it matters: Every tolerance on that list is a decision somebody had to make with a ruined part in their hand. Ordering closed paths by signed area is a physical insight rather than a software one: a part that drops out of the sheet before its detail is finished is scrap.
- Step 4
Check the heat map preview, then frame the job
The heat map preview shows the toolpath the core will actually generate, colour coded by power, rather than the source artwork. Framing parses the generated output for laser-on coordinates, rasterises them into a 300 pixel binary mask, dilates then erodes at radius 2 to close gaps, boundary-traces with Moore neighbourhood 8-connectivity and simplifies with Douglas-Peucker at 0.5 mm, with a convex hull fallback by Andrew's monotone chain that is guaranteed to terminate. The framing pass is emitted in constant power mode and clamped to a maximum of 10 percent.
Why it matters: A wrongly chosen setting shows up on screen instead of on the workpiece, and an alignment preview stays an alignment preview: even this feature carries two algorithms, a fallback and a safety clamp.
- Step 5
Stream it, stop it, and bring it back to a known origin
Character-counting streaming tracks bytes in flight against the controller's 128 byte receive buffer and keeps it full rather than waiting for an acknowledgement per line, with a send and wait fallback on a 3, 8 then 12 second retry ladder. Preflight primes absolute mode, issues a no-op move and probes laser mode. The stop system has three levels: emergency with feed hold, power zero, laser off and the soft reset byte, soft stop, and a recovery sequence that soft resets, flushes buffers, drains controller boot chatter, verifies status, clears alarms and restores the user origin. The stop flag is an atomic integer checked on every streaming iteration.
Why it matters: Stopping a laser is easy. Bringing it back to a known coordinate frame afterwards is the engineering, and on a floor the real question is what the operator has to do next and whether the origin survived.
- Step 6
Save the setting so the result repeats
Machine profiles, material settings and templates are stored against the job, and step and repeat layouts run up to a 20 by 20 grid. A parameter set is recovered from the file rather than rediscovered at the machine.
Why it matters: The first good result matters. Reproducing it six months later, on the same machine, from a written parameter set, is where the core earns its keep.
The constants the core is built on, published raw
These figures belong to the controller-aware core as it ships in the desktop application. They are published rather than summarised, because a reader who recognises them knows immediately whether the people who wrote the page also wrote the code.
Why the constants are the specification
Most laser software keeps this arithmetic behind a slider. Publishing the coefficients, the tolerances and the quantisations is what makes the behaviour checkable: the same input produces the same emitted motion, and a change to the geometry engine cannot silently change what a machine does.
- Three dithering error models, because on a laser this is a materials decision rather than an aesthetic one: Floyd-Steinberg diffusing error to four neighbours at 7/16, 3/16, 5/16 and 1/16 with serpentine bidirectional scanning, Atkinson diffusing one eighth of the error to six neighbours and deliberately discarding the rest to lift contrast, and Bayer on a 4 by 4 ordered threshold matrix. Error diffusion leaves isolated single-pixel dots that a beam with a finite spot size will not resolve on a coarse substrate, while ordered dithering produces clustered structures that survive. Exposure bias of plus or minus 0.3 is applied to luminance before diffusion.
- Dynamic power as energy control. A head decelerating into a corner deposits more energy per millimetre than a head at cruise, which is what burns corners, so the firmware modulates power against actual velocity and the generator emits an inline power value on every move. Constant power is not a constant result.
- Raster emission with serpentine rows, 2.5 mm overscan so the head is at velocity before the row starts, modal feed, and inline power quantised into 50 steps. We treat the image as a light source, not as a picture.
- A golden fixture suite holding emitted machine output stable across three dialects, 42 fixtures across two images and seven processing variants, with a conformance validator checking output against the dialect rules. That is the answer to the question an industrial buyer rarely gets to ask: what happens to my machine output when the software updates.
- Exactly one package may import the desktop framework runtime. Code generation, serial communication, controller adapters and power mapping, project and material persistence, licensing, image handling, export and update are pure Go, unit testable without a window opening, and the boundary is held by a purity guardrail in continuous integration rather than by a style guide. The engine does not know a window exists, and a build fails if anyone tries to teach it.
- Every licence state transition completes offline. The application mints a Device Setup Code carrying the device identifier, an Ed25519 public key, device name and platform, and verifies the returned RS256 activation and lease signatures, issuer, device identifier and public key hash entirely locally. Offline lease refresh and offline deactivation are both Ed25519-signed requests, the deactivation code persists across restart so the device slot is provably released, secrets live in the operating system credential store, and every update is verified against a published SHA-256 checksum before installation.
Explore more
Controller support
The exact status of each dialect: GRBL, Marlin, Smoothieware and Generic G-code as supported paths, and Ruida as an external bridge labelled alpha.
Getting started
Install, connect the machine, let the core read its registers, and put a real first job through the preview.
Controller dialects, and what changes between them
One internal, dialect-neutral motion program is emitted into each dialect below. The differences are structural rather than cosmetic: the laser-on command, the travel strategy, the power scale, the precision, the status vocabulary and the streaming discipline all move between them.
| Dialect | Power scale | Emission detail | Status |
|---|---|---|---|
| GRBL | Internal 0 to 10000 mapped onto the $30 value read live off the controller at connect time | Travel moves are emitted as G1 F rapid with S0 rather than G0, because GRBL rejects G0 carrying an F parameter. The core applies it automatically, so error 20 never reaches the operator. $110 and $111 are queried to derive and validate the effective maximum feed rate. | Supported |
| Marlin | 0 to 255 integer | The Marlin adapter sets the laser-on command, the travel strategy and the precision, and inline power is emitted on every move so energy per millimetre tracks actual velocity. | Supported |
| Smoothieware | 0 to 1.0 at four decimal places | Four decimal precision on power, with the adapter holding its own streaming discipline and status vocabulary. | Supported |
| Generic G-code | 0 to 1000 | A neutral target for controllers that accept standard G-code, with emitted output checked against the dialect rules by the conformance validator. | Supported |
| Ruida | Handled by the bridge | Ruida runs as an external bridge rather than a native adapter, so it is validated against the specific controller in front of it. | Alpha |
Status labels, stated exactly
Confirmed
- GRBL, Marlin, Smoothieware and Generic G-code are supported paths, and emitted machine output across three of those dialects is held stable by the golden fixture suite and the conformance validator
- Ruida runs as an external bridge and carries the alpha label, in the product and on this page. It is an active path under evaluation, validated against the specific Ruida controller in front of it
- Arc fitting carries the Experimental label. The method is Kasa algebraic least squares circle fitting solved through a 3 by 3 Cramer's rule determinant, gated on five simultaneous conditions: at least 8 segments, radial error under 0.08 mm, radius deviation under 1.5 percent, sweep of at least 15 degrees, and consecutive segments within 0.12 mm. Full circles split into two semicircles and arcs over 180 degrees split in half
Not confirmed
- Ruida parity with the established dialects sits behind the alpha label, so plan a validation pass on your own controller before a workflow depends on it
- Arc fitting stays behind the Experimental label until the gating holds across a wider range of geometry, so treat arc emission as a path to evaluate rather than a production default
The work the core runs, at parameter level
One machine, one job at a time, with the processing decision stated rather than guessed.
- Line work and logos: two vector modes, outline and fill, with closed paths ordered by descending signed area so the outer contour runs before the inner detail, and each closed path rotated to its nearest approach point
- Photographic and tonal work: grayscale, threshold and dither, with the error model chosen against the substrate rather than the screen, and percentile clipping at the 0.5th and 99.5th setting the tonal range before conversion
- Machine readable codes: QR in square, rounded and dot module styles, with centre logo embedding at 5 to 29 percent of symbol size and error correction raised automatically to level H when a logo is enabled, because embedding a logo means deliberately destroying part of the symbol
- Linear symbologies: Code 128, Code 39, EAN-13, UPC-A and ITF-14, each with input validation enforced at entry rather than discovered at the scanner
- Repeat production: saved templates, material settings and machine profiles, with step and repeat layouts up to a 20 by 20 grid, so the tenth run is emitted from the same numbers as the first
- Branding, personalisation and one-off pieces: plaques, metal cards, inserts and named work where the material gets one attempt, checked in the heat map preview before anything is streamed
Engineering questions, answered with numbers
What happens to my machine output when the software updates?
It is held by a regression suite rather than by a promise. The golden fixture suite holds emitted machine output stable across three dialects, 42 fixtures across two images and seven processing variants, with a conformance validator checking the output against the dialect rules. A change to the geometry engine cannot silently change what a machine does. The architecture boundary is held the same way: exactly one package may import the desktop framework runtime, and a purity guardrail in continuous integration fails the build if anything else tries.
Does the desktop application compose a mark per part from our ERP?
That is the industrial marking layer. On a marking station, the Light Lane Control Layer reads the PLC tag that identifies the part at the head, pulls the job, batch or serial from the system that already owns it, generates Data Matrix to ISO/IEC 16022 graded to ISO/IEC 15415, fires inside the window the part gives you, and writes the completion back against the job. The desktop application drives one machine directly and generates QR and five linear symbologies from the job in front of it. Both run on the same controller-aware core, so the geometry arithmetic underneath them is identical.
What does the operator do after an emergency stop?
The stop system has three levels: emergency, which issues feed hold, power zero, laser off and the soft reset byte, soft stop, and a recovery sequence that soft resets, flushes buffers, drains controller boot chatter, verifies status, clears alarms and restores the user origin. The stop flag is an atomic integer checked on every streaming iteration. Stopping a laser is easy. Bringing it back to a known coordinate frame afterwards is the engineering.
Which controller paths carry which status label?
GRBL, Marlin, Smoothieware and Generic G-code are supported paths, each with its own laser-on command, travel strategy, power scale, precision and streaming discipline. Ruida runs as an external bridge and carries the alpha label, so it is validated against the specific controller in front of it. Arc fitting carries the Experimental label, gated on five simultaneous conditions including radial error under 0.08 mm and radius deviation under 1.5 percent.
Does it run on a machine with no internet connection?
Yes, and offline operation is the design point rather than a mode. Every licence state transition completes offline: the application mints a Device Setup Code carrying the device identifier, an Ed25519 public key, device name and platform, and verifies the returned RS256 activation and lease signatures, issuer, device identifier and public key hash entirely locally. Offline lease refresh and offline deactivation are Ed25519-signed requests, and the deactivation code persists across restart so the device slot is provably released. Licence state expires if the system clock is set more than an hour before lease issuance, secrets live in the operating system credential store rather than a file on disk, and updates are verified against a published SHA-256 checksum before installation. The assistant features are the single part that needs a live connection, and they sit outside the path that generates and emits motion.
Why three dithering models rather than one?
Because on a laser the choice is a materials decision. Floyd-Steinberg diffuses error to four neighbours at 7/16, 3/16, 5/16 and 1/16 under serpentine bidirectional scanning and holds fine tonal detail. Atkinson diffuses one eighth of the error to six neighbours and deliberately discards the rest, which lifts contrast. Bayer uses a 4 by 4 ordered threshold matrix and produces regular clusters. Error diffusion leaves isolated single-pixel dots that a beam with a finite spot size will not resolve on a coarse substrate, while ordered dithering produces clustered structures that survive the same material.
What does the Experimental label on arc fitting mean?
It means the numerical method is published and the gating is strict while the label stays. Kasa algebraic least squares circle fitting is solved through a 3 by 3 Cramer's rule determinant and gated on five simultaneous conditions: at least 8 segments, radial error under 0.08 mm, radius deviation under 1.5 percent, sweep of at least 15 degrees, and consecutive segments within 0.12 mm. Full circles split into two semicircles and arcs over 180 degrees split in half. Evaluate it against your own geometry, and run production work on the line segment path.
Why does the heat map preview matter?
It shows the toolpath the core will actually generate, colour coded by power, rather than the source artwork. Power is the variable that decides the physical result, so seeing it mapped over the real path is what turns a setting into a checked decision before material and machine time are committed.
Run the core on your own machine
Start the 14 day trial, connect the machine, and let the core read its registers. The first job tells you more than any specification: the profile it builds at connect time, the toolpath in the heat map preview, and the emitted motion in the dialect your controller actually speaks.
Last updated August 21, 2026