Hamilton Microlab STAR Integration
Drive your liquid handler in Python, without writing a VENUS method
Aspirate and dispense on independent channels, pick up tips, move plates with the iSWAP or CO-RE gripper, load carriers, and lay out the deck in code.
- Supports
- All models
- Connects over
- USB
- Local interface
- SiLA 2
- Vendor software
- None required
- Runs On
- Linux / Windows / MacOS
What You Can Command on the STAR
Channels, tips, the 96 head, plate transport, the autoload and TADM each arrive as their own callable capability. Modules register from the instrument's own configuration, so an iSWAP or an on-deck heater-shaker only appears if one is installed.
Pipetting Channels
Aspirate, dispense and multi-dispense on independent channels, with liquid level detection, tip washing and per-channel positioning.
Tip Management
Pick up and discard tips per channel, check tip presence on every channel, and define custom tip types.
CO-RE 96 Head
Where the 96-channel head is fitted: aspirate and dispense a full plate in one step, with its own parameter sets.
Labware Transport
Move plates with the iSWAP from a chosen approach side, or with CO-RE gripper paddles held on two channels. NGC arms add the quad gripper.
Autoload and Barcodes
Load and unload carriers, read carrier barcodes (2D codes on the 2D autoload), and check what's on the deck and loading tray.
TADM
Record per-channel pressure curves during aspirate and dispense, and stop the plunger when a curve leaves the guardband you set.
Run a Transfer From Python
Ordinary async Python. Version it, test it, generate it at runtime like any other code.
# bring up, arrange the deck, transfer on 8 channels, discard
from unitelabs.sdk import AsyncApiClient
from unitelabs.liquid_handling.hamilton import MicrolabSTAR
from unitelabs.labware import PredefinedLiquids, Standard96Plate, StandardTrough
from unitelabs.labware.hamilton import (
PLT_CAR_L5MD_A00,
TIP_CAR_480_A00,
HamiltonTip_300,
HamiltonTipRack_300,
LiquidClass,
)
hamilton = MicrolabSTAR(name="Microlab STAR", client=AsyncApiClient())
await hamilton.initialize()
tip_carrier = TIP_CAR_480_A00()
tips = HamiltonTipRack_300(filled_with=HamiltonTip_300)
tip_carrier[0] = tips
hamilton.deck.add(tip_carrier, track=7)
plate_carrier = PLT_CAR_L5MD_A00()
assay = Standard96Plate()
reagent = StandardTrough()
reagent.containers[0].add_liquid(PredefinedLiquids.WATER, 150_000)
plate_carrier[0] = assay
plate_carrier[1] = reagent
hamilton.deck.add(plate_carrier, track=1)
water = LiquidClass.HamiltonTip_300_Water_DispenseJet_Empty()
channels = range(8)
await hamilton.pipettes.pick_up_tips_from(channels=channels, rack=tips)
await hamilton.pipettes.aspirate(source=reagent, channels=channels, volume=100, liquid_class=water)
await hamilton.pipettes.dispense(target=assay["A1":"H1"], channels=channels, volume=100, liquid_class=water)
await hamilton.pipettes.discard_tips(channels=channels)
Know One Connector, and You Know Them All
Three calls bring any instrument online, and the same Python drives whatever comes next.
One API, Every Instrument
Three calls to start: configure(), initialize(), activate(). The same on a liquid handler, a reader or an incubator, whatever the vendor ships underneath.
Ask a Connector What It Can Do
Modules and actions are discoverable at runtime, and parameters carry their own types, units and constraints. You don't need a PDF to find out.
Also Works With
The same Python script can drive every instrument on the bench. A liquid handler sets up the plate, a thermal cycler can cycle it, and a reader measures it, all from one script.
Hamilton Microlab STAR
The questions automation engineers ask before integrating a STAR.
Yes. With the UniteLabs connector and the liquid handling SDK you call the STAR directly from Python: pick up tips, aspirate from a trough, dispense into a plate, and move labware with the iSWAP or CO-RE gripper. It's ordinary async Python, so it can be version-controlled, tested and generated at runtime like any other code.
No. The connector talks to the STAR firmware over USB, so no VENUS method sits in the loop. It exposes the instrument as a SiLA 2 service on a local gRPC port, and opens one outbound TLS connection on port 443 to your tenant.
Yes. The same connector covers the Microlab STAR, STARlet and STARplus. On connect it reads the instrument's configuration and registers only the modules that are actually fitted, so channel count, the 96 head, iSWAP and autoload all come from the hardware.
Independent pipetting channels, the CO-RE 96 head, the iSWAP, the CO-RE gripper (including the quad gripper on NGC arms), the autoload and 2D autoload, and Hamilton heater-shakers on up to two ports.
Yes. The connector exposes the STAR as a SiLA 2 service on a local gRPC port, and it groups what the STAR can do into modules you can list at runtime. Find out more about how we use the SiLA 2 standard for instrument interoperability.
Yes. Turn on recording for an aspirate or dispense and each channel stores a pressure reading every 10 ms. Add a guardband and the STAR stops the plunger when a curve leaves it. TADM works best above 10 µL; below that the pressure profiles get inconsistent.
The liquid handling SDK handles liquid classes, carriers on deck tracks, labware definitions and tip tracking. You call aspirate with a source, channels, a volume and a liquid class, and the SDK works out the rest.
Yes. A mock liquid handler is a drop-in replacement for the real hardware, with liquid tracking and state validation, and the connector has a simulation mode of its own. Be clear about what the mock doesn't model: it catches layout, state and volume errors rather than physics. A protocol can pass the mock and still need a dry run.