An AI-assisted workbench for molecular dynamics.
verlet is an IDE for simulations: an editor that knows the engine, an assistant that drafts and checks inputs, runs anywhere you have SSH, and every input and result kept.
LAMMPS is supported today; more engines are planned.
500 Lennard-Jones atoms start on an fcc lattice and melt, integrated with velocity Verlet in your browser. Drag to turn the box; cool it below about kBT 0.7 and the liquid slows down.
One place for every run, wherever it ran.
Thermo charts, speed, time left, CPU and memory update while the simulation runs. Logs, outputs and the exact input that produced them stay with the run.
An editor that knows the engine.
Completion for every command, style and keyword, taken from the manual of the LAMMPS version you run. Hover a style for its syntax, press F1 for the whole page beside the editor. Styles your executable was not built with are marked before you run.
- From the manual, not a word list. Keywords come with their values and what they mean.
- For your binary. The packages each executable was built with decide what is offered.
- Checked on save. The engine reads the input with zero timesteps; problems land on their line.
From your laptop to the cluster, without a terminal.
verlet talks to remote machines through the SSH you already use. A small runtime installs itself in your home directory and stays out of the way.
- No root, no cluster-wide install. Everything verlet puts on a machine sits in
~/.verlet. - Runs survive the connection. Close the laptop; the run keeps going and the results catch up when you reconnect.
- Your SSH, as configured. Aliases, keys, jump hosts, one-time codes.
1. Add a machine
Type the SSH host you already use, like perlmutter or me@login.cluster.org. verlet runs your own OpenSSH, so ~/.ssh/config, keys, jump hosts and Kerberos all work. Password and one-time-code prompts appear in the app; nothing is stored.
Turn any Linux account into a simulation machine.
The engine isn't installed, or lacks the packages you need? Describe the build in a few lines of YAML. verlet installs Spack in your home, reuses the compilers and MPI already there, and builds as many executables as you want, side by side. LAMMPS builds work today.
- home writable~/.verlet
- free space8.7 GB
- python3Python 3.12
- make, patch, tar/usr/bin
- C++ compilerg++ 13.3.0
- github.comreachable
~/.verlet/everything lives herespack/spack-1.2.2/Spack itselfspack/config/compilers and packages foundopt/installed packages, sharedbuilds/lmp-minimal/spec.yaml, spack.lock, logbin/lmp-minimalthe executable you run- Nothing is written outside your home. No step needs sudo.
1. Check the machine
Before changing anything, verlet checks what a build needs: a writable home, free space, Python 3, tar, patch, make, a C++ compiler, and a route to GitHub. Anything missing comes with the fix in plain words.
Pick packages, not CMake flags
Start from a template, tick the packages you need, choose the compiler, MPI and optimisation level. The spec is checked against the machine while you type.
An assistant that reads the manual and checks its work.
Describe the simulation in a sentence. The agent searches an index of the engine's manual, tutorials and example inputs (LAMMPS today), writes the input, and runs it for zero timesteps with the executable you will use. Errors land on the line that caused them and the agent repairs them, up to ten attempts.
- Grounded in the documentation. Every command is looked up before it is written.
- Nothing half-finished is versioned. All attempts stay in version 1 until one passes.
- Your model, your key. Any OpenAI-compatible API; the key stays on your computer.
PromptA Lennard-Jones melt in reduced units: fcc lattice, 4000 atoms, start at T* = 3.0, NVE.
- Looking up the commands this needs
search_documentation"velocity create temperature reduced units"read_exampleexamples/melt/in.meltread_documentationpair_style lj/cut- Draft written, attempt 1 of 10
units lj atom_style atomic lattice fcc 0.8442 region box block 0 10 0 10 0 10 create_box 1 box create_atoms 1 box mass 1 1.0 velocity all create 3.0 87287 loop geom pair_style lj/cut 2.5 pair_coeff 1 1 1.0 1.0 2.5 neighbour 0.3 bin fix 1 all nve run 250
Every change is a version. Every run belongs to one.
Saving an input checks it first and records a new version only when it passes. Each run remembers the version, machine, executable and ranks it used, so you can always answer "which input made this?" and compare two runs side by side.
Version 3: Rebuild neighbor lists less often
- neigh_modify every 1 delay 0 check yes + neigh_modify every 20 delay 0 check no
| Run | Where | Ranks | Result |
|---|---|---|---|
| #5 | login.cluster | 32 | 44,100 steps/s |
See where the time goes.
Turn on profiling for a run and verlet-probe samples every MPI rank with eBPF, then merges them into one flame graph with the hottest functions and source lines. Put# verlet-probe start production and # verlet-probe stop around the part of the input you care about.
Also in the box
- Checks on save
- The engine reads your input with zero timesteps. Problems show the line, the parsed command and a link to its manual page.
- Every executable, one table
- Each simulation binary on each machine with its compiler, MPI, packages and how fast it has run.
- Compare runs
- Pick two runs for the deltas, overlaid thermo, the timing breakdown and hotspot changes.
- Outputs in one click
- Logs, dumps and restart files from remote runs download when the run ends.
- Local first
- Scripts, versions and history live in one SQLite file on your computer. No server, no account.
- Every rank, every second
- CPU and memory of the run, and each MPI rank's CPU over time, so an idle rank or a lopsided decomposition shows.
- Keyboard first
- Jump to any simulation or run with ⌘K, help on the command under the cursor with F1, the next problem with F8.
- Survives restarts
- Runs and builds keep going when verlet closes and are picked up again when it opens.
Where verlet is
verlet is under active development and in private preview. What is in the preview is not yet tested end to end on every platform; what is planned is listed so you know where it is going.
Workstations, GPU nodes and cluster login nodes, with verletrc installed in your home.
The first engine: inputs, runs, live thermo and builds from a YAML spec with Spack under ~/.verlet.
Retrieval from the engine manual, tutorials and examples; checked with your binary.
Completion and inline help for commands, styles and keywords; styles your executable lacks are marked.
eBPF sampling of every rank on Linux, merged into one flame graph.
macOS first; Linux and Windows builds after testing.
GROMACS and others, with the same versions, runs, live view and agent.
Submit to the queue instead of running on the login node, with the same live view.
Start nodes on a cloud account, prepare them, run, and shut them down.
Data files, molecules and force fields from a description, with a 3D preview.
RDF, MSD, block averages with error bars and publication-ready plots, without Python.
Freeze a run with its inputs, binary and outputs so an advisor can open or rerun it.
Request early access
verlet is in private preview. Leave your email and we will invite people in batches, macOS first. Tell us what you simulate and where it runs, and you help decide what comes next.