Five steps, for the person standing next to a printer that is not in the network yet. Each one ends in something checked rather than something claimed: the hub hands back a key that belongs to this machine only, the printer itself starts reporting, the filament in the slots is the filament the page shows, and the last step is a real 20 mm cube going through the whole loop, dropped, sliced, and started by the owner. Nothing here is ticked off on your word except the one thing no machine in this system can see.
What this page cannot do. It cannot reach your printer: the browser you are holding is not on its network, and nothing here talks to a machine directly; the node you install does that, from the printer's own LAN, dialling out. It cannot write a file on the computer that runs the node, so the config below is text to paste. It cannot show you the node key twice: the hub keeps a hash of it, exactly as it does with the access codes, so the copy in this tab is the only copy there is. And it cannot start the test print for you: sending a job to a printer is a statement about an empty build plate, and that statement belongs to the owner console, where it costs a deliberate tick that lasts ten minutes.
Too many attempts: the hub locks owner auth for 15 minutes.
Step 1 of 5 · 0% · nothing verified yet
1 · Who2 · The machine3 · The printer4 · The filament5 · The test print
The bar counts steps the hub has confirmed, not steps you have walked past. It survives a reload of this page: which step you are on, the machine's slug, and what has passed are kept in this browser. The setup code never is, and the node key lives only until this tab closes.
Step 1 · Who: the setup code
works once
The setup code was printed once, by whoever bootstrapped this machine on the hub, and it opens exactly one machine. Spending it, here or in the installer, trades it for a node key that belongs to that machine alone, and the hub will not answer the same code again. That is the whole point of it: nobody has to send a key in a chat message, and if one friend's PC is ever compromised, every other printer is untouched.
The installer asks for this same code, and if you are going to run it, the normal way, let it have the code rather than spending it here: it writes the key into the two config files without ever putting it on a screen, and prints the machine's name when it finishes. Come back with that name and use the second field. Claim it here instead if you are setting the node up by hand, or if you want to see the key. Either order works; step 2 says what to do with each.
CLAIMED––
–Held in this tab only.
This is the only copy. The hub stores a PBKDF2 hash of it, the same way it stores the three access codes, so it cannot show it again, not to you, not to us. Copy it into the node's config before you close this tab. Closing the tab is also how you get rid of it: it is held in this tab's own storage and nowhere else, and “Forget it now” empties that immediately once the node is running.
The name the installer prints when it finishes: “Done. This machine is x1c-002.” Also the way in for a node that has had its key for ages: node 001 is one, and it still authenticates with the hub's original shared key. Knowing a slug grants nothing on its own: the queue, the filament and the send path all still want the owner code, and the public machine list names every slug anyway. This page checks the hub lists it before accepting it, and then has no key to show you, because it never had one.
Step 2 · The machine: name it and install the node
3 to fill in
Two pieces run at the machine: the agent, which listens to the printer over your own LAN and pushes a status snapshot outward, and the slicer worker, which runs Bambu Studio headless so a friend's drop comes back with a time and a weight. Neither opens a port. Neither needs a tunnel, a public address or a hub of its own: the hub is already public, and both pieces dial out to it. What they do need is the slug and the node key from step 1.
The model is not decoration: it picks the two profile names the slicer hands to Bambu Studio. Only the X1 Carbon pair has been run end to end on a real machine. For any other model, open PROFILE_ROOT/machine and PROFILE_ROOT/process and check the names match what is installed there: the worker refuses a profile it cannot find and says which one it wanted, which is a slice failure in step 5 rather than a bad print.
Also load-bearing. Every filament profile carries a bed temperature per plate type, and a filament with no temperature for the current plate is refused before a single layer is planned: PETG Translucent on the Cool Plate is the case that bit us. Bambu's own spellings, exactly as the worker expects them.
Reading what the hub already has for this machine…
The command
–
Run it on the computer that sits on the printer's network: the always-on one, not this phone. It asks four things: the setup code, where the printer is (press Enter and it looks), the printer's serial, and whether the queue may start prints on its own. Then it writes both config files, checks the agent and the slicer, and registers two scheduled tasks so they come back after a reboot. No admin rights, no ports opened, no pip install: both pieces are standard library only.
–
By hand, without the installer two files
The installer writes exactly these, and reads them back on a second run. Three values in the agent's file can only be read off the printer itself: the LAN access code (touchscreen → Settings → WLAN/Network, at the bottom; it rotates whenever LAN Only mode is toggled), the serial (the chassis sticker, 15 characters starting 00M), and the printer's LAN address. None of the three ever reaches the hub: they stay in that file, on that machine. When the files are in place, these two say whether each half is happy, and name what is wrong when it is not.
–
printdrop-agent/config.env
–
printdrop-slicer/config.env
–
One thing this step does not do: rename the machine on the hub. The display name, the model and the location that friends see came from the bootstrap that made this machine, and there is no route here for changing them, so if what you typed above differs from what the hub says, the hub's version is the one on the public card. What you typed is used for the node's own config and for this wizard's own sentences.
Step 3 · The printer: is it reporting?
waiting
This is the step that proves the LAN half. Nothing here asks you whether it worked: the wizard watches the hub's public machine list until this slug shows up reporting, which can only happen if the agent is running on the printer's network, is talking to the printer over MQTT, and has authenticated with the hub. It costs no owner call, that list is public, so it polls every few seconds for as long as you leave this step open.
––Waiting for the machine's first report…
State –Firmware –Reported –Slug –
NOT YETNothing has reported for this slug yet.Leave this page open while the node starts: the first snapshot usually lands within a few seconds of the agent running.
If it stays here, the four things that cause it, in the order they happen: the agent is not running, or is running in a folder without its config; the node key is wrong, and the agent's own log says hub rejected X-Agent-Key in as many words; the slug in the config is not this slug; or the printer refused the MQTT connection, which is nearly always the access code having rotated: read it off the touchscreen again and restart the agent. One command at the machine tells you which of the four it is: cd printdrop-agent ; py -3 agent.py --check. Firmware is shown when the machine reports it, and left blank when it does not, rather than filled in with something nobody read.
Step 4 · The filament: what is actually in the slots
–
The printer reads its own spools off their RFID tags, which is where the material, the colour, the Bambu filament id and the percentage left all come from. A tag it cannot read looks exactly like an empty slot, so a third-party spool, or a Bambu one with a dead tag, needs a name from you. That name is not cosmetic: it is what the slicer matches a filament profile on, and the filament id is what the finished file carries so the printer feeds from that tray instead of from the spool on the back.
There is no field for how much is left. A percentage is a reading off a tag, and one you would have to keep true by hand would be wrong by the end of the first print. A slot with no tag says so.
Reading the AMS…
NOT YETWaiting for the machine to report its slots.Every loaded slot needs a name: the printer's, or yours.
Confirming is recorded in this browser and nowhere else: the hub keeps no record of a wizard's progress, so this tick is a note to yourself that you have looked at the slots and they match the spools you can see from where you are standing.
Step 5 · The test print: the whole loop, for real
not run
A 20 mm cube, built in this browser as a binary STL, twelve triangles, 684 bytes, no asset to download, and then put through exactly what a friend's part goes through. It is dropped on the public endpoint with the friends code, so if it lands, the code you hand out works. The worker at the machine picks it up on its own and slices it, so if a time and a weight come back, Bambu Studio is installed and the profiles resolve. Then the wizard steps aside: the cube is a job in the queue like any other, and starting it is the owner's tick in the owner console about a plate only a person can see.
No stage here is ticked off on trust. Each one shows the hub's own numbers when it passes, and the hub's own sentence when it does not, and if the slice fails, this setup is not finished, whatever the bar above says about the first four steps.
The one you hand out: code 2, not the personal one, which the drop endpoint refuses on purpose. Held in this field for this drop only: it is never written to storage, and a reload loses it. The hub allows ten drops an hour from one address, so this is not a button to lean on.
Built from the slots you just confirmed, so the test goes through the same slot-to-tray path a real drop does. Leave it on no preference and the file carries no filament id, which makes the printer feed from the external spool: worth knowing, because that is a genuinely different result from the one you are testing.
NOT RUN1 · Build the test model in this browserA 20 mm cube, twelve triangles, written into an ArrayBuffer exactly as the drop page would read one off a disk.
NOT RUN2 · Drop it with the friends codeThe public endpoint, the same one the drop page posts to, no owner credential involved.
NOT RUN3 · The worker slices it, unaskedNobody presses anything for this one. The worker polls the hub about every twenty seconds, so give it a moment.
NOT RUN4 · The owner sends it and the printer takes itYours to do, in the owner console, after looking at the plate. This page watches for the outcome.
The last stage opens once there is a sliced cube waiting.