Construct v1.1.0

Models come alive. Construct 1.1 is the NetLogo release: it makes the NetLogo bridge something a
student can use in a minute and a teacher can trust. One command in NetLogo turns a run into a
construct that explains how to read it; two runs stand side by side for a lesson, and a page prints
as a worksheet. A run can leave as a film or a 3D model for Blender.

It is also the release of things you can make. Any construct prints, at the largest size a printer
takes, as voxels or as its own exact solids; it becomes a model kit with a booklet, real CAD shapes in
FreeCAD and STEP, and pieces a game engine can knock apart. And a construct says more honestly what it
knows: a part's size and its shape answered apart, and every guess in a shade that shows how firmly it
is held to the real thing.

And it is for anyone. With no terminal, the Claude app (Cowork) and the ChatGPT app (Codex) read the skill
and build a construct from your photos and one message: a digital copy of something you own, a change to your
home tried on a copy first, a part that is missing, made to print. Each everyday use has a page with a worked
example, the photos and the exact message.

For learners and teachers: a run in one command

Construct for NetLogo, a NetLogo 7 extension (hosts/netlogo).
Add extensions [construct] to a model and type construct:run in the Command Center: it runs the
model as its buttons do, records what is worth recording, lets the run go until the model stops by
itself, chooses the view the data suits and opens the construct in the browser. A model that never
stops is drawn after 1000 runs of go, and says so; construct:run-for 3000 runs longer. The
step-by-step commands (construct:start, construct:track-…, construct:record,
construct:draw) are there for full control. Install: unzip construct-1.1.0.zip into a folder
called construct in NetLogo's extensions folder (a listing in NetLogo's Extensions Manager is
planned). Recording needs only NetLogo; drawing needs Python 3.10 or newer.

The Models Library, unattended. Of NetLogo 7.0.4's 445 two-dimensional models, 388 now record a
run (at least two records) with no hand edits, from 256 at 1.0. Setup and go come from the model's
own buttons, turtle buttons and step buttons are understood, a model that never starts the tick
counter is recorded by steps, and a clock that moves in fractions (GasLab, system dynamics)
records every step. Most of the rest wait for a player or a classroom.

Reading a run. Every construct of a run carries its legend, each label shown as its part is drawn and kept
inside the window, a How to read it panel, and a replay bar: drag it, or press play, and the
construct is drawn up to that tick, with the tick and the run's counts beside it. The panel also
offers the counts as CSV and Cite this run (model, NetLogo version, seed, ticks,
Construct's version and the data lock); construct netlogo … --csv writes the counts at every
record. Printed, the page is a one-page worksheet with three questions for students. construct netlogo-compare draws two or more runs (up to eight) side by side on one time scale, for a lesson: a
slider moved, or another seed. --view auto chooses the view: a network where something spread or that grew, patches
that changed, turtles that switch on and off (the new pulse: one ring per tick, as wide as how
many are on at once, so falling into step shows as a thin column opening into wide plates), two
counts that cycle, or the agents' paths.

Landmarks. A construct of a run marks its moments by itself, computed from the counts: a peak ("Peak: 78
infected · tick 147"), or where something was half way and most of the way, or when half, then all, of
the fireflies flashed at once; each is marked inferred and kept under the data lock.

Where the order forms. Flocks form and fireflies fall into step early in a run and then hold, so a
construct of a whole long run would squeeze that moment into a few centimetres. Moving agents are
measured by their alignment and agents that switch on and off by their synchrony, and when that
order forms early, the construct is drawn over the window where it formed, and says so in its title,
its facts and How to read it (--window whole draws everything; the recording and the film keep the
whole run).

Films and 3D models

Runs as films. A construct holds a run's shape; a film holds its motion. In Blender (the
add-on's File > Import > NetLogo Run, construct netlogo-film run.jsonl --out film.mp4, or
(construct:draw "auto" "film" true) in NetLogo), the recording itself is drawn: every agent at
every tick as moving light with a trail, in its own NetLogo colours, each link as a line of light
between its agents while it lasts, the patches as a floor that changes with them, the world's edge as
a line of light, at 30 ticks a second. Nothing is sampled, so a three-minute flock of 200 birds stays 200 birds
for three minutes. NetLogo 3D runs are recorded with their heights and fly in their box; hidden
turtles are recorded and stay unlit.

A run as a 3D model. construct netlogo … --solid --glb run.glb, or "model" true in NetLogo,
adds solids drawn from the recording (each turtle a sphere where it rose, a cycle as a tube, a
spread as a surface) and exports the run in its own NetLogo colours, its build replaying the run.

Things you can make

Prints. construct print makes one watertight body to 3D print (STL or 3MF), checked: watertight,
pieces, the bed, overhangs. --printers says for five printer classes (from an A1 mini to a Prusa XL and
a resin printer) the largest print that stands on each and what is lost at that size; --printer and
--fit print at it, turned on the bed when it fits only that way. --exact keeps the construct's own
solids as parts of one object the slicer joins, so a print keeps every detail at the printer's own
resolution; open and too-thin surfaces (windows, panels, a curved nose) become true shells the wall
thick, in their own shape, not voxels. Line art can be engraved like a kit's panel lines.

Model kits. construct kit makes a construct a kit to print, glue and paint: pieces that fit, clear
parts on plates of their own, each piece glued where a kit designer would glue it, sub-assemblies built at
the bench and doors hung last, a booklet on paper with each step's pieces in their own colours, and the
same steps in 3D (assembly.html), the pieces dropping into place in their paints, the model ghosted around
what is built at the bench; the booklet's drawings shaded as a kit sheet's, with no hidden lines; made with a
critic's brief and a plan, as constructs are. Each piece can be printed on its own, first or again. Four kits
open in the gallery, their steps in 3D and their booklets: the
Yamaha CFX, Tompion's year-going clock, the VW T1 Samba and an owner's Vespa GS 150. Their plates are attached
to this release, one zip per kit with the booklet and the 3D guide. No kit has yet been
printed and built by a person: if you build one, tell us how it went.

CAD. construct freecad builds a construct in FreeCAD with its joints, and writes STEP. Parts are
true CAD shapes where their parameters allow: exact boxes, cylinders and spheres, lathes and extrusions
from splines, lofts as smooth NURBS surfaces; each is checked against the construct, else faceted.

OBJ for artists. An OBJ's positions are shared and its strips are quads again, so it subdivides
cleanly; every export reports its thin triangles, and --quality shows where they are.

A run you can hold. construct netlogo-plates prints a run as plates that stack, with a key card.

For everyday use, with no terminal

Find your path now starts with everyday uses: a digital copy of something you
own, a change to your home or garden, your vehicle, a part that is missing or broken, a model kit of your own
thing, showing someone what you mean. Each has a page with an example made from real photographs, the message that
made it, what came back and how to take it further (a finished model in Blender, a STEP file for a builder, a print
file for the part), and one page says how to use Construct in the Claude app or the
ChatGPT app, both tested: the same chair from the same two photos, in about half an hour and about an hour.

New examples, made that way: an Eames Lounge Chair (in the Claude app, and in the ChatGPT app), a Braun SK 4 with a
replacement knob to print, a garden shed with a planned log store and deck, and a 1960 Vespa GS 150
with its owner's parts told from the factory's.

Your own formats

ADAPTERS.md says what a construct holds (named parts at their real sizes, how each is known,
how they assemble, open and move), where an adapter reads it (the glTF in any language, the compiled geometry,
the scene) and the rules that keep an adapter honest. A tested template writes a parts sheet and an STL per part.

For game engines

Colliders (--colliders), pieces that break apart and settle rather than burst (--pieces: each copy a
body, convex shapes that follow the surface, interlocked parts as one assembly), or glued (--pieces glued:
what stays put is one body, each door, tailgate or lid one more on its own hinge, joined in Godot by
hosts/godot/construct_joints.gd), seeded variants of an archetype (params --seed), and a guide to Godot
(GODOT.md).

Seeing it as a solid

S for solid. Every built page now also carries the construct's surfaces: press S (or open it with
?mode=solid) to see it as a modelling program shows it, lit like a studio, still opening and building in
stages; with P the solids take their provenance colours. Review captures solid.png for the critic,
because the light forgives what a solid shows: panels that do not meet, glass outside its frame. Solids for
the page, the exports and prints are now smoother: lofts pass smoothly between their sections (the line art
is unchanged) and round tubes have twice the sides.

Refining what the solid shows

What the light forgives, a solid, a print and a kit do not. construct check --fit lists the parts that poke
through others where it shows (a fender's edge up through a bonnet) and the parts buried in others (a fender so
thick it swallows the strut tower), each with where it is, the most visible first, for an agent or a person
to fix one by one; S shows the result and review's solid.png gives it to the critic. The R34 was
refined this way: its windscreen pillars, window sashes, the bonnet's crumple and its headlamps.

Contact you can trust. The check that every part rests on something used to look at the parts' boxes, so a
gap passed when a round part's box reached past it or a wire-thin strut bridged it (a desk fan two models built,
reported from use). check now follows support through the solids: a part whose surface meets nothing held up is
an error, a part carried only by something far thinner than itself a warning, each with the gap and the part to
rest it on. It runs in every mode and needs no vision, and it closed three gaps in the gallery.

What a construct knows

Size and shape, apart. A spec sheet verifies a car's length, not its outline: a part's certainty can
now say each ({"size": "verified", "shape": "traced"}), with traced for a fit to an orthographic
drawing. The provenance view (P) keeps fully verified parts white and gives size verified, shape verified
and traced parts their own colours; its legend counts them and names the sources behind the verified
ones.

Guesses in shades. An inferred part is deeper amber the more firmly it is held to the real thing:
designed, described, seen in a picture of it, seen and checked by a verified fact or a passing silhouette
comparison. A construct can carry a note for the provenance view; seven early gallery constructs say
where their shades understate their evidence.

Modes, and one construct end to end

Timeboxed. Masterpiece in two hours in all, the critic's time counted with the author's, for when it has to be
done by a certain time. Masterpiece is unchanged.

A longcase clock, end to end. One construct, built by DeepSeek V4.1 Flash in masterpiece
mode, taken through every 1.1 feature with real pictures: provenance, the solid, Blender, Godot, a film, FreeCAD,
a print in PrusaSlicer and a model kit.

For agents

NetLogo for every agent. The MCP server gains construct_netlogo_instrument and
construct_netlogo_draw, so Hermes or any MCP client can instrument a model, draw a run, add an art
layer, solids and colours, then compile or export it with the existing tools. The skill knows the
extension, the reading, 3D models and films.

Critic rounds for a run (opt-in). Construct's improvement rounds now judge a construct of a run
by its own standard: every label and milestone against the recording's facts and counts, and how a
student would read it. With GPT-6.1 Sol as the blind critic, three rounds on Virus on a Network
raised accuracy from 1 to 3 (of 3), and a planted false milestone was its first, critical defect.

Fixes

• The ReVox A77's meter faces sat in the plane of their housings and flickered in any solid render;
  the FJ62's glasshouse shared its bottom with the body's top. Both are fixed in the examples.
• The field view's fronts are declared floating, so a run whose first front sits above the floor
  passes the audit.
• The recorder's own names no longer clash with a model's.
• Found by breaking things on purpose (scenes, recordings, files and commands mutated thousands of ways):
  no malformed scene, recording or command crashes any more; each is answered with an error that says
  where. A page whose title named a template marker broke; a grid in metres near the origin was read as
  degrees; a thin hardcover had no room for its pages and an empty glass bubbled.

Compatibility

The scene and geometry contract keeps its id, construct/0.2, and changes nothing that exists:
1.1 adds optional scene keys (presentation.labels, reading, a part's look.color, a part's
certainty as {"size", "shape"} and the certainty traced, authoring.provenance_note) and optional
geometry keys (reading, annotations' phase, style_colors, a part's certainty_axes and evidence,
provenance.checked). A geometry reader that knows four certainties reads traced as a fifth word; a v1
sheet reads it as inferred. The viewer changes in one way for every page: a label appears as
the build reaches its part, instead of from the first frame; otherwise a page whose scene uses none
of the new keys is the 1.0 page. NetLogo recordings gain optional header keys (zcor, the world's min-pzcor and
max-pzcor) and, for NetLogo 3D, each turtle's height last in its row; a 1.0 recording reads as
before. The three NetLogo examples are regenerated with readings,
so their data locks changed; their data did not. Films need Blender.

See What's new in 1.1 for each feature with an example and the commands to try it,
CHANGELOG.md for every change, and docs/NETLOGO.md for
the bridge.