Written from the ground up for a reader who has never touched a laboratory or written a line of code. It covers what problem this tool solves, how it works, and how you can judge for yourself whether it is any good. Every result quoted here is produced by the tool itself and checked by an independent referee.
Modern labs use robots to move tiny amounts of liquid between hundreds of little cups. This is the everyday work behind drug discovery, medical testing, and research. Today a scientist writes the robot's instructions by hand: it is slow, easy to get wrong, and wasteful of expensive single-use plastic tips.
PipetteC lets the scientist write a short "recipe" instead. The tool turns that recipe into precise robot instructions, automatically makes them cheaper and faster, and has an independent referee check every result before anyone trusts it.
The setting first, so the problem makes sense. No jargon; skip nothing.
A huge amount of science and medicine comes down to moving small drops of liquid from one little cup to another and seeing what happens. Testing whether a drug works, running a COVID test, checking a blood sample: under the hood, it is liquids being combined in precise amounts.
Doing this by hand, thousands of tiny identical drops, is tedious and imprecise. So labs use a liquid-handling robot: a machine with a motorized eyedropper (a "pipette") that moves over the tray and squirts exact amounts into each cup. A popular, affordable one is the Opentrons OT-2. That is the machine this tool writes instructions for.
Writing the robot's program by hand is slow, error-prone, and wasteful. Three costs, concretely:
The program is hundreds of low-level "move this much liquid from here to there" commands. One typo can ruin an experiment, wasting days of work and costly materials, or, worse, produce results that look fine but are subtly incorrect.
A careless program grabs a brand-new plastic tip for every single drop, even when the same tip could safely be reused. On a busy plate that is hundreds of needless tips: real money and real plastic, every run.
Optimizing the program by hand to save tips is fiddly and risky. Every hand-optimization is a new chance to accidentally change what the experiment actually does.
PipetteC is a "compiler" for lab experiments. That word deserves one plain sentence.
PipetteC does the same for lab work. The scientist writes a short, readable recipe, such as "make a standard dilution series of Drug A, 8 copies, 12 steps." The tool then does three jobs automatically:
A short, human-readable file. This is the entire input for a real 96-cup dilution experiment:
make: serial_dilution
compounds: [DrugA]
copies: 8
steps: 12
strength: 100
dilution_factor: 3The tool also accepts a real industry file called an "Echo picklist": a spreadsheet of "move this much from cup A to cup B" rows that many labs already produce. No new format to learn.
Each square is a slot on the robot's workbench. Green = trays of cups; blue = the reservoir of liquid; yellow = racks of fresh tips; red = the trash. The tool draws this from the recipe so a person can eyeball it before pressing "go."
pipettec render examples/dose_response.yaml --deck.A tool that saves money is worthless if it quietly breaks the experiment. So this is the section that matters most: the three independent ways we prove the output is trustworthy.
The maker of the robot (Opentrons) publishes an official simulator: a program that "dry-runs" any set of instructions and flags anything impossible or invalid, without needing the physical robot. We run every single set of instructions the tool produces through this referee. It is never faked or skipped.
When the tool reuses tips to save money, it must never change what liquid ends up where. We check this with a strict rule: the optimized instructions must deliver the exact same amount of every liquid to every cup as the plain, un-optimized version. We tested this on 550 randomly generated experiments and found zero cases where it differed.
Before anything runs, a built-in safety checker rejects recipes that ask for the impossible (too much liquid for a cup, drawing from an empty cup, mixing things that must not touch), giving a clear, readable explanation instead of a silent failure.
Every number here is produced by the project's own automated checks, which run again on every code change.
opentrons_simulate (v8.8.2), the project's
automated test suite, and benchmarks/simulate_corpus.py (500-experiment run).The payoff, measured rather than estimated. "Tips" are the throwaway plastic nozzles; fewer is cheaper and greener. The comparison is fair by construction: both columns come from the same tool, once with the money-saving smarts off, once with them on.
| Experiment | Tips before | Tips after | Saved | Est. time before → after |
|---|---|---|---|---|
| Dose–response dilution (flagship) | 184 | 13 | −92.9% | 49 → 16 min |
| Plate normalization | 8 | 1 | −87.5% | 2.1 → 1.2 min |
| PCR setup (24 reactions) | 48 | 25 | −47.9% | 12.8 → 9.7 min |
| Echo picklist import | 10 | 7 | −30.0% | 2.7 → 2.3 min |
| Cherry-pick transfers | 5 | 4 | −20.0% | 1.3 → 1.2 min |
| 96→384 plate reformat | 192 | 192 | 0% | 51 → 51 min |
benchmarks/bench.py, run on opentrons 8.8.2.pipettec compile examples/dose_response.yaml.A credible report states its boundaries plainly.
The clever tip-saving math is published prior research that we apply and credit; we do not claim to have invented it. The contribution is the packaged, end-to-end tool: an easy recipe in, a verified robot program out, with the official referee wired in as an automatic gate.
It targets one specific robot (the Opentrons OT-2) and validates in the official simulator, not on physical hardware. The time figures are transparent estimates, clearly labelled and never presented as hardware measurements.
A scientist writes a short recipe. PipetteC turns it into correct, cheaper, self-checked robot instructions, cutting disposable-plastic use by up to 93% on the flagship experiment, with a proven guarantee that the science is unchanged and an independent referee signing off on every result.
The value lies in trustworthy execution rather than a novel formula: less waste, fewer errors, and results you can verify yourself rather than take on faith.