The Studio manual

Mixos Studio is a 3D scene application that runs in a browser tab. You build or import objects, arrange and light a scene, animate it, and render it — no install, no drivers, no upload wait.

This manual covers the whole application, chapter by chapter: the workspace and viewport first, then your scene's structure, modelling, materials and lighting, animation and rendering, and finally the assistant and the keyboard. Each section opens with the idea in plain language and then names the individual controls worth knowing. Read it top to bottom the first time; afterwards each section stands on its own.

The layout above is what Studio opens as. Nothing in it is fixed: panels can be closed, moved to the other column or floated as windows, the viewport can be split into as many as four panes, and any arrangement you build can be saved as a section of your own. What does not move is which question each region answers.

1. 1
   Put something in the scene — Use the create rail down the left edge — Mesh for a primitive, Import for your own file — or open the starter scene from the welcome card. A new object becomes the selection immediately, so the inspector is already showing its numbers.
2. 2
   Move it — Pick it in the viewport or in the outliner, then drag the gizmo handles or type into the inspector's Position, Rotation and Scale fields. The two are the same values shown twice.
3. 3
   Give it a surface — The materials bar along the bottom holds the materials this scene owns. Library opens a catalogue of a few thousand ready-made CC0 surfaces; drag one onto the object.
4. 4
   Light it — Light on the create rail is three groups: lighting the whole scene at once, a single lamp, or a complete three-point rig. The rig is the one to start with.
5. 5
   Save it — ⌘S. Saving works signed out — the document is kept in this browser — and signing in is what makes it reach your other devices.

Where a panel lives is yours, not the app's. Every panel can be closed, collapsed, moved to the other column, or floated as a window you position over the viewport — and the arrangement you end up with can be saved as a section of your own.

Window in the menus is the index of every panel, and it is where a panel you have closed comes back from. If something has gone and you cannot find the button that brings it back, that is the menu.

The viewport itself splits. View in the viewport header offers one pane, two side by side, two stacked, or four at once, and each pane keeps its own camera and its own shading mode. A quad layout showing front, side, top and a perspective view of the same scene is the arrangement most modelling is done in, and it costs nothing to try — a pane layout is a way of looking, not a change to the document.

The divider between any two regions is draggable, so a column can be widened for a panel that needs it and narrowed again afterwards. Sizes are remembered per section, which is why the Animation section can keep a tall timeline while Standard keeps a short one.

The bar across the top of the window is split into three zones that never trade places: identity on the left, the current view in the centre, and utilities on the right. Once you know which third a control lives in, you stop hunting for it.

On the left is the Mixos mark — which takes you home — the app name, and the name of the scene you are working on. The scene name is a button: click it to rename the document, which is also the fastest way to check you are in the file you think you are in.

Beside the name sits the save chip, and it is a readout and a control at once — clicking it saves. It has five states worth recognising. Unsaved in amber means there is work the saved document does not have. Saving… is in progress. Backing up means it is safe on this machine and on its way to your account. This device means it is saved in this browser only, which is what a signed-out save looks like — it is not a warning, but it is also not a backup. Saved in green means it is in your Scenes library.

The centre holds the menus and the section switcher, both covered in their own sections below.

The right holds the things that apply to the whole document rather than to your selection: undo and redo, Send to — which hands the selected object across to Paint or Mold — Export, and your account.

Studio is divided into sections, and the section you are in changes the whole window rather than one panel: the viewport lane, the side column and the available tools all follow it. Modelling controls simply do not apply while you are setting up a render, so they are not there.

This is why sections are a switch in the top bar and not a checkbox inside a panel — a mode with its own layout is a workspace, and giving one two different doors is the scatter this interface has deliberately dismantled.

Standard is the general-purpose arrangement and the one to stay in until you have a reason not to. Modeling puts the mesh tools and an edit-mode-shaped layout in front of you. Assets opens the catalogue, your own saved models and surfaces, and the generators that make new ones. UV opens the unwrapping workspace, with the texture atlas beside the model. Rigging is for characters — skeleton, skin weights, IK controls and the motion library. Animation brings up the timeline and the transport in one tall dock. Rendering turns the viewport lane into the output and the column into the render settings. Generate is the AI creation surface.

You are not limited to those eight. Any arrangement you build can be saved as a section of your own, and saved sections join the same list as the built-in ones — Window ▸ Workspace saves, resets and deletes them.

The menus are the complete index of what Studio can do. Everything the rails, the context bar and the panels offer is also in here, which is the property that makes them worth opening: a control that has gone away because it did not apply to your selection has not gone anywhere.

There are nine — File, Edit, Create, Select, Mesh, Modify, Animate, Render and Window — and in the default layout they are folded behind the ☰ trigger in the top bar to buy the chrome back. Opening it nests them as submenus, so File ▸ Recent ▸ … still works and nothing is stranded.

Window is the one to know about early. It opens and closes the individual panels — the material editor, the graph editor, the Stats page — and holds the workspace commands, which is where a section you have arranged yourself gets saved.

Then there is ⌘K, which is the same index without the browsing. Type what you want and it finds the command by name, shows what it does, and runs it. Every command Studio has is in here, including the ones no panel offers today, and every one of them is the same code the menus run.

Window ▸ Preferences…, or ⌘,. This is the one place Studio is set up, and it holds five things: autosave, scene units, the keyboard layout, the camera gestures and the viewport backdrop. Nothing in it changes your scene — units are the one entry that is saved with the document, because what a number MEANS is a fact about the file rather than about you.

Autosave keeps a background copy of the whole scene in this browser, so a crash or a stray reload can offer the work back. The line under the switch is the live status — the interval, whether there are changes no copy has captured yet, and whether something is waiting to be recovered. It is not a save: File ▸ Save is what puts a scene in your library, and an autosave only survives on this device.

Units decide what a number means. Off, everything is a bare number and measurements come back in world units. Metric or imperial gives them a physical size, and *metres per unit* is the setting that matters for imported work — a model authored in centimetres reads correctly the moment you say one unit is 0.01 metres, and no geometry moves. The display unit can be pinned or left on auto, which picks one per value so a 3mm bolt and a 2km road both read naturally.

Keyboard picks whose transform letters the viewport uses — MixOS/Maya's W/E/R, Blender's G/R/S, or Cinema 4D's E/R/T. It is the same picker the ? sheet shows, and *See all shortcuts* opens that sheet for the full list.

Navigation is a table you read rather than a setting you change, and that is the point of it. Every DCC's camera gesture is live at the same time — ⌥-drag orbits the way Maya, Cinema 4D and Spline do, middle-drag orbits the way Blender does, space-drag pans the way every design tool does — because each scheme distinguishes orbit from pan from dolly with a different modifier, so they do not collide. There is nothing to set: if your hand already knows one of those apps, it already works here.

Viewport holds the backdrop — the shade behind your model, in three stops. It is the room you are working in, not the background of a render; that is a separate setting on the render itself, because the two answer different questions.

The strip along the top of the viewport controls how the scene is drawn rather than what is in it. Nothing here changes your document.

The shading strip is the leftmost control, and its three modes read as a ladder of what each one adds. Wire draws edges only — no materials, no lighting. Clay puts a single clay colour on everything under a fixed studio rig, ignoring both your materials and your lights, so that all you are reading is form. Materials shows your materials under the scene's own lamps and world.

Beside it, the Display menu holds the overlays, the preview-lighting switches, the HDRI backdrop and the viewport quality setting — which runs from Off through Low, Medium, High and Full, with an Auto that picks for your device and a Custom for setting it yourself.

There is also a dedicated overlays button rather than only a menu row, because “what does this actually look like?” is a question asked a dozen times an hour and answered by looking. One click hides the grid, gizmos, handles and selection outline; one click brings them back. It lights up when overlays are OFF — lit here means this viewport is not showing you everything.

View at the far end is the pane layout: one viewport, two side by side, two stacked, or four at once. Each pane keeps its own camera and its own shading mode, which is what makes a quad layout useful — front, side, top and a perspective view of the same scene, all live.

The small axis marker in the corner of the viewport shows which way the scene is oriented. It is also a control: clicking one of its axes snaps the camera to look straight down that axis, which is the fast way back to a square front, side or top view after you have orbited somewhere confusing.

The colours are the standard ones and they are worth memorising, because they are the same colours used everywhere else a direction is named: the transform gizmo's handles, the inspector's Position, Rotation and Scale fields, and the per-axis tracks in the timeline. X is red, Y is green, Z is blue, in all four places.

The context bar shows the controls that apply to what you have selected right now, and only those. It is empty with nothing selected, and its contents change as the selection does — which makes it the fastest way to find out what an object can actually do, without reading a menu.

It floats over the viewport as an island rather than sitting in a band above it, so the controls for the thing you are working on are near the thing you are working on.

Nothing in this bar is ever greyed out, and that is the rule the whole surface is built on: a disabled control still costs a slot, still has to be read, and still cannot be used. If it does not apply, it is not here. That is also the disclosure mechanism — you never meet Align until you have selected two objects, and by then you know what it would do.

Select several objects and alignment appears: nine ways to line objects up, three per axis — by their left edges, their centres or their right edges on X, by bottoms, centres or tops on Y, and by backs, centres or fronts on Z. Select exactly two and Place on appears, which sets the first down on the surface of the second. Select three or more and Distribute spaces them evenly.

Open a mesh for editing and the bar becomes a different set entirely: the way out first, then which kind of element a click picks.

Points, Edges and Polygons decide what a viewport click selects, and picking one opens the mesh for editing on the way past — there is no separate mode to enter first. Beside them are the selection verbs that only make sense in here: select all and none, See-through so a click can reach elements on the far side, and Borders to pick the open edges of a hole.

Snapping constrains a drag so parts line up exactly rather than nearly. The chip in the context bar turns it on and says what it is snapping to, because “is snapping on?” and “on to what?” are one question.

There are five targets. Grid steps by a fixed distance in world units and is the one to leave on for laying things out. Vertex lands the drag exactly on another object's corner. Edge midpoint and Face centre are the two places on a face you most often want and cannot eyeball. Object origin snaps to another object's pivot, which is how you stack things that were modelled around their own centres.

Three numbers govern it, and they are measured in three different things. Grid spacing is in world units — the distance objects step by. Rotation step is in degrees and applies to every rotate drag. Capture radius is the odd one out: it is measured in screen pixels rather than world units, so it stays the same size to your eye at any zoom. That is deliberate — a capture radius in world units would grab everything when you zoomed out and nothing when you zoomed in.

The outliner lists everything in the scene as a hierarchy — objects, cameras, lights and the world itself — and is where you select, rename, group, reorder and reparent. Selecting a row selects the object, and vice versa.

The world is a set of rows in this list rather than a separate dialog: the sun and the environment sit in the hierarchy alongside your objects, because they are part of the scene in exactly the way an object is, and hiding them somewhere else is how new scenes used to end up unlit without their author noticing.

Selecting a row selects the object, and selecting in the viewport highlights the row — they are two views of one selection. Drag a row onto another to parent it, which is how you say “this moves with that”; drag it out again to unparent. Grouping several objects puts them under one parent you can move as a unit.

Each row carries its own visibility and lock toggles. Hiding is a viewport convenience; locking is protection, and it is the answer to accidentally dragging the floor every time you try to select something standing on it.

The footer counts what is in the document and how much of it is selected. It is the honest count — the outliner lists what exists, including whatever is hidden, locked or filtered out of view.

The strip above the outliner's tree. A layer is a named, coloured bucket an object can be filed onto, independent of where it sits in the hierarchy — Cinema 4D's layers, Blender's collections. Click a chip to narrow the tree to that layer; click it again to show everything. The ⋯ on a chip holds hide, lock, solo, select, the colour and delete.

Hide takes the layer's objects out of the working viewport and out of the marquee. Lock stops them being moved or edited, and every refusal says which layer is holding them. Solo shows that layer alone while it is on — a way to work on one part of a busy scene without hiding the rest by hand. Each row in the tree carries its layer's colour as a thin bar at the left edge.

Right-click an object ▸ Move to layer to file it, or New layer from selection to make one from what is picked. Select ▸ Select all in layer picks everything on the active chip. Layers are saved with the scene; pasting an object into another scene keeps its layer only when that scene has one of the same name.

The toolbar above the outliner filters and reorganises the list without touching the scene — useful once a document holds more than fits on screen.

Search filters the list to objects whose name matches, which is the main argument for naming things as you go. The kind filters narrow it to meshes, curves, lights or cameras — the fast way to find every lamp in a scene you did not build. Isolate selection narrows the list to what you have selected and its family. Reveal selection does the opposite and is the one to remember: it unfolds whatever group is hiding the selected object and scrolls to it, so a selection you made in the viewport stops being lost in a collapsed tree. Clear drops the search and every filter at once.

The inspector shows everything about the current selection, organised into tabs rather than one long scroll — transform, the object's own parameters, its material, and its modifiers. Tabs rather than a stack because a long scrolling column buries the control you came for.

Which tabs appear depends on what you have selected, and that is the useful part — the tab row is a list of what this object actually is. Object holds the transform: position, rotation and scale. Shape holds a generator's own parameters, so a parametric cube keeps its width and height as editable numbers. Mesh appears once there is real geometry. Material, Modifiers and UV are what they sound like. Motion holds drivers — motion described as a behaviour rather than keyed. A camera gets Lens; a text object gets Text; booleans, cloners, effectors, subdivision and splats each bring their own.

The transform fields and the viewport gizmo are the same values in two places. Dragging the gizmo updates the numbers live, and typing a number moves the object — use the gizmo to explore and the fields to commit.

The small diamond at the head of a row is its keyframe control: it says whether that property is animated, and clicking it sets a key at the current frame. Every numeric property in here can be keyed, which is why the timeline's track list can be so much longer than position, rotation and scale.

A UV map is the instruction for laying a flat image onto a 3D surface: every point on the mesh is given a coordinate on a square, so a texture knows where to go. Without one, a map has nowhere to land — which is why a material that looks right in the preview can come out black on the object.

The UV section opens the atlas beside the model. The pipeline reads left to right and the panel is in that order: cut the surface, unfold it, arrange the pieces, then verify.

Seams are where you cut. Think of unwrapping a paper model: the seams are the edges you would slice so it can lie flat, and putting them somewhere that will not be seen is most of the craft. Unwrap and Solve do the unfolding. Layout packs the resulting islands into the square with a margin between them.

Checks is the part worth knowing about, because the defects it counts are invisible until they have already ruined a texture. Overlapping islands paint two places at once. A flipped island paints mirrored. An island outside the square wraps around to the other side. Each check is a live count, and clicking a non-zero one selects the offenders — so the fix is the next click rather than a hunt.

The Stats page measures what your scene costs to draw — triangles, draw calls and memory — against what this particular device can comfortably handle, and lists the heaviest objects so you know where the weight actually is.

It appears once the document has something in it to measure; an empty scene has nothing to report.

The numbers are measured against this device rather than an absolute standard, because a scene that is comfortable on a desktop can be unusable on a phone. A figure in the clear is fine here and may not be elsewhere.

When a scene is over budget, the heaviest-objects list is where to start — weight is almost never spread evenly, and one imported model usually accounts for most of it. The fixes, in the order worth trying: hide what you are not working on, reuse one object many times rather than importing many copies, and reduce the density of the offender itself.

The History panel is the app showing its working. It has two folds: Undo history, which is every step you can take back, and Command log, which is every operation this session has run and what it reported. Open it from Window ▸ History.

Undo history lists the steps newest first, with a dot marking where the scene is now. Click a step above the dot and the scene rolls forward to it; click one below and it rolls back. This is exactly what pressing undo repeatedly would do — the panel only saves you counting the presses — so nothing here can take the document anywhere Ctrl+Z could not.

Each step carries a badge naming which part of the app owns it: the scene graph, the modelling tools, animation, sculpting, painting. Studio keeps one timeline over several independent histories, and the badge is what tells you which one a step belongs to. A step the assistant took is badged assistant instead, and a whole assistant turn is one step — so taking back what it did is a single click rather than an unwinding.

Command log is the other direction: what was asked for, and what happened. Each line names the operation, who ran it — you, a keyboard shortcut, or the assistant — how long ago, and a sentence describing the result. Refusals stay in the log, marked, with the reason: “it did nothing and I do not know why” is the question this fold exists to answer.

Copy as script turns the visible log into a script you can edit and re-run, which is the quickest way to turn something you did once by hand into something repeatable. It is a starting point rather than a finished macro — the operations name the objects that existed when you ran them, so a replay on a different scene needs those references changed. Paste it into Window ▸ Scripts… to run it.

Most first objects are not primitives — they are a file you already have. Drop it anywhere on the Studio window, or use Import at the foot of the create rail. There is no upload step to wait through: the file is read in the browser.

GLB is the one to prefer where you have a choice: it is a single file that carries geometry, materials and textures together, and it is what most exporters now offer. glTF is the same format unpacked into several files. FBX carries rigs and animation, which is why a character usually arrives as one, and it is also the format most likely to be large. OBJ is geometry only. STL and 3MF come from printing and carry no materials or UVs at all. SVG, AI and PDF come in as curves rather than surfaces, which is how a logo becomes something you can extrude.

What arrives is a hierarchy, not one merged lump: the parts the file had become rows in the outliner with their own names, transforms and materials. That is the difference from Paint, which loads a single mesh to texture — here the structure is the point, because you are going to move pieces around.

The create rail adds new things to the scene — primitives, curves, cameras and lights. A new object lands in the scene and becomes the selection, so the inspector is already showing its parameters when it appears.

The rail is grouped by what you are making. Mesh holds the primitives. Curve holds paths, and the pen for drawing your own. Light is three groups in one: lighting the scene as a whole, individual lamps, and complete rigs for when you want a working setup rather than one lamp. Generator builds geometry out of what you put under it — subdivision for meshes, and lathes, sweeps and extrusions for curves. Cloner covers setting up repetition and the effectors that vary it. Text, Camera and Null run on the click, because a category of one is a menu you have to open to find out it was never a choice. World holds the scene's atmosphere. At the end sits Import, for bringing in your own file.

The rail deliberately does not react to your selection. What you can ADD does not depend on what is picked, so a rail that rearranged itself as you clicked around would be moving under the hand for no information — it is the one fixed landmark in the chrome. The single exception is edit mode, where the modelling tools take its place; the Create menu remains a complete superset either way.

Open a mesh for editing and the create rail becomes the modelling rail, in the same 58px column so nothing jogs sideways under the swap. It holds the operations that change geometry, and which ones it offers depends on whether you are picking points, edges or polygons — the same tool means something different on each.

The verbs come in four groups. Shape changes form without changing how the mesh is built: Extrude pulls a selection out into new geometry, Inset adds a smaller face inside an existing one, Bevel rounds an edge or corner, and Poke, Panelize, Flatten, Smooth, Push and Slide adjust what is already there.

Topology changes how the mesh is built: Loop cut runs a new ring of edges around a shape, Knife cuts a line you draw across faces, Divide splits a selection, Bridge joins two openings with new surface, and Connect links selected points.

Remove takes geometry away: Delete face removes a face and leaves the hole, Dissolve removes an edge or point and merges what was either side, and Merge collapses selected points into one.

Mesh is the group that does not take a selection at all. Fill holes closes every gap, To tris and To quads convert the whole surface, Subdiv smooths all of it, and Flip reverses the normals. They are offered in all three modes and are never greyed, which is exactly what the heading is there to tell you.

A tool that needs something you have not selected greys itself and says why in one line — “Select a face in the viewport”, “Bridge works on faces — switch to Polygons”. That is a deliberate difference from the context bar, which hides what does not apply: in here, a greyed tool is teaching you what it wants, because the answer is usually one click away.

Half of modelling is choosing what to change. Clicking four hundred faces one at a time is not a workflow, so the selection tools are topology-aware: they follow the shape rather than the screen.

Grow and Shrink step the selection one ring outward or back, which is the fastest way from one face to a patch. Select edge ring follows the topology the whole way round a cylinder — the move loop-cut work is built on. Select linked takes the entire connected piece, which is how you isolate one part of an imported model. Select open borders picks the edges of every hole, so you can see what Fill holes is about to close before you run it.

Checker deselect drops every other element, for alternating patterns. Select similar facing takes everything pointing roughly the same way, which is how you grab the whole top of something in one click. Invert elements swaps picked for unpicked.

Two more worth knowing. Symmetry mirrors what you do across an axis, so a change on the left happens on the right. Proportional — soft selection — makes a pull fall off over a radius instead of moving one vertex, which is what turns poking at a mesh into shaping it.

A curve is an editable path rather than a surface, and on its own it renders as nothing. Its value is as an input: the Generator items in the create rail turn a curve into geometry by spinning it, sweeping a profile along it or extruding it, and the Animation section can use one as a path for something to travel along.

The curve verbs appear in the context bar when a curve is selected, and cover adding and removing points, changing how a point behaves — a sharp corner or a smooth tangent — and closing the curve into a loop. Whether a curve is open or closed matters more than it looks: a lathe of an open curve gives you a surface with an edge, and a lathe of a closed one gives you a solid.

Drawing your own. Curve ▸ Draw starts an empty curve with the pen armed, and from then on the viewport shows you the point before you place it: a ghost marker with a crosshair sits where the next click will land, and a dashed band runs to it from the end of the curve in the exact shape the new segment will take. Click for a sharp corner, press and drag for a smooth point whose tangent follows the drag, and click the first point again to close the outline. Backspace takes the last point back; Esc finishes the curve open.

The pen's own strip sits beside the verbs. Plane decides which world axis plane points land on — points go onto a flat plane rather than onto the screen, which is what keeps a drawn outline extrudable from any camera angle; Auto picks whichever plane the view most faces and fixes it once the first point is down. Grid rounds each point to the workspace grid step, and holding Shift while aiming constrains the next point to 15° steps out of the previous one. The readout between them prints exactly where the point will land and how far it is from the last one.

Editing points. Drag a point to move it, drag its handle to reshape the curve either side, and Alt-drag a handle to break the tangent so the two sides move independently. Click anywhere on the line to add a point there — the segment under the cursor lights up to show which piece is about to be split — and double-click a point to flip it between a corner and a smooth curve. Drag across empty viewport to band-select several points at once, then nudge them with the arrow keys, a grid step at a time, or ten with Shift.

Some tools fire on the click, and some arm instead. The shaping verbs — Extrude, Inset, Bevel, Poke, Smooth, Push, Slide — all have an amount to dial in, and committing a guess to find out whether it was right is a blind edit. Clicking one opens the operator panel, draws the result live in the viewport, and commits nothing until you say so.

What you are looking at while the panel is open is a preview. It is drawn from the pending operation rather than from your document, which is why Cancel is free: nothing was written, so there is not even an undo step to spend. Accept runs the real command, and lands as exactly one entry in the shared undo history.

If the numbers reach something that cannot be built — a zero-distance extrude, which is valid topology made of zero-area faces — the panel says so in a line and disables Accept, rather than leaving you to work out why a button will not press.

Some tools arm rather than fire: you pick the tool, then the viewport waits for you to indicate where or how much, and only then does anything happen. The operator bar is the always-visible answer to “what is the app waiting for, and how do I get out of it?” — it names the armed operation and offers Accept and Cancel.

It is a row of its own rather than a floating panel, and that is a fix rather than a style choice: on a phone a floating Accept button ended up underneath the sheet covering it, which made an armed operation impossible to finish or escape.

A modifier changes the mesh without changing the mesh. It sits on the object as a stage in a stack, is evaluated every frame on the way to the screen, and can be reordered, switched off or deleted at any point — the geometry underneath is never touched until you deliberately apply it.

They come in two kinds, and the distinction is the one worth learning. Generate stages change how much geometry there is: Subdivide, Bevel, Array, Radial, Mirror, Solidify and Boolean. Deform stages move the vertices that are already there: Twist, Bend, Taper, Wave, Noise, Spherify and Smooth.

That is also why the order matters so much. A deformer can only move the points it is given, so a twist above a subdivide bends a smooth surface and a twist below it bends eight corners. If a deform looks blocky or does nothing at all, a Subdivide stage above it is almost always the fix — reach for a deformer on a stock primitive and you get the one result here that reliably looks broken.

Boolean is the exception to the stack being self-contained: it cuts with another object, so it names one. That operand is evaluated with its own stack applied, which means a bevelled cutter cuts with its bevel. Delete the cutter and the boolean passes through rather than failing.

A cloner repeats an object. An effector varies what the cloner made. Together they are how you build a hundred of something without modelling a hundred of anything — and everything stays live, so the count, the spacing and the variation are numbers you can keep changing.

The cloner's mode decides the arrangement. Linear runs copies in a straight line. Grid fills a 3D grid. Radial puts them around a ring. Onto object scatters them across another object's surface, which is how you get grass on a hill or rivets on a panel.

An effector on its own does nothing visible — it needs a cloner to affect, which is why the effectors are filed under the Cloner button rather than getting one of their own. Plain applies its offsets flat to every clone it reaches. Random turns its offsets into the ± amount each clone is jittered by, which is the one that stops a grid looking like a grid. Step ramps from nothing to its offsets across the clone index. Target aims the clones at it. Time applies its offsets per second, so the clones keep moving with no keyframes at all.

A material describes how a surface responds to light — its colour, how rough or metallic it is, whether it is transparent. The materials bar along the bottom holds the materials this scene owns, and is where you make, assign and open them.

Drag a swatch onto an object to apply it — the same material can be on many objects at once, and editing it changes all of them, which is the point. Double-click a swatch, or press Edit, to open it in the material editor. New makes an empty one.

You do not have to start from scratch: Library opens a CC0 surface catalogue of a few thousand ready-made materials, free to use, which is usually faster than building a convincing brick or metal by hand.

The library panel is where you bring things in rather than make them, and it holds four pages — Content, Generate, Render and UV. You will not see all four at once: it shows the pages that apply to what you are doing, so entering the Rendering section brings up Render, and the UV workspace brings up UV.

Content is models and surfaces, both the ones that ship with Studio and the ones you have saved. Search here is semantic rather than literal — asking for “rusty metal” finds surfaces nobody named “rusty” — and the results can be filtered to what is available offline. Generate makes a new material or model from a description. The other two are the settings surfaces for rendering and unwrapping.

The material editor is its own panel in the left column, under the library. It shows the one material you have open: a preview ball that re-renders as you work, the material's name, a preset to start from, and the channels that describe the surface.

A physically-based material has twenty-one channels, and showing twenty-one rows would make the common edit — “make this less shiny” — harder than it is. They are paged instead, Cinema 4D's way: Color, Luminance, Transparency, Reflectance, Normal, Displace and Alpha. Every channel takes a texture map as well as a value, and the slot for it sits on the channel's own page.

Pages that cannot do anything are not drawn. Sheen models cloth fibres and transmission needs diffuse light to bend, so on a metal neither group appears at all — a control that can have no effect is worse than a missing one, because it reads as a bug in the renderer.

It is a separate panel from the library above it rather than a page inside it, which means both can be open at once — you take a surface off the catalogue and tune it without either one going away. Close it on its own from its ✕, or from Window ▸ Material editor. Right-click its header to move it to the other column or float it as a window.

To open a material in it: double-click a swatch in the materials bar along the bottom, press Edit on that bar, or press Edit in the inspector's Material tab when an object is selected. The materials bar is the list of materials the scene owns; this panel is the one you are editing.

Nothing in a 3D scene has a colour of its own — a material describes how a surface answers light, so with no light there is no answer. This is the single most common reason a first scene looks wrong: it reads as a modelling mistake when it is only an unlit one.

Light the scene is the group to start with, and it holds the two halves of ordinary daylight. Environment is an HDRI — a photographed sphere of light that surrounds the scene, lighting it from every direction at once and filling every reflection. It is the single biggest thing that makes materials look real, and it casts no shadow. Sun is the world's directional light, aimed by a height and a heading, and in an environment-lit scene it is the only thing casting one. Most scenes want both.

Lamps are objects in the hierarchy with a transform each, so you place and aim them like anything else. Point throws light in every direction from a spot. Directional sends parallel rays from infinitely far away. Spot is a cone with a falloff at its edge. Area is a rectangle of light, and it is the soft one — the bigger the rectangle, the softer the shadow. Ambient lifts everything flatly and casts nothing. IES loads a real fixture's measured beam from a profile file, which is how an architectural render gets a light that behaves like the thing on the drawing.

Rig is three lamps arranged for you, and it is the fastest way from an unlit scene to a lit one. Three-point is the standard: a bright key off to one side, a softer fill opposite it, and a rim behind the subject to separate it from the background. Studio softbox puts two large sources high and close for even product-shot lighting with soft shadows. Dramatic rim is a single hard back-light with a very dim front fill.

A mesh has no idea it is a person. Rigging puts a skeleton inside it and works out how much each bone moves each part of the surface, so that turning a shoulder bends an arm rather than shearing a hole in it. The Rigging section holds the whole of it: skeleton, skin weights, IK controls and the motion library.

Auto-rig does the usual case in one step. It measures the character, fits a 21-joint humanoid skeleton to its actual body, and solves the weights — the job a service like Mixamo does. Afterwards the mesh deforms live, the bones keyframe like any other object, and the motion library will retarget onto it.

For a character made of several meshes — body, armour, hair, a hat — select the group rather than a mesh. The skeleton is measured from the largest mesh, which is the body (a hat would otherwise make the character read as taller than it is), and every part is bound against one shared solve. Binding them one at a time weights each part in ignorance of the others, and they come apart the first time you pose them.

A joint that lands wrong is not a dead end: every joint is an ordinary object, so move the ones that are off and bind again. Re-binding replaces the existing weights, and that correction loop is the intended workflow rather than a repair. Note that undo does not remove a binding — there is an explicit Unbind for that.

IK is the other half of posing. Without it you rotate a shoulder, then an elbow, then a wrist to get a hand where you want it; with it you drag the hand and the arm follows. A control rig adds those handles for you.

The motion library is where movement comes from if you are not animating it by hand: a catalogue of motion-captured clips you can preview on your own character before committing. The preview runs on the real model at the real scale and is not a clip in your document until you accept it, so trying ten costs nothing and leaves nothing behind. Clips retarget onto whatever proportions your character has rather than assuming a standard skeleton.

You can orbit a scene forever without a camera object — the viewport has its own free camera and it is not part of the document. A camera object is what you add when the FRAMING matters: it remembers a position, a lens and an aspect, it can be animated, and it is what a render is taken through.

Lens is what it sees: focal length, projection, shift and clipping. Focal length is the one that decides how a shot feels — a short lens exaggerates depth and makes a room look vast, a long one flattens it and makes a product look considered. Frame is what it composes for: the delivery gate, the fit and the sensor. Focus is depth of field and the subject it should be sharp on. Aim is where it points, including a target it can track.

Look through puts the viewport behind the camera's eye, and this is the part worth understanding: while you are looking through it, orbiting and panning MOVE THAT CAMERA. That is how a shot is composed — every navigation becomes an edit to the camera object and lands in the undo stack. Leaving look-through hands the view back to the free camera, which returns to exactly where it was standing.

The transport runs along the bottom of the window: play and pause, stepping a frame at a time, looping, the current time, and the way in to the timeline.

Animation works by keyframes: you move to a frame, set a value, and Studio fills in the frames between. Setting a key records the current state of the selection at the current frame, and the timeline shows those keys as markers you can drag to re-time.

The timeline is where the keys live. It opens from the transport, fills the bottom of the Animation section, and shows the selection's animated properties as rows against time.

Position, rotation and scale are keyed per axis rather than as a single block, which is why the track list has three rows under each heading rather than one. Any numeric property in the inspector can be keyed the same way, so a material's roughness or a lamp's intensity gets a row here too once it is animated.

The header carries the clip: its Length in frames, its frame rate, and Snap, which rounds a dragged key to whole frames. Set key records the selection's current state at the playhead, and Auto keeps recording as you work — every change you make becomes a key until you turn it off again.

Keys are draggable. Drag one along its row to re-time it, drag a box across several to move them together, and right-click for the rest — copying, mirroring, and the easing presets. How a value travels between two keys is its easing, and easing is what separates animation that reads as deliberate from animation that reads as mechanical.

Curves is the other half of the same dock. It draws each track as a curve you can shape directly rather than as a row of markers — the finer control for when a preset is not the shape you want. It is a mode of this panel rather than a separate window, and it is also under Window ▸ Graph editor.

Motion opens the motion browser: a library of ready-made animation you can preview on your own character before committing to it. The preview runs on the real model at the real scale and is not a clip in your document until you accept it, so trying ten of them costs nothing and leaves nothing behind.

The Render section turns the scene into a finished image. The render frame follows the guides in the viewport, so what is inside the frame is what you get.

A path-traced render works by sampling: it fires rays into the scene and averages what they find, so an image starts noisy and cleans up the longer it runs. There is no single correct number of samples — you stop when it looks right, and complex lighting takes longer to settle than simple lighting.

Denoising shortens that wait by cleaning up a partly-converged image rather than waiting for it to converge on its own. It is close to free in quality terms at moderate sample counts and is usually worth leaving on.

Samples decide how CLEAN the image gets; bounces decide how much light reaches it at all. The Quality tab offers three tiers as shorthand and an exact bounce count under them — two is enough for a single opaque object, while a room lit through a window needs eight to twelve before it stops reading as a cave. Glass has its own budget beside it: every transparent surface a ray passes through costs one, so a tumbler needs four and a shelf of them needs twelve, and the usual cause of glass coming out dark or muddy is that budget rather than the bounce count.

The Look tab is display-side, which means everything in it re-composites the image already traced rather than starting over — you can grade a finished render, add bloom or a vignette, dial in lens aberration or sharpen it, and none of it costs you a sample. The Backdrop group decides what sits behind the scene: a flat colour, the environment map itself, or nothing at all for a cut-out with real transparency. With the environment behind it you can blur and dim it independently of the lighting, which is how a product shot keeps its highlights while the background stops competing.

Studio models and arranges. Paint textures a single mesh, and Mold sculpts one. Send to, in the top bar, hands the selected object across without an export step in between — you are not making a file, you are opening the same object somewhere else.

Paint — texture it opens the object in the texture painter, where it gets layers, masks and painted maps rather than a shared material. What comes back applies to that object here.

There are two Mold rows on an object that came from a sculpt, and they are not the same offer. Continue reopens the sculpt this object was made from, with its history intact. Sculpt it fresh starts a new one from the mesh as it stands now, including whatever you have done to it since. One is going back; the other is going on.

Saving and exporting answer different questions. Saving keeps the document so you can come back to it. Exporting hands a copy to something that is not Studio.

Saving is ⌘S, and it works signed out — the document is written into this browser first, so nothing is lost while you decide whether you want an account. That is what the This device state on the save chip means. Signing in adds the second half: the document is backed up to your Scenes library and is then on every device you sign in from, and it survives clearing this browser's site data. ⇧⌘S saves a copy under a new name.

Exporting is one dialog, and it is split by where the file is going rather than by format — which is the question someone opening an export dialog can actually answer.

1. 1
   3D model — “I want to open this in another 3D tool.” GLB, glTF, FBX, OBJ, STL and USDZ. GLB is the default and the right answer most of the time; STL is the one for printing; USDZ is the one an iPhone opens in AR.
2. 2
   Web — “I want to put this on a page.” A self-contained page, an embed snippet, a React component or a plain three.js module. The last two download as a zip: the code plus the scene it loads.
3. 3
   Publish — “I want this on a page and I do not want to host anything.” Studio hosts it and hands you a live link. Nothing to upload and nothing to wire up.
4. 4
   Scene file — “I want a copy of the document itself.” An .mxs file — everything, including the things a model format cannot carry: your generators, modifiers, animation and render settings.

The assistant sits in its own dock and can operate the scene by running the same commands the menus and the palette run. Asking it to do something and doing it by hand take the same path, so anything it does is undoable exactly like your own edits.

Because it reports what actually happened rather than what was asked, it will tell you when a value was clamped or an operation refused — which makes it useful for finding out why something did not work, not only for doing things.

It is at its best on work that is tedious rather than difficult — repetitive edits, setting many values consistently, and answering “where is the control for this?” without making you go and find it. It is least useful for judgement calls: what a scene should look like is not a thing to delegate.

Anything it does lands in the same undo history as your own edits, so ⌘Z reverses it exactly the way it reverses a click. You are never in a position where you have to accept its work to get rid of it.

Press ? at any time to see every key the application binds, and to choose your keymap.

Studio ships three keymaps — MixOS (Maya-style), Blender and Cinema 4D — because navigation habits are the single largest reason a 3D application feels foreign. If orbiting does not work the way your hands expect, you are almost certainly on the wrong preset rather than fighting the app; change it in the same ? sheet.

The Generate section makes an image or a video from the scene you have built. It is not a renderer and does not compete with one: the Render section traces light, and this hands a picture of your scene to a generative model and gets back a different picture.

The pipeline is two inputs feeding one button, and the page is laid out that way because it is the mental model. A still comes from the viewport, via Finish frame. A motion reference comes from an animation clip, via a playblast. Generate consumes one or both.

Depth is the default, and it is the single biggest quality lever here. A beauty playblast — one that records the shaded view — generates a perfectly good shot. A depth one generates a shot that TRACKS, because the generator is handed the scene's real geometry rather than left to infer it from shaded pixels. The difference is invisible in the setting and obvious in the result.

Interpretation decides how far the result may travel from your scene: Precise, Balanced or Creative. Precise is the default, because a Studio viewport usually holds a real model rather than a blockout — and because a still pinned as the first frame of a video has to describe the same shot the motion reference performs.

3D has a vocabulary, and most of it is only strange until someone says it plainly once. These are the words this manual uses without stopping to explain them.

Mesh

A surface made of flat faces meeting at edges and points. Every solid object in a scene is one, however smooth it looks — smoothness is small faces plus shading.

Vertex / point

A corner. Move it and every face touching it changes shape.

Edge

The line between two points.

Face / polygon

A flat patch bounded by edges — three of them makes a triangle, four a quad. Quads are easier to model with; everything becomes triangles by the time it is drawn.

Topology

How a mesh is divided up, as distinct from what shape it is. Two objects can look identical and have topology that makes one a pleasure to edit and the other unusable.

Normal

The direction a face points, which is how the renderer knows which side is outside. A face with its normal reversed goes invisible or black.

UV

A coordinate on a flat square, assigned to every point on the mesh, so a texture knows where to land. Making them is unwrapping.

Material

A description of how a surface answers light — colour, roughness, metalness, transparency. Not a colour: a material with no light is black.

PBR

Physically based rendering. Materials described in terms that behave like real ones, so the same surface looks right under any lighting.

Map / texture

An image feeding one channel of a material. A colour map paints it; a roughness map says where it is shiny; a normal map fakes detail without adding geometry.

HDRI

A photographed sphere of light used as the scene's environment. It lights everything from every direction at once and fills the reflections — the fastest route to a scene that looks photographed.

Generator

An object that builds geometry from parameters or from other objects and keeps them live. A primitive cube is one; so are lathes, sweeps and cloners.

Modifier

A stage in a stack that changes a mesh on the way to the screen without changing the mesh underneath.

Transform

Position, rotation and scale — where an object is, which way it faces and how big it is.

Pivot / origin

The point an object rotates and scales around. Put it in the wrong place and a door swings from its middle.

Parent / child

A containment relationship. Moving a parent moves its children; the child keeps its own transform relative to the parent.

Keyframe

A recorded value at a moment in time. Two of them and the application fills in everything between.

Easing

The shape of the travel between two keyframes. It is the difference between motion that reads as deliberate and motion that reads as mechanical.

Rig / skinning

A skeleton inside a mesh, and the weights saying how much each bone moves each vertex.

Path tracing

Rendering by firing rays into the scene and averaging what they find. It starts noisy and cleans up the longer it runs.

Sample

One of those rays, per pixel. More samples means less noise and more time.

Bounce

How many surfaces a ray may hit before it is given up on. Samples decide how clean the image is; bounces decide how much light reaches it at all.

Denoise

Cleaning up a partly-converged render rather than waiting for it to finish converging.

Gizmo

The handles drawn on a selection for dragging it — and the axis marker in the viewport corner, which is a different gizmo doing a different job.

Most of what goes wrong in a 3D application is a control doing exactly what it says somewhere you were not looking. This section is indexed by the symptom rather than by the control, because the symptom is the only thing you have when you do not yet know which control is at fault.

1. 1
   My render came back clay-coloured, or empty — The renderer traces the scene as the viewport is currently shading it. Clay shading gives a clay render; Wire gives an empty one. Set the shading strip to Materials and render again.
2. 2
   Everything is black — Almost always no lighting. A scene with no Environment and no lamp has nothing for a material to answer. Add an Environment and a Sun from the Light category, or drop in a Three-point rig. If only ONE object is black, check its UVs instead — a map on UV-less geometry has nowhere to land.
3. 3
   The viewport is not responding to clicks — An armed operation is the likeliest reason: a tool is waiting for you to say where or how much, and the operator bar is saying so. Esc cancels it and changes nothing.
4. 4
   A control I remember has gone — Three places to look, in order. You are probably in a different section — the switch is in the top bar. The context bar only shows what applies to the current selection, so picking the right object brings its verbs back. And the menus are the complete index: nothing is ever only in the bar.
5. 5
   Opacity does nothing — Turning a material transparent changes how it must be drawn, not only how it looks, so it takes effect on a rebuild rather than instantly.
6. 6
   The viewport looks cropped, or the grid is cut off — That is the frame guides showing you what will render, not a drawing bug. They dim everything outside the output frame. Render ▸ Frame guides turns them off.
7. 7
   My edit went to the wrong object — Open the outliner. The viewport shows what is visible from one angle; the outliner shows what exists, what is selected, and what is parented to what. A child moving with a parent you did not mean to pick is visible there and nowhere else.
8. 8
   The modelling tools are greyed out — They need a selection of the right kind. The greyed tool's own tooltip says which — “select a face”, “switch to Polygons”. Note that the rail also greys itself after every operation on purpose: a rebuild renumbers the faces, so the old selection is cleared rather than quietly pointing at the wrong ones.
9. 9
   It is stuttering — Open Stats from the outliner header. It measures what the scene costs against what this device can handle and lists the heaviest objects — the weight is almost never spread evenly. Lowering the viewport quality in the Display menu buys headroom without touching the document.
10. 10
    A deformer did nothing, or came out blocky — A deformer can only move the points it is given, and a stock primitive has very few. Put a Subdivide stage above it in the modifier stack.
11. 11
    I cannot find my scene — Check the save chip beside the document name. This device means it was saved signed out and lives in this browser only — sign in and save again to put it in your account. Unsaved means it has not been saved at all.