Onion skin, references and the camera

Onion skin

Previous drawings tint red, next drawings blue. The checkbox on the timeline bar turns it on; the two number fields beside it, under Ghosts, are how many drawings to show before and after the playhead, asked separately because working forwards usually means two behind and none ahead. They start at 1 and 1, so onion skin out of the box is one drawing each way — raise them to see further. Ghosts sit directly under the layer they belong to, so multi-layer onion reads correctly, and they are off during playback — the one thing playback has to show is the animation.

Two switches, and both have to be on. The checkbox says whether onion skin is on at all; each layer's own ◉ (in the Layers panel, and on the shortcut bar for the layer you are drawing on) says whether that layer ghosts. A new layer starts with its ◉ off — the first layer of a new document included — so turning onion skin on shows nothing until you pick the layers worth ghosting: usually the line, rarely the colour, shading and effects underneath it. A document saved before this keeps every layer as it was.

The same controls are on both the Timeline and the X-sheet bars, because onion skin belongs to you rather than to whichever view of the animation you have up. They used to be on the X-sheet's bar alone, which made the Timeline tab look as though one drawing each way was all it could do. The on/off switch — along with Keyed drawings only and the motion trail — is also on the Animation menu, so it can be reached with the timeline hidden; the dials stay on the bar, where a slider belongs.

Everything else is behind the ⚙ next to those fields:

Setting	What it does
Mode	Frames ghosts this layer's other drawings. Light table instead dims the other layers at this frame, as sheets under the one you are drawing on. The paper is left alone.
Opacity	How visible the nearest ghost is.
Falloff	What each further ghost is worth, and the setting that decides whether a deeper ghost is visible at all. It compounds, so it bites fast: at 0.5 the third ghost is an eighth of the nearest one's opacity, which against paper is nothing — raise the depth to 3 at that setting and it looks as though nothing happened. The default is 0.75, which at the default opacity gives 0.35, 0.26, 0.20, 0.15 — four you can read, still clearly ranked by distance. At 1 they are all equally visible, which is right for checking registration across a sequence.
Keyed drawings only	Step by drawings rather than by frames. On 2s or 3s the frame before is a hold of the drawing already on screen; this walks to the real one.
Draw over the current drawing	Ghosts on top instead of underneath. Under is how a lightbox works and is what you want while drawing; over is for checking a line you have just made against the one it should match.
Before / After tint	The two ghost colours. Red and blue by convention.

A ghost counts drawings, not frames: on 3s the drawing three frames back is still the first ghost, and gets the strongest opacity.

Per-layer, the ◉ beside a layer's name in the timeline's layer column opts that layer out of ghosting entirely — the background you never want ghosted, or a layer you are not working on. The one on the canvas shortcut bar does the same for the active layer.

If you raise the depth and see nothing new appear, the falloff is why, not the depth. Every ghost you asked for is being drawn; the ones further out are simply too faint at a low falloff. Take the falloff up before you take the depth down.

Ghost poses. Pin as ghost keeps the current frame ghosted from everywhere else in the sequence — the extreme you are animating towards, however far away it is. Depth cannot express that, because the distance is the point. Clear pins removes them all. Pins are saved with the document; a document that never pins anything stores nothing for it.

Onion settings belong to you, not to the artwork: they are kept across sessions, survive rearranging or switching workspaces, and opening another document does not reset them.

The motion trail

Motion trail, beside the onion controls on the timeline bar, draws a line through where the subject is on each drawing around the playhead, with a tick per drawing — earlier ticks red, later ones blue, the current drawing ringed in white. How many drawings it runs through each way is set behind the ⚙, under its own heading — separate numbers from the ghost depths, because a spacing chart wants more drawings than anyone wants ghosted, and starting at four each way.

The gaps between the ticks are the spacing. Even gaps read as even speed; gaps closing up read as an ease-in — the same chart animators draw on paper margins, taken off the drawings you already made. A hold is one tick, not a pile of them, so counting ticks counts drawings.

Where each tick sits comes from the drawing itself: a pivot anchor placed on the drawing (rig edit mode, Ctrl+K) if there is one, else the centre of the drawing's ink — the ink that is there, so work you rubbed out does not drag the tick towards where it used to be, and neither does the eraser's own path. A filled tick is an anchor — your own statement of where the subject is; a hollow tick is the derived centre — a guess that wobbles with the silhouette. If an arc looks wrong on hollow ticks, anchor the drawings before trusting it. Sockets are ignored: a hand's attachment point is not where the character is.

The trail follows the active layer, is view-only — it never touches the document — and like the ghosts it is off during playback, coming back the moment you stop. Its settings are kept with you across sessions, like onion skin's. It has no key out of the box; Configure → Shortcuts → “Show motion trail” binds one. A drawing with strokes bound to bones is trailed where it was drawn, not where the pose moved it — trailing the posed motion is Planned.

Reading the trail: the analysers

Behind the same ⚙, under Analysis, three readers ride the trail. They only speak while the trail is on — they annotate its ticks — and each is a shortcut you can rebind (Configure → Shortcuts, gestureless out of the box). Whatever they have to say appears as text under the checkboxes, following the playhead.

Spacing targets puts a dashed amber tick where the intended spacing wants each inbetween — the extreme's timing chart if it has one, else the easing picked on the X-sheet bar — with a tether from any drawing that misses its mark. The targets sit on the path you drew: the assistant re-times your motion, it never straightens it. Nudge to spacing then moves the playhead's drawing along that path onto its target — the whole drawing, anchors and all, as one undo step. Extremes are never nudged; they are the statements the spacing is measured between. A drawing with a pixel baseline, or with selection-clipped strokes, is refused whole rather than having its ink moved out from under its pixels or its mask.

Jump arc fits a gravity arc to the run the playhead is in — extreme to extreme, constant speed across, constant fall down — draws it dashed, and rings any drawing sitting off it. Four drawings with a subject are the minimum: three fit any parabola, so the first honest verdict needs a fourth. A run whose best fit accelerates upward is called out as not reading ballistic at all. Frame the jump with extremes — and where the run carries "contact" markers (yours, or Detect contacts'), the fit trims itself to the airborne stretch between them, so a crouched takeoff or landing never drags the arc.

Walk cycle report reads the walk under the playhead — the tag's range if one covers it (so "frames 30–70 are the walk" is a tag, the same object an engine clip is), else the whole layer — and reports in prose: whether the loop closes, whether the contacts land evenly, whether the bob matches between steps, and whether the planted foot holds its place — still on the ground in a travelling walk, treading at a constant rate in place. The loop checks only run when the range is meant to repeat: the tag's own Loop flag decides, and without a tag, standing in place does. It is advisory — a deliberate shuffle is allowed to trip it — and it needs at least four drawings with ink.

The ground doesn't have to be flat. Name a line guide "ground" (View → Guides, then name it in its options) and every foot, bob and gravity reading measures against that line at whatever angle it lies — slopes and tilted layouts read correctly. Without one, the ground is the lowest ink the sequence reaches, horizontal, as a sprite cycle expects. And when the drawing changes size across the range — a character walking toward camera — the analysers say so and stand down rather than flagging staging you meant: a flat reading of depth motion would only cry wolf.

Through the camera (needs a camera) re-judges spacing and the jump arc on each drawing's projected position — what the audience sees, not what the world does. Spacing that is even in the world can bunch up on screen under a zooming camera; the ghost targets still land in the world, at the place whose projection is even, so the nudge works exactly as before. The jump verdict is then about the read — correct gravity can legitimately fail to read as an arc under a camera move, which is worth knowing and not an error — and the walk checks stay in the world either way: a camera move cannot make a foot slide.

The arc, and the predicted position

Two more switches live behind the ⚙, under the trail's depths, and both draw in gold — one added colour for one added concept: what the fitted arc has to say. Switching either on switches the trail on with it, since both are read off its ticks.

Arc fits a smooth arc — a circle, or a straight line where the motion is straight — through the ticks, and draws it under them. A drawing that sits off the arc gets a gold ring and a pull-line to where it would land on it: not just this drawing breaks the arc, but move it about here. The fit is forgiving of one stray drawing — it finds the arc the rest agree on and blames only the stray — and "off" is judged against the size of the motion, so a three-pixel wobble matters on a settle and not on a screen-wide throw. It takes at least three ticks; two positions agree with every arc through them.

Predict the next position marks where the drawing after your last one should go: a dashed tick on the arc's dashed continuation, spaced by carrying on your own spacing — an ease keeps easing. It appears only past the end of your drawings; a suggestion is never drawn on top of a drawing that exists. And when the playhead stands on an empty cel between drawings, a dashed tick marks where that drawing's subject belongs on the arc — the inbetweening moment. Everything dashed is a suggestion: the trail never touches the document, and drawing the mark is still yours to do. A stopped subject gets no prediction — where it goes after a hold is a timing decision, not geometry.

Both have unbound shortcuts — “Show motion arc” and “Show arc prediction” in Configure → Shortcuts. If the arc looks wrong on hollow ticks, the fix is the same as the trail's: anchor the drawings first.

Animation references

View → Reference opens a panel for importing an image of an animation — a sprite sheet, a strip of frames, a contact sheet, a run cycle you photographed off paper — and laying it against the timeline. The ＋ in the panel's header picks the file — or skip the panel entirely and drop the file anywhere on the window: any image dragged in from outside becomes a reference, the panel opens to show it, and a dropped video goes through the same import questions the ＋ asks. What Lightbox keeps is the image, not the path, so a reference never breaks because the file moved.

That includes pictures that were never saved anywhere: drag an image straight out of a browser and Lightbox fetches it and imports it the same way, named after the file in its address. Sites like Pinterest wrap their pictures in links, so a drag off one carries the page as well as the picture — Lightbox takes the picture, and falls back to reading the page only when there is nothing better. Because that fallback is the site's guess rather than your choice, the status line says so when it is used.

If a site fights you, the route that always works is to open the image on its own — Open image in new tab, or Copy image address — and then drag that tab's picture in, or paste the address with Ctrl+V.

Lightbox finds the frames in it by reading the gaps between the drawings, and puts the first on the frame you are on, the second on the next, and so on. The timeline grows to fit if it is shorter than the reference. If the document has no drawing on those frames yet, that is the point: they are what you are about to draw.

The frames it finds are windows onto the sheet, not crops of the drawing inside each one. A runner who travels across their cell still travels when you step through the reference — cropping each frame to its own artwork would put the character in the same place every time and delete the animation.

Setting	What it does
Show on canvas	The reference sits over the paper and under every drawing, like a photograph taped to a lightbox. It is never exported, and it is never in the artwork.
Follow timeline edits	On, inserting a frame moves the later references along with the animation, and the new frame gets no reference — you are drawing an inbetween, and there is no reference drawing for it. Off pins the reference to absolute timing, for matching a shot frame for frame.
Scale	One scale for every frame. Per-frame scale would put the character at a different size on each drawing, which is the one thing a size reference exists to prevent.
Opacity	How strongly it reads under your drawing.

A character sheet, taped to the canvas

The ⧉ button beside a view in the Reference sheets panel tapes a flattened copy of that view onto the canvas — over the paper, under every drawing, on every frame. It is the same kind of reference as an imported sheet, so everything in the table above applies: drag it, scale it, set its opacity with the same slider, and it is never exported and never in the artwork. Click ⧉ again to take it down.

It stays live: draw on the sheet — in its tab, or hide one of its layers — and the taped copy on the canvas updates by itself. Undoing the sheet edit updates it back. A view that is later deleted leaves its last picture standing, the way a missing video file leaves its extracted frames.

Another document to draw against

With the jump open, right-click the run in the project panel ▸ Reference in current document — or drag the run's row onto the canvas. The run's frames are laid under the jump the way an imported sheet is: its first drawing on the frame you are on, the next on the next, the timeline growing to fit. The ＋ in the Reference panel does the same for any Lightbox document (*.lightbox.json), in a project or not, and so does dropping one onto the window. Everything in the table above applies — scale, opacity, lock, Follow timeline edits, aligning frames by hand.

Your other file is only read. Lightbox opens it to look, never to edit, and never saves it — so referencing the run cannot change the run, however long the jump is open.

Each frame is flattened into one picture: every layer the run shows, without its paper, so the reference does not cover the paper it is taped over. Layers hidden in the run stay hidden.

Frame for frame, not by the clock. The run's drawing 1 sits under your frame 1, drawing 2 under frame 2 — even when the two documents run at different frame rates. That is what you draw against; matching a shot to the second is what turning Follow timeline edits off is for.

It lines up. When the two documents have the same canvas size, the run lands exactly where it was drawn — its feet on your ground line — rather than being fitted and centred. A different-sized canvas fits and centres it like any imported picture.

The panel says what it is linked to. Under the reference's name: Linked to "run" · from its save at 14:32 — the run's own save, so you can tell which version you are drawing against. It says flattening… while it works, not found — showing its last frames if the run has gone, and it has unsaved changes — save it to update when the run is open with edits the reference cannot see yet: the reference reads the saved file, not the tab. Refresh now flattens it again on the spot, and Open source takes you to the run — its tab, if it is already open. Both can be given keys in Configure ▸ Shortcuts.

It stays current. Save the run — in another tab, or another copy of Lightbox — and the next time you come back to the jump, its frames are flattened again. Your placement, opacity and per-frame alignment survive the refresh; a run that gained drawings lays them on after the old ones. If the run is moved or deleted, the jump keeps the last frames it had, so nothing you were drawing against disappears. A document cannot reference itself.

Flattening takes a moment on a long run — a 31-frame 1080p cycle is about ten seconds — and it happens in the background: the status line says Flattening… and you can keep drawing.

A long run wraps into a second column rather than shrinking, so a big character keeps its full resolution.

What it will not follow. A document on a network share is refused — copy it to this machine first — because a reference is re-read on its own, and Lightbox will not reach out to another computer without you asking. A reference saved as a path beside this document only ever looks beside it. And a source too big to be a reference — more than 2,000 frames, or a canvas past 64 megapixels — says so rather than trying.

The reference board

View → Reference board…, the Board… button at the top of the Reference sheets panel, the 🗔 icon beside any view in it, or Ctrl+Shift+B — all open the reference board: a wall of reference beside the easel, instead of one picture opened in the drawing's place. Put it on a second screen, or beside the canvas, and draw.

It does not need a character sheet. With no sheets at all it opens empty and you drop photographs on it — that is a perfectly ordinary way to use it.

Where there are sheets it fills itself: every reference sheet the document can consult is pinned up, each view flattened to one picture rather than a stack of layers, laid out to fit the window. Sheets belonging to a folder above the document are in scope, so a knight's animations all open the knight's wall.

The board is bigger than the window. It extends as far in every direction as you drag something, so pictures go wherever you want them and the window is a view onto the wall rather than the whole of it.

To do this	Do that
Move a picture	Drag it. Picking it up brings it to the front
Resize it	Drag its bottom-right corner. The shape is kept
Change the stacking	Right-click ▸ Bring to front / Send to back
Put one on the canvas	Right-click ▸ Project onto the canvas — see below
Lay one onto the timeline	Right-click ▸ Lay onto the timeline as frames — the frame analysis the Reference panel's ＋ does, fed from the wall
Take one down	Right-click ▸ Take off the board, or Delete
Tidy the whole wall	Auto-arrange — every picture fitted into the space there is, in the order they are in
Find something you have lost	Fit (Ctrl+Shift+F) zooms out until everything on the board is on screen
Add a picture from disk	Drag files onto the board, or Add…
Add another document	Add… and pick a Lightbox document — its frames, flattened and stacked in a column (see below)
Add one from a web page	Drag the image off the page onto the board — as many times as you like
Paste one	Ctrl+V — a copied file, a screenshot (PrtScn, Win+Shift+S, the Snipping Tool), or an image address copied out of a browser
Put a sheet back up	Sheets ▾ lists everything in scope that is not on the wall
Move around	Wheel zooms, middle-drag or drag the empty background pans

Paste takes an address too. Ctrl+V pins a copied file or a copied picture — a screenshot, most often — and, failing both, whatever address the clipboard is holding. So Copy image address in a browser and Ctrl+V here is a second route in when a drag will not do it, and it is fetched exactly the way a dropped address is. A picture on the clipboard still wins over an address on it: it needs no network and cannot be refused.

The board accepts the drag and then tells you. The pointer will not refuse a drag on the way in, even one holding nothing Lightbox can use — because a cursor that says no explains nothing and leaves no trace. Let go, and the board says what happened.

Whose wall is this? In a project a board belongs to a folder, so every animation of the same character looks at the same reference. The board takes the nearest folder at or above the open document that already has a wall, and starts a new one on the document’s own folder when nothing above has one — so a project organised characters/Ren beside characters/Goblin Archer gives each of them their own. The toolbar says which folder it is, and Wall for… moves it: pick a folder further down to split a shared wall into one per character, or further up to merge them back. The pictures move with it.

A drop that brings nothing says so — on the board. Browsers hand a picture over in more than one way — sometimes the file it cached, sometimes an address, sometimes the picture itself — and they label those differently on Windows, on macOS and on Linux. Lightbox reads whatever the drag turns out to be carrying and tries all of it before giving up. What decides is whether the bytes are a picture, not what anything is called, so a browser's nameless temporary works like any other. When the address turns out to be the page the picture lives on — which is what many sites, Pinterest among them, put in a drag — the page is read for the image it names and that is fetched instead.

Reading a page is the last thing tried, not the second. A drop learns the picture three ways, and each is more of a guess than the one before it: an address that is a picture, then the picture the drag is carrying itself, and only then a picture that some page merely names. That last one is the site's answer to what is this page about — and a great many sites answer it the same way on every page, with one social card. Pinterest is the plain case: its feed, its boards and its search results all name the same collage, so a drag off any of them used to pin the Pinterest logo. Lightbox now recognises that card by comparing it with the one the site's front page names, and refuses it; if that leaves nothing, the drop says so rather than pinning something you did not ask for. When a page's picture is taken, the board says so, because it is a guess.

Only when every one of those fails does the drop refuse, and then the board's own toolbar says which way it failed rather than leaving you wondering; what the drag was carrying is written to the diagnostics log, which is the thing to attach if a drop that should work does not.

A document on the wall is its frames, top to bottom. Add… pins another Lightbox document up as one picture: every frame flattened the way Another document to draw against describes, stacked in a column — two columns for a long run. It is read and never changed, and it refreshes when the document is saved, keeping its place and width on the wall. Lay onto the timeline as frames on it lays out that document's own frames, linked and live, rather than guessing them back out of the picture; Project onto the canvas pins the whole column, like any picture.

A picture lands where you put it — under the pointer when you drop it, in the middle of the view when it comes from the picker or the clipboard. Drop several at once and they fan out from that point rather than stacking exactly.

The sheets on it stay live: draw on a view in its tab, hide one of its layers, undo, and its picture on the board updates by itself. Drawing still happens in the tab, not on the board. A view deleted from the project comes off the wall; imported pictures answer to nothing in the document and stay.

The arrangement is remembered. It is saved as you make it, and belongs to the folder the references belong to — so every animation of the same subject opens the same wall, where you left it, in the session after this one. A document that is not in a project keeps its own board inside the file instead.

Imported pictures are copied into the project, into a references folder beside your art. The original can be moved, renamed or deleted afterwards and the board is unaffected — which is the point, since a picture dragged off a web page has no file to point at in the first place.

Opening it again brings the board you already have forward; there is one board window, not one per picture, and it closes with the application.

Projecting a board reference onto the canvas

Right-click any picture on the board and choose Project onto the canvas to tape it over the drawing area — any picture, not only sheet views: a file from disk or an image dragged off a web page projects the same way. The projection sits over the paper and under every drawing layer, so an opaque background does not hide it and your lines always draw on top. It is not a layer: it never appears in the layer stack, never reaches an exported pixel, and its opacity is the reference opacity slider like any taped-up reference.

The projection keeps its link. A sheet view stays live — draw on the sheet in its tab and the canvas copy follows. Asking the same tile again takes the projection down rather than stacking a second copy, and the board's menu reads Take off the canvas while one is up.

On the canvas itself:

To do this	Do that
Select a projected reference	Click it with the Arrow (A). An amber box appears round it
Move it	Drag it, once it is selected
Scale it	Drag a corner. The opposite corner stays put and the shape is kept
Let it go	Esc, or click where there is no reference
Lock it	The 🔒 on the canvas shortcut bar, or Locked in the Reference panel
Lock every reference	The second lock on the bar, or Ctrl+Alt+R
Line up one frame against your drawing	Align on canvas in the Reference panel, then drag — see Registering the frames below
Bring it forward or back	Right-click ▸ Bring forward / Send backward (or to front / to back) among the other references
Take it down	Right-click ▸ Take off the canvas, or the board's menu

Forward and back move a reference among the other references — the whole stack stays beneath the drawing layers, which is what a reference is for.

The drawing always wins the click. A reference is picked up where there is no art under the pointer — its corner grips are the exception, because they are small and deliberate. A plate covering the page would otherwise make every line under it unclickable.

Locking is about the pointer and nothing else. A locked reference still draws, still follows the timeline, and can still be selected — the box appears without grips, which is how you can see why it will not move. It is what to reach for the moment a reference is registered against your drawing, so the next stray drag cannot knock it out. The lock on the reference travels with the document; lock every reference belongs to your workspace, the way the guide lock does.

One drag is one undo. Moving or scaling a reference takes a single Ctrl+Z to put back, however far the pointer travelled.

Selecting and moving are two gestures, on purpose. The first click takes hold, the drag after it moves — so a marquee started over a reference is still a marquee. Switching to another tool lets the reference go.

Projecting and laying onto the timeline are different acts. A projection is one picture pinned over the paper on every frame. Lay onto the timeline as frames instead runs the picture through the same analysis as the Reference panel's ＋ import: the frames are found in it (a sprite sheet, a strip, a run cycle), laid against the timeline from the frame you are on, and the timeline grows to fit. The Reference panel opens so you can fix the grid (Cols/Rows ▸ Apply grid), rescale, and align — everything in Animation references above applies. Laying the same picture twice is two imports, exactly like pressing ＋ twice; taking a projection down never touches a laid-out animation.

What detection actually looks for. Not gaps in the whole image — the drawings themselves. It finds every connected mark on the sheet and then throws away what is not a drawing: specks and watermarks go because they are tiny next to a figure, and a title banner goes because a line of text is a fraction of the height of a row of figures. What survives is grouped into rows, and each row is cut into cells of equal width. So a page with a heading and a signature on it works, not only a clean sprite atlas.

When detection cannot find the frames. Two rows that touch have no boundary in the pixels, and no amount of looking finds one that is not there. Set Cols and Rows and press Apply grid and the image is not consulted at all. Detect goes back to reading it. Or edit the boxes by hand — see below.

Video to draw against

The same ＋ also takes a video clip (MP4, MOV, AVI, MKV, WebM) — the drawn-over-live-footage workflow. The clip's frames are extracted at the scene's own fps and laid against the timeline like any reference: frame 1 under frame 1, the timeline growing to fit, your drawing layers on top.

On import you choose what the clip is for, and each purpose has its own storage:

• Reference — keep by path (the default): the document stays light and the frames rebuild from the file when the document opens. If the file has gone, you are drawing against nothing until it is back — the drawing itself is never touched.
• Reference — embed the frames: the extracted frames travel inside the document at reference quality, so it reopens self-contained, with no FFmpeg and no file beside it. The original footage is not recoverable from the document — it is a reference, not an asset.
• Production — embed the clip: for the small production whose whole pipeline is Lightbox. The original footage travels in the document at full fidelity, shows at full strength, and — unlike every reference — composites into video and PNG exports, over the paper and under your drawings, exactly as the canvas shows it.

There is a budget on the extracted frames either way: reference quality (up to 480 px wide) and at most 240 of them — twenty seconds at 12 fps. A reference is for registration and timing, not for grading; production footage keeps its full-fidelity original alongside for the render.

Extraction runs through the same bundled FFmpeg the video export uses; on a machine without it, the import says so instead of failing quietly.

Editing the grid by hand

The ⊞ in the shortcut bar turns on grid editing. Every box on the sheet appears at once, the canvas stops being a place to draw, and Esc leaves. The mode is only there when a reference has been imported.

• Drag inside a box to move it.
• Drag a corner of the selected box to resize it. The box is a window onto the sheet, so growing it shows more of the drawing rather than scaling it.
• Drag on empty canvas to draw a box of your own — the way out when detection cannot see a boundary.
• Delete removes the selected box. The sheet is untouched; only the window goes.

Every box carries a pivot, drawn as a red cross: the point that should sit still from frame to frame — the contact foot, the hips. Until you place one it sits at the middle of the box's foot, which is where a standing figure's contact point usually is. It is recorded on the sheet, so nudging or rescaling the reference afterwards leaves it on the same part of the drawing.

Generate keyframes does two things at once, because they are one intention: the timeline grows until every box on the sheet has a frame, and the boxes are registered so their pivots land at the same place. An eight-frame reference on a one-frame document is not a state anybody asked for, and neither is a run cycle that has to be nudged into place eight times. Pressing it twice changes nothing — everything is measured against the first box, so the sheet cannot wander off the canvas one press at a time.

Registering on the pivot takes the travel out of a cycle, which is the opposite of what tiling the sheet does, and both are wanted: tiling keeps a runner travelling, and aligning lets you see the pose change underneath. Which you want depends on whether you are matching the walk or the drawing, so it is a button rather than a rule.

Alignment. Align on canvas turns dragging into lining the reference up rather than drawing: drag to move this frame's reference, hold Shift to move the whole sheet. The This frame X / Y fields do the same numerically, and they drag horizontally like every other numeric field. Alignment is per reference frame, because it is a property of that drawing — a frame shown twice is lined up the same way both times. Clear all alignment undoes every nudge on the sheet. Nudges are undoable.

Boxes can also be nudged several at a time: select them with the Select tool and the Move tool drags the whole selection, as one undo step. This moves where the boxes sit, never which part of the sheet they show — resizing a box is how you change that, and the two stay separate so lining up a pose cannot quietly recrop it.

Each reference is saved inside the document, image and all, so it cannot break by having a file move out from under it.

Camera

A camera is optional and absent until you add it. A document that never adds one shows no camera UI, serializes no camera keys and pays nothing for it. That matters because Lightbox has two output targets and neither is the default:

• Assets — sprite sheets and cycles. The canvas is the output. No camera.
• Shots — the canvas is a world and the camera frames part of it. The deliverable is what the camera saw.

Add one from the timeline bar. Pan, zoom and roll are keyframed and interpolated; set a key at the playhead, or clear it. Through camera previews the framing, and is remembered between sessions like the other switches on the shortcut bar.

With a camera, the canvas shows its frame in orange with everything outside dimmed — and the frame is a gizmo. Drag the square on its top edge to pan, a corner square to zoom (drag inward to push in, outward to pull back), and the circle floating above the top edge to roll. Each drag writes to the framing at the playhead, keying it there exactly as the numeric fields do — adjusting the camera is keying it. The handles are small on purpose: a press anywhere else on the canvas still paints, camera or no camera.

The camera is the one transform that is not view-only: it is authored, saved and exported. It still never touches a stroke — it only decides what part of the record a render shows.

Multiplane parallax — layer depth

Give a layer a depth and a camera move separates the planes by itself — classic Disney multiplane, without a rostrum. A pan slides a far hill less than the trees in front of it; a push grows the foreground faster than the sky. The depths live in the Scene panel (View ▸ Dockers ▸ Scene): one row per layer with its depth in canvas units, a marker showing where the plane sits, and the camera's path drawn across the page underneath.

Depth 0 is the picture plane — the canvas as it always was. 1000 shows half of a camera move, larger is further, and a small negative depth floats a layer in front of the plane so it moves more. Setting a depth back to 0 removes it from the file entirely.

Three rules keep it honest:

• Depth does nothing without a camera. No camera, no parallax — the world view, an asset export and every document you have ever saved are untouched. The Scene panel says so when the document has no camera.
• You see it where the camera sees it. Parallax shows in Through camera preview, playback through the camera, and every export — never in the plain working view, which shows the planes head-on so drawing stays simple.
• The drawing never changes. Depth is compositing, like the camera itself: strokes keep their coordinates, and clearing a depth puts the layer back exactly where it was.

Each depth edit is one undo step. Zoom responds too, geometrically — a distant plane grows less under a push, which is what makes a truck-in read as depth rather than as a scale.

---