Construct v1.1.1

A fix release, and a new use case.

The kits are attached as before (construct-kit-<slug>.zip): plates to print, the booklet and the 3D guide. construct-1.1.1.zip is the NetLogo extension and construct-blender-1.1.1.zip the Blender add-on.

• New things from real ones (docs/for/invent-from-what-exists.md): a use
  case for game developers, filmmakers, Blender artists and worldbuilders: how to write a brief that grounds an
  invented ship, vehicle, creature or artefact in real designs, with an invented brief to follow. Three examples made
  for the author's album film (ARGUS, Lander 2, Object 001) join the gallery as their own group, published to view
  only: all rights reserved, without their scenes or briefs (examples/worlds.json; see NOTICE).
• The provenance legend on embedded pages: a page embedded with ui=0 (every gallery example) coloured
  its parts on P but hid the legend that says what each colour means and how many parts are each; it now
  shows wherever P does, and stays out of stills (capture=1). The viewer's pinned copy moves to
  testdata/hologram-1.1.1.js.
• No copy of Chrome left behind: on macOS, Chrome copies itself on every launch to check its signature and
  removes the copy when asked to quit, but not when it is terminated. Construct's headless browser (every
  capture, still, kit picture and many tests) was terminated, so each launch left a full copy of Chrome in the
  user's temporary folder (thousands over a week of work). It now asks Chrome to quit first.

What came before: the 1.1.0 release notes.

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, ...

Construct v1.0.0

Construct v1.0.0

Describe a thing. Get a hologram, a 3D model and its parts. Construct 1.0 takes a construct beyond
the hologram: the same scene an AI agent writes now exports as a 3D model with named parts,
working joints and its build order, for Blender, game engines and the web, plain or finished in
paint, chrome, glass and wood. And for a NetLogo model, Construct records a run and draws it in
time, so the construct's assembly replays the run.

What's new

• 3D export. construct export scene.json --out model.glb writes glTF 2.0: every part a named
  object under its stage, with its role and how it is known; the joints as the open animation,
  periodic motion as idle, and each vertex's build phase. OBJ too. See
  3D export.
• Finished models. A material map, kept beside the scene, finishes parts by id: paint, brushed
  metal, chrome, wood, rubber, plastic, glass and light, in standard glTF extensions. A part named
  for its glazing gets glass on its own.
• Game-ready. --merge puts every part that does not move into one mesh per material (the
  FJ62 goes from about 300 draw calls to 27, its tailgate still opening), --wire seams keeps only
  the design lines, as dark seams, and surfaces carry texture coordinates. Checked in Godot 4.7.2,
  and every export option passes the Khronos glTF Validator with no errors or warnings.
• Construct for Blender. An add-on that imports a construct with three controls, Build,
  Open and Light ↔ Metal, plus Plain ↔ Finished and the line thickness. They are custom
  properties, so a .blend works without the add-on. The add-on is GPL-3.0-or-later, as Blender's
  extensions platform requires; the rest of Construct is Apache-2.0. See the
  Blender add-on.
• From light to a finished model. An interactive 3D page with four gallery constructs (the FJ62, the James
  Webb Space Telescope, the Revox A77 and the MiniFreak) as their exported files: from the
  hologram to the plain model to the finished one, with each file to download:
  https://rtmandreyev.github.io/construct/examples/light-to-metal/
• The NetLogo bridge. construct netlogo-instrument makes a copy of a model record its run;
  construct netlogo run.jsonl --view space-time | network-time | phase | field draws the run as a
  construct, computed from the recording, never drawn by a model. It reproduces the Simple Viral
  Marketing example's run exactly. See the
  NetLogo bridge.
• Art direction, with the data locked. An optional art.json layer adds views, labels and
  milestones on top of a recorded run; a data_lock fact makes construct check refuse any change
  to the data under it. Three new examples, Flocking, Wolf Sheep Predation and Fire, were
  art-directed by Claude Opus 5.5, every milestone computed from the run.
• A gallery in three parts: the constructs and films first, then the full pipeline, then the
  models that come alive: https://rtmandreyev.github.io/construct/
• Who it is for. The README now opens on what people make with Construct: game developers, 3D
  artists, film and motion, educators and researchers, and museums.

Nothing breaks

The contract stays construct/0.2: 1.0 adds a shape (paths, up to 4,000 polylines in one part)
and changes nothing else. A scene written for 0.3.0 builds the same hologram in 1.0; the export
reads a separate, solid compile, so the hologram's own compile is unchanged. Film mode works as
in 0.3.0.

A new licence: Apache-2.0

From 1.0, Construct is under the Apache License 2.0 instead of MIT. It is just as open (use it,
change it, sell it, in closed products too), and adds three things: copies keep the NOTICE file
that says who made Construct, a copy gets no right to the name or to present itself as the
official Construct, and contributors grant users a licence to any patents their code covers. The
Blender add-on is GPL-3.0-or-later, as Blender's extensions platform requires. Versions up to
0.3.0 stay MIT.

Install

git clone https://github.com/rtmandreyev/construct.git
cd construct
python3 construct_hologram/package.py --out dist             # the Claude Code and Hermes skills
python3 scripts/build_blender_extension.py                    # the Blender add-on, in dist/

Then add dist/claude-code/construct to Claude Code (claude --plugin-dir dist/claude-code/construct)
or copy dist/hermes/construct into ~/.hermes/skills/, and ask in plain words. In Blender:
Edit → Preferences → Get Extensions → Install from Disk with the zip, built as above or
downloaded from this release (construct-blender-1.0.0.zip). See the
README and USING.md.

Requirements

Python 3.10 or newer, with no third-party packages. Review stills and films need a
Chromium-family browser you already have; videos and films need ffmpeg. The add-on needs Blender
4.2 or newer; the bridge, desktop NetLogo 6 or 7.

Known limitations

• An exported model is a blockout, a prop or a starting point, not a finished hero asset: it is
  built from Construct's own shapes, overlapping parts are not merged (so it is not watertight
  for 3D printing), its texture coordinates are a simple box projection, and its joints are
  mechanical, with no skinned rig. It is not CAD.
• Godot ignores glTF's clear coat and transmission, so glass there is a plain translucent
  material.
• The NetLogo bridge needs desktop NetLogo (NetLogo Web does not support include files) and does
  not record NetLogo 3D's third coordinate. A long run of many agents is sampled; the construct's
  facts say how. A construct shows a quantity by position, not by colour.
• No imported meshes, CAD or photogrammetry; one periodic motion per part.
• Masterpiece mode in Hermes needs a higher helper-agent limit; see
  Troubleshooting.
• Tested on macOS; review capture on Linux and Windows is untested.

License: Apache-2.0 — Copyright (c) 2026 Artyom Andreyev
(see NOTICE).
The Blender add-on (hosts/blender/) is under GPL-3.0-or-later. The four NetLogo example folders
derive from Uri Wilensky's NetLogo models and are under CC BY-NC-SA 3.0.

Construct v0.3.0

Film mode. A construct can now assemble across a whole track of music, and you can see the music
in it: the build nearly pauses in the quiet passages and surges in the loud ones, the light
swells and dims, the construct flares on the strong attacks, and each new section of the music
starts a new stage of the construct. You get a video with the track in it. Film mode is entirely
optional: without it, Construct makes exactly what 0.2.1 made.

What's new

• Film mode. construct audio track.wav measures a track frame by frame: its loudness, its
  brightness, its attacks and where it changes section. construct video scene.json --assembly <seconds> --audio features.json --sound track.wav renders the construct assembling across it,
  with the track in the MP4. See Film mode.
• The music shows. On calm synth tracks, the build's pace over any four seconds now
  ranges from under a tenth to over three times an even build, and the light from 60% to 140%.
• A reactivity setting. --reactivity from 0 (an even build, the music only as soundtrack) to 2;
  the default, 1, makes the music clearly visible even on calm, ambient tracks.
• Choose the camera. --camera tour plays the scene's own camera flights, keeping each in its
  place as the build lengthens; steady is one long shot that drifts and breathes; still holds
  the view.
• Agents know the workflow. Ask "make a construct of New Horizons that assembles across this
  track", and the skill authors the construct, measures the track, renders the film and reviews
  its frames. In testing, DeepSeek V4.1 Flash in Hermes did exactly that from that one sentence.
• Three films in the gallery, made by DeepSeek V4.1 Flash in masterpiece mode, each with a
  choice between watching the film and opening the live construct:
  https://rtmandreyev.github.io/construct/#films
• An optional three.js loader for filmmakers who want a construct inside their own 3-D scene.
• Docs for people new to Construct: how a construct is made, the Measured Light style,
  troubleshooting, and a docs index with a short glossary.

Strictly optional

Film mode lives in its own script, which a page carries only when you build it for film
(build --film, or video with a film option). Without it, the viewer is the 0.2.1 viewer byte
for byte, and check, build, review and video write the same files as 0.2.1 did; the tests
check both. The contract stays construct/0.2: film mode adds to it and changes nothing in it.

Install

git clone https://github.com/rtmandreyev/construct.git
cd construct
python3 construct_hologram/package.py --out dist

Then add dist/claude-code/construct to Claude Code (claude --plugin-dir dist/claude-code/construct)
or copy dist/hermes/construct into ~/.hermes/skills/, and ask in plain words. See the
README and USING.md.

Requirements

Python 3.10 or newer, with no third-party packages. Review stills and films need a
Chromium-family browser you already have; videos and films need ffmpeg.

Known limitations

• Film mode follows the attacks it hears, not a beat grid: there is no tempo or bar detection.
• Sections come from changes in loudness and brightness, not harmony or melody.
• A film renders at about a frame or two a second on a laptop: a four-minute film takes about an
  hour.
• The voice shimmer needs a separate vocal stem.
• Glass is never tinted, and stills show the closed pose; open a construct in a browser to see it
  open.
• No imported meshes, CAD or photogrammetry; a construct is built from Construct's own shapes.
• One periodic motion per part.
• Masterpiece mode in Hermes needs a higher helper-agent limit; see
  Troubleshooting.
• Tested on macOS; review capture on Linux and Windows is untested.

License: MIT — Copyright (c) 2026 Artyom Andreyev.

Construct v0.2.1

The first public release. Construct is an agent skill and toolkit that turns a description of a
real or fictional thing into an animated holographic model, in the Measured Light style: an AI
agent writes a short scene, and Construct checks it, builds it into one web page and reviews it.

What's included

• Three modes, and the skill chooses. fast is one careful pass in about ten minutes;
  masterpiece runs rounds judged by an independent critic for named subjects whose likeness
  matters; unbounded keeps going without the round and time limits, only when you ask. When
  you don't name a mode, the skill picks one and tells you why before it starts.
• An independent critic. In masterpiece mode a fresh model compares each new version with
  the best so far without knowing which is which, and only a better version is kept. You get a
  short report after every round.
• Honest constructs. Every fact and part is marked as verified, user-supplied, inferred or
  decorative, and the provenance view (press P) shows which. Unknown facts are left out.
• A check that repairs. Every problem comes back with where it is and how to fix it, and the
  agent repairs until the scene is clean.
• One house style, Measured Light. Line light over smoked glass, built part by part on screen,
  with labels drawn only from facts. Models never choose the colours.
• A drawing guide for detailed, sculpted constructs, and a check that warns when a main surface
  is drawn as a flat shape.
• New shapes: lofted car bodies and a vehicle template, towers, roofs, facades, battlements,
  ribbed shells, measured terrain and a globe from coastline data.
• An examples gallery of constructs made by Claude Opus, GPT-6.1 Sol and DeepSeek:
  https://rtmandreyev.github.io/construct/
• Any agent, any model: Claude Code and Hermes skills, an MCP server, and a runner for any
  OpenAI-compatible model.

Install

git clone https://github.com/rtmandreyev/construct.git
cd construct
python3 construct_hologram/package.py --out dist

Then add dist/claude-code/construct to Claude Code (claude --plugin-dir dist/claude-code/construct)
or copy dist/hermes/construct into ~/.hermes/skills/, and ask in plain words: "make a construct
of a Leica M3". See the README and USING.md.

Requirements

Python 3.10 or newer, with no third-party packages. Review stills need a Chromium-family browser
you already have; videos need ffmpeg.

Known limitations

• Glass is never tinted, and stills show the closed pose; open a construct in a browser to see it
  open.
• No imported meshes, CAD or photogrammetry; a construct is built from Construct's own shapes.
• One periodic motion per part.
• Masterpiece mode in Hermes needs a higher helper-agent limit; see
  Troubleshooting.
• Tested on macOS; review capture on Linux and Windows is untested.

License: MIT — Copyright (c) 2026 Artyom Andreyev.