01
Compose
151 reusable components across controls, conveyors, robotics, process, building, street and connection-hardware packs.
Build a factory from reusable PBR components, generate its PLC tags, write the logic, inject faults and watch the scene move—without installing a vendor IDE or Windows-only desktop simulator.
Orbit every model in the browser: conveyors, controls, robots, process equipment, street furniture and scenario props. These are the same PBR assets used by guided 3D scenarios and the Pro 3D Sandbox.
Public viewer is free. Guided 3D starts on Basic; composing and saving custom 3D scenes is Pro.
151 real-time factory components
Load the interactive viewer when you are ready to orbit the models.
Loads 3D only after your click
One connected workflow
The component contract is shared between the public viewer, guided scenarios and custom builder. A conveyor behaves like the same conveyor everywhere.
151 reusable components across controls, conveyors, robotics, process, building, street and connection-hardware packs.
Every functional object exposes typed input and output ports that generate collision-safe PLC tag names.
Write ladder or Structured Text in the same workspace and import selected-object or whole-scene tags.
PLC state drives deterministic motion, signal lamps, analog progress and realistic failure states.
Honest category boundary
Use it to learn sequencing, interlocks, I/O, faults and spatial machine behavior. Do not use it as evidence that a production line is mechanically safe or cycle-time capable.
CAD ingestion, hardware network emulation, safety certification and high-fidelity mechanical commissioning are outside the current product scope.
| Need | Best fit |
|---|---|
| Learn PLC logic in a visual factory | 3D Sandbox or guided 3D scenarios |
| Connect a vendor IDE to external scene I/O | Factory I/O or vendor-compatible tooling |
| Validate production mechanics and networks | Production virtual commissioning stack |
| Model throughput and queues statistically | Discrete-event simulation software |
Each component has a stable root, physical scale, ground-contact pivot, PBR material contract, motion classification, I/O ports, snap ports and failure modes. That lets us compose many scenarios without duplicating scene code or animation logic.
A sandbox proves your machine can move. Automated scenario tests prove your program meets a specification. We ship both: open composition for exploration and controlled tasks for objective learning evidence.
3D scene, tag and motion guide
Direct answer
A 3D PLC simulator runs ladder or Structured Text against a three-dimensional machine whose conveyors, cylinders, gates and sensors are bound to PLC tags. Its value is spatial: you see where a photo-eye sits, how long a cylinder travels and where parts queue, then prove the sequence with tag values and scenario tests rather than the animation alone.
This guide is written for pLC learners who can write basic ladder logic but struggle to picture a machine sequence, and instructors who want sensor placement, actuator travel and material flow reasoned about in one browser workspace. The intended result is specific: the learner can map every moving object to a command tag and every sensor or limit to a feedback tag, run a complete cycle from a recorded scene state, and explain any disagreement between what the scene shows and what the controller reads.
Every functional component exposes typed ports. Ports the PLC writes, such as a conveyor forward bit or a cylinder extend bit, are commands; ports the PLC reads, such as an extended limit or a photo-eye detecting bit, are feedback. A sequence should advance on feedback, because a command only records what the program asked for.
The sandbox builds each tag from the instance name and the port key, so a cylinder named Pneumatic cylinder 1 produces tags such as PNEUMATIC_CYLINDER_1_EXTEND, typed as BOOL, DINT or REAL. Because names are derived, renaming a component after import creates names the program does not reference, and scene validation rejects duplicates.
The controller acts on tag values sampled once per scan: read inputs, execute the program, write outputs, then advance the deterministic machine model. The animation is a picture of that model state at render time. When the picture and a tag disagree, trust the tag table and the scenario result first, then work out why the scene looks different.
In a guided 3D cell a photo-eye reports true only while a modeled part occupies its detection point, so its position along the belt sets timing. The spacing between an entry eye and a height eye fixes how long the logic has to decide before a diverter must act. Orbit the camera to confirm sensor order and spacing before writing the sequence.
Cylinders, gantry axes, gates and doors take modeled time to move between end positions. Logic that moves to the next step as soon as a command is issued, instead of waiting for the arriving limit switch, can look plausible in a quick visual loop yet fail a test that checks order. Treat travel as a window that feedback must close.
In the sandbox a failure is chosen per component while in edit mode. Stuck-on moves a component without a command, stuck-off and jammed prevent motion, slow reduces speed and misaligned flags a tripped state. Each stands for a class of field fault, so the program should detect missing or late feedback rather than wait indefinitely.
Write down part positions, actuator home states, sensor states and the reset policy before the first run.
Evidence: The same cycle can be repeated from an identical scene and compared run to run.
Avoid: Starting each test from wherever the previous run left the machine.
Load a starter layout or place components on the 0.25 m grid, then snap equipment together through compatible load, pipe, mount or safety ports.
Evidence: Material-flow ports line up and scene validation reports no errors.
Avoid: Nudging parts until they look joined while their flow ports remain unconnected.
Give components meaningful names, add the scene tags to the PLC program, then read each tag, its direction and its data type.
Evidence: The program variable list holds every command and feedback tag with the expected type.
Avoid: Renaming components after import and leaving the program pointing at stale names.
Advance each sequence step on a limit, sensor or at-speed input and give every wait a timeout.
Evidence: Each transition names the feedback that closes it and the fault state reached if it never arrives.
Avoid: Using fixed timers to stand in for travel that the scene can report.
Switch to run mode, watch the scene and the tag values together, and stop at the first step where they disagree.
Evidence: The observed order of sensors and actuators matches the written sequence across several parts.
Avoid: Declaring success after one smooth-looking animation.
Return to edit mode, set one failure such as jammed or slow on a single component, and rerun the same case.
Evidence: The program stops or alarms in a defined state instead of waiting forever or commanding the next move.
Avoid: Injecting several failures at once and losing track of which one caused the symptom.
| Observed symptom | Inspect | Interpretation | Next proving action |
|---|---|---|---|
| Command tag is true but the component does not move | Tag name in the program against the generated name on the selected component, tag direction, run mode and any stuck-off or jammed failure | A renamed instance, logic writing a similarly named variable, or a scene still in edit mode leaves the component idle while the rung looks correct. | Compare the component tag list with the program variables and re-import any missing tags. |
| Part crosses the sensor but the input never turns true | Sensor position relative to the part path, whether the part reaches the detection point, and which source writes that feedback tag | In a guided cell the model decides detection from part position; in a custom scene, confirm what drives the feedback input before blaming the logic. | Orbit to a side view and watch the input tag at the moment the part should cross. |
| Sequence advances before motion has finished | Step transition conditions, command bits, end-position feedback and timer presets | A transition keyed on the command or on a short timer lets the program run ahead of modeled travel time. | Make the transition wait for the end-position input and rerun the test that checks order. |
| Parts bunch or collide at a transfer or diverter | Part spacing, conveyor enable and direction, stop blade or diverter state, and downstream occupied signals | Material flow exposes missing accumulation logic: an upstream conveyor keeps feeding while the next station is still busy. | Add a zone-occupied permissive and repeat the case with parts released closer together. |
| Scene looks right but the scenario test fails | The failing check, its expected tag value, the time it samples and any hidden cases | Tests read controller and model state, not the picture; a one-scan pulse, a step out of order or an early diverter can be invisible at viewing speed. | Reproduce the failing step with the tag values and correct the logic rather than the camera angle. |
| Viewer stutters or motion is hard to follow | Browser WebGL support, device memory, screen size, component count and other open tabs | Rendering detail is scaled to the device and small parts may be culled at distance; a low frame rate makes timing hard to judge by eye. | Use a current desktop browser on a larger screen and rely on tag values and tests for timing questions. |
Product evidence / 05
The 151-component library shares one component contract across the public viewer, guided 3D scenarios and the Pro 3D Sandbox: typed I/O ports generate PLC tags, snap ports join compatible equipment, and supported components accept injected failures. Guided 3D editions keep the physics, I/O and tests of their proven 2D scenarios and change only the presentation.
It links PLC logic to a spatial machine so learners can see sensor order, actuator travel and part flow while they program. That makes sequencing, interlocks and timeouts easier to reason about than a bare tag list. The learning evidence still comes from tag values and automated scenario checks, not from how the animation looks.
No. The editor, tag model, tests and 3D scene run in one browser workspace, so no external driver or vendor IDE is involved. The trade-off is that you cannot connect your own vendor engineering software to the scene; tools built around external I/O connections serve that need instead.
Select a component to see its generated tags, then add that component’s tags or the whole scene’s tags to the PLC program. Commands such as extend or forward become outputs the logic writes; limits and sensors become inputs it reads. Name components before importing, because each tag name is derived from the instance name.
Scenario checks sample tag and model state at defined moments, and the guided 3D editions share their physics, I/O and tests with the 2D sources. A one-scan pulse, a step taken out of order or a diverter energized too early may not be visible at normal speed. Read the failing check and reproduce it with the tag values.
Not in the engineering sense. A digital twin is normally validated against the geometry, dynamics and data of a specific real asset. This scene is an instructional state model with deterministic motion; it does not ingest CAD or prove collision, cycle time or safety. Production virtual commissioning tools serve that purpose.
Yes. In the 3D Sandbox a supported component can be set to stuck-on, stuck-off, jammed, slow or misaligned before the scene runs. Apply one failure at a time and check that the program detects missing or late feedback, holds a defined state and needs a deliberate reset instead of resuming motion by itself.
A modern browser with WebGL on Windows, macOS, Linux or Chromebook; there is no installer or virtual machine. A current desktop browser on a larger screen is the most practical surface for editing scenes, while small touch devices can find complex 3D workspaces harder to use. Performance also depends on the device and scene size.
Anyone can open and orbit the component viewer without paying. The Basic plan adds a guided 3D gantry pick-and-place cell, and Pro opens every guided 3D scenario along with composing and saving your own layouts in the 3D Sandbox. Access can change as scenarios are staged, so treat the current pricing page as authoritative.
Watch the real browser product respond to the task on this page, then try the same practical workflow yourself. No slides, concept mockups, install, or credit card.
Try this in the browser