Load molecules

Paste SMILES, drop a file, or start from a reference set. Every structure is parsed by RDKit as it arrives, so anything malformed is flagged here rather than failing quietly three stages later.

Input

Drop a .smi, .csv, .txt or .sdf file or click to browse — one molecule per line, optional ID and label columns

Paste SMILES

Store canonical SMILES Columns: SMILES · ID · label

Set summary

What runs where. Parsing, drawing, descriptors and fingerprints are computed locally by RDKit in your browser. Nothing here is uploaded. The encoder stages call Hugging Face directly.

Molecule set

Convert representations

Canonical SMILES, InChI, molfiles and fingerprints come straight from RDKit. BRAID and SELFIES are yours — register a converter below and they become first-class everywhere else in the pipeline.

Inspect one molecule

Representation adapters

not registered

I don't know the BRAID grammar — it's your work, not something I can infer — so this stage stays open rather than guessing at it. Register the converter once and BRAID flows into tokenization, embedding and export automatically.

Reference implementations, not reimplementations. BRAID comes from braids/codec.py and SELFIES from the selfies package, both executed by backend.py. The codec needs RDKit's RWMol, GetValenceList and AssignCIPLabels, which the WebAssembly build does not expose — so a browser-side port would be a different algorithm wearing the same name.

Backend base URL

not connected

Mode

Endpoint URL

BRAID aromatic mode — cccccc^5 rather than C=CC=CC=C^5

The two BRAID modes are not interchangeable. BRAIDBERTa was pretrained on one of them; encode with the other and every token is off-distribution.

Converter body — receives smiles, returns a string

Decode

string back to structure

Notation

String

Draw structures

RDKit renders these as vectors, using the same element colours as the interface around them. Type a SMARTS pattern to highlight a substructure across the whole set.

Drawing controls

SMARTS highlight

Tile size — 210px

Annotations Atom indices Stereo labels

Bonds Kekulise rings Explicit methyls

Structures

Predict properties

Two different things, kept apart on purpose. Descriptors are exact values RDKit computes from the graph. The probe is a ridge head trained live on your labels over encoder embeddings — the standard way to ask what a representation actually carries.

Computed descriptors

Rule filters and reactive groups

Lipinski, Veber and a small set of well-known reactive substructures, matched as SMARTS. This is a demonstration set, not a curated PAINS catalogue — treat a clean result as "nothing obvious here", not as a pass.

Train a probe

Representation

Ridge α

CV folds

Labels come from you. Add a value in the label column on stage 01, or include a third column when pasting. The probe needs at least ten labelled molecules to say anything meaningful.

No probe trained yetEmbed a set on stage 06, add labels, then run cross-validation.

Benchmark tokenizations

Real tokenizers, pulled from the model repos and run in your browser — WordPiece and BPE, including byte-level. Two reference schemes sit alongside them so the numbers have something to mean.

Sources

Token-by-token

No tokenizers loadedFetch them above to see how each one cuts a molecule apart.

Comparison over the set

Token length distribution

Run the benchmark to see the distribution.

Compare encoders

Embed the same molecules with both models and an ECFP4 baseline, then look at what actually differs: how the space is laid out, whether the two agree on what counts as similar, and how much a linear head can pull out.

Run

Pooling

Batch size

Input representation

Embedding summary

Embed a set to compare.

Principal components

Two components of each embedding space, computed exactly.

Neighbourhood agreement

Mean Jaccard overlap of each molecule's k nearest neighbours between encoders.

Masked-token probe

Input

Mode

Mask token index

The two models read different notations. BRAIDBERTa consumes a BRAID token stream, DeepBERTa consumes SMILES. In SMILES mode this panel converts your molecule for each model, masks the token at the given index in that model's own tokenisation, and shows you the exact string it sent. One shared masked string cannot be correct for both.

Export datasets

Everything computed upstream, written out in a shape you can hand to someone else. The dataset card records which models, which tokenizers and which settings produced the file.

Columns

Format

File name

Valid molecules only

Preview

Pick columns to preview the file.