Helmkit: fast and robust conversion of HELM notation to atomistic representations for large-scale macromolecular informatics Authors: Ramon Adàlia, Gemma Sanjuan, Tomàs Margalef, Ismael Zamora Published: 2026 ABSTRACT AbstractThe Hierarchical Editing Language for Macromolecules (HELM) provides a powerful framework for representing complex biomolecules, including peptides, oligonucleotides, and hybrid constructs, but existing tools for converting HELM notations to atomistic models suffer from limitations in speed, scope, and robustness. We introduce helmkit, an open-source Python library that enables direct, high-throughput conversion of HELM strings to RDKit molecular objects. Designed for general macromolecular structures, helmkit supports peptides, nucleic acids, chemical linkers, and hybrids, while natively handling inline monomers, special characters in names, and automatic inference of missing attachment points. Its streamlined architecture, with minimal dependencies and built-in parallelization, achieves processing speeds of up to 5,000 HELM entities per second. Validation on large-scale datasets from PubChem (878,442 entries) and CycPeptMPDB (7,298 entries) demonstrates near-perfect accuracy, with helmkit successfully parsing structures that fail in other libraries. By facilitating efficient, scalable analysis of diverse macromolecules, helmkit advances computational workflows in drug discovery, virtual screening, and biomolecular engineering. Scientific contribution We introduce a lightweight Python library that provides direct and accurate conversion from HELM notation to atomistic RDKit representations, addressing a practical limitation of existing cheminformatics tools. Unlike prior approaches, the library supports peptides, RNA, chemical linkers, and hybrid molecules within a single framework, while remaining robust to real-world HELM variants through built-in error correction and R-group inference. Validation on public datasets and high-throughput performance demonstrate that the method is reliable and suitable for large-scale molecular data processing.Keywords: HELM, Python, Macromolecules, RDKit, Cheminformatics, High-throughput Introduction Macromolecules such as peptides [5], oligonucleotides [22], and hybrid constructs [23] play a central role in modern biology and drug discovery. These molecules include peptides that act as hormones and signaling agents [3], oligonucleotides that regulate gene expression [1], and conjugates that combine small molecules, linkers, and biopolymers into multifunctional therapeutics [7]. Collectively, they span a continuum between small molecules and large biologics, offering tunable specificity, potency, and pharmacokinetic properties [25]. Their expanding use across oncology, metabolic disorders, and infectious diseases highlights the growing need for computational tools capable of handling their structural diversity. With the increasing sophistication of designed macromolecules, including non-natural residues, cyclic topologies, chemical linkers, and hybrid architectures, manual analysis and representation have become unfeasible. Computational tools are essential for virtual screening, property prediction, structure generation, and synthetic planning. Central to these applications is the ability to accurately represent and manipulate macromolecular structures in silico [2]. However, existing cheminformatics tools are typically tailored to either linear biopolymers or small molecules, making them ill-suited for hierarchical structures that combine both [9]. Biopolymers can be represented in a variety of ways. Sequence-based formats such as FASTA [15] encode peptides or nucleic acids as strings of monomer symbols, providing a compact and human-readable representation. However, they cannot describe non-linear architectures, chemical linkers, or modified monomers. Conversely, atom-level formats such as SMILES [26], InChI [6], or MDL [4] describe molecules as arbitrary chemical graphs, allowing full flexibility but losing the hierarchical, monomer-based organization that facilitates sequence-level operations. Tasks such as identifying termini, counting residues, or mapping modifications become nontrivial graph traversal problems. The Hierarchical Editing Language for Macromolecules (HELM) [28] was developed to bridge this gap. HELM combines the clarity of sequence-based notation with the expressiveness of chemical graph representations. It encodes macromolecules as sets of named monomers connected through explicitly defined attachment points. Each monomer’s chemical structure and bonding information are defined in a monomer database, enabling the representation of peptides, RNA, DNA, chemical linkers, and hybrid constructs within a unified framework. While several open-source tools can parse HELM, they often suffer from limited functionality and poor scalability. For example, the widely used RDKit [10] provides only basic parsing and cannot handle extended monomer definitions or nested polymer structures. The more recent pyPept library [14] supports custom monomers but focuses exclusively on peptides, lacks support for inline monomers, and struggles with datasets where monomer names contain special characters, which are issues common in public resources such as PubChem [8] or CycPeptMPDB [11]. Furthermore, its performance constraints, typically processing only a few molecules per second, limit its suitability for high-throughput workflows. To overcome these limitations, we introduce helmkit, a dedicated Python library for converting HELM strings into RDKit molecular objects. Unlike peptide-specific tools, helmkit is designed for general hierarchical structures, supporting peptides, nucleic acids, chemical linkers, and hybrid combinations thereof. It natively handles inline monomers, custom monomer definitions, and special character encodings, ensuring compatibility with real-world datasets. The implementation emphasizes efficiency and robustness, with built-in parallelization and optimized data structures enabling throughput approaching 5,000 HELM entities per second on standard hardware. helmkit has been validated across large-scale datasets from PubChem and CycPeptMPDB, demonstrating both correctness and scalability for modern macromolecular informatics. Related work The development of tools for handling macromolecular structures has evolved alongside the increasing complexity of biotherapeutic design. Several open-source software packages support the parsing, manipulation, and conversion of HELM notation, reflecting its adoption as a standard for representing diverse biomolecules. These tools vary in scope, from general-purpose cheminformatics libraries to specialized parsers, but often exhibit limitations in scalability, flexibility, or integration with popular Python ecosystems such as RDKit. Below, we survey key existing approaches, highlighting their strengths and gaps that helmkit addresses. General cheminformatics libraries with HELM support Prominent open-source cheminformatics toolkits provide partial support for HELM, primarily focusing on basic parsing and conversion to molecular objects. The RDKit library itself offers native HELM parsing through the MolFromHELM function, which converts HELM strings directly into Chem.Mol objects. This functionality is efficient for standard monomers, such as natural amino acids and nucleotides, and integrates seamlessly with RDKit’s extensive suite of molecular manipulation tools. However, RDKit’s HELM support is constrained to a predefined set of monomers; user-supplied custom monomers are not natively supported. As a result, it is unsuitable for diverse real-world datasets without significant preprocessing. Other general libraries, such as the Chemistry Development Kit (CDK) [24] in Java, indirectly support HELM through integrations with specialized toolkits (discussed below). CDK excels in graph-based molecular representations and can generate SMILES or other formats from parsed structures, but it does not natively parse HELM, requiring additional layers for macromolecular handling. Pistoia alliance HELM toolkit and editors The Pistoia Alliance, the organization behind the HELM standard, maintains a suite of open-source tools under the PistoiaHELM project on GitHub [17]. These are primarily implemented in Java and serve as reference implementations for HELM parsing and manipulation. The HELM2 Notation Toolkit [19] is the core reference implementation for HELM version 2.0. It provides robust parsing of HELM strings, creation of HELM notation objects, validation, and basic calculations (e.g., molecular weight). Leveraging CDK for chemistry operations, it supports ambiguous structures and can be configured for external monomer databases via web services. While it enables conversion to atom-level representations such as SMILES through CDK, it does not directly output RDKit-compatible molecules and is not designed for Python workflows. An earlier HELM Notation Toolkit exists for version 1.0, with similar features but without ambiguity support. Complementing the toolkit are graphical editors: the HELM Web-editor [20], a web-based tool for drawing and editing biomolecules, and the HELM Antibody Editor (HAbE) [18] for specialized antibody notations. These tools facilitate visual structure creation and export to HELM strings but are not optimized for batch processing or programmatic conversion. A.NET implementation of the HELM Toolkit is also available, offering similar parsing capabilities for Windows-centric environments, although it lacks the CDK integration for advanced conversions. Overall, the Pistoia tools provide comprehensive HELM compliance and are ideal for validation or standalone Java/.NET applications. However, their language-specific nature limits their adoption in Python-dominated cheminformatics pipelines, and their performance in high-throughput scenarios is not emphasized. Specialized python libraries In the Python ecosystem, options for HELM handling are more limited, with a focus on domain-specific applications. The pyPept library [14] is a notable Python tool for peptide structures, supporting HELM parsing and conversion to RDKit molecules. To the best of our knowledge, it is the only Python library capable of handling HELM with custom monomer libraries. It handles custom monomers via SDF files and includes features for 2D/3D conformer generation. However, as detailed in Sect. Differences with pyPept, pyPept is restricted to peptides, employs inefficient intermediate representations (e.g., BILN to sequence), requires multiple dependencies (e.g., pandas, Biopython, igraph), and struggles with monomer names containing special characters. Its performance, at a few molecules per second, hinders large-scale use, and error handling via process termination (exit()) is suboptimal for robust applications. Gaps and opportunities Existing tools demonstrate HELM’s maturity but reveal key shortcomings: general libraries such as RDKit lack extensibility for custom macromolecules, Pistoia tools are not Python-native, and specialized options such as pyPept are narrow in scope and inefficient. None emphasize parallel processing, inline monomer support, or automatic R-group inference for underspecified datasets such as PubChem. helmkit fills these voids by offering a lightweight, Python-centric library with direct HELM-to-RDKit conversion, broad macromolecular compatibility, and high-throughput capabilities, making it a valuable addition to the ecosystem. HELM notation The Hierarchical Editing Language for Macromolecules (HELM) [28] is a line notation developed to represent complex biomolecular structures in a concise, hierarchical, and computationally accessible format. It overcomes the limitations of sequence-based or atom-only representations by organizing structural information across four levels: complex polymer, simple polymer, monomer, and atom. This hierarchy enables the accurate encoding of large, chemically modified biomolecules, including peptides, oligonucleotides, antibody–drug conjugates, and crosslinked systems, while remaining convertible to both atomic-level formats (e.g., SMILES, InChI) and biological sequences. A complete HELM notation is structured as a string with sections delimited by dollar signs ($): Only the simple polymer list is mandatory. Simple polymers A simple polymer represents a single linear chain of monomers sharing the same polymer type (e.g., PEPTIDE, RNA, CHEM). Each is denoted as: where PolymerID follows the form TYPE# (e.g., PEPTIDE1, RNA1), uniquely identifying the chain within the notation. The simple polymer notation concatenates monomer IDs from left to right, following these rules: Single-letter IDs for natural monomers (e.g., A, G, U) are written directly. Single-letter IDs for natural monomers (e.g., A, G, U) are written directly. Multi-letter IDs for modified or non-natural monomers are enclosed in square brackets (e.g., [dF], [mR]). Multi-letter IDs for modified or non-natural monomers are enclosed in square brackets (e.g., [dF], [mR]). Branch monomers are enclosed in parentheses and attached to the preceding backbone monomer (e.g., R(A) attaches base A to ribose R). Branch monomers are enclosed in parentheses and attached to the preceding backbone monomer (e.g., R(A) attaches base A to ribose R). Periods (.) separate monomers into logical groups. Periods (.) separate monomers into logical groups. Backbone chain extension implicitly connects R2 of one monomer to R1 of the next, whereas branch chain extension connects R3 in the backbone to R1 in the branch. Backbone chain extension implicitly connects R2 of one monomer to R1 of the next, whereas branch chain extension connects R3 in the backbone to R1 in the branch. Monomers need to be defined externally with a SMILES or Molfile structure, a unique ID within their polymer type, and labeled attachment points (R1, R2, etc.) with default capping groups. For example, the peptide sequence: represents a 10-residue chain (N- to C-terminus) with two modified amino acids ([dF], [ahA]). An RNA strand using the sugar–base–phosphate model: encodes a 4-nucleotide sequence (5’ to 3’) with a modified sugar (mR, dR), a phosphate linker (sP), and a base (5meC). The CHEM polymer type is reserved for nonspecific chemical modifiers (e.g., linkers). Due to the absence of predefined connection rules, each CHEM simple polymer contains exactly one monomer, and enclosing brackets can be omitted for multi-letter identifiers. Complex polymers Intrapolymer connections enable cyclic structures and branches; interpolymer connections support conjugates and crosslinks. Interconnections between simple polymers are specified in the connection list via the following format: where the positions are 1-based indices within each simple polymer and where R1, R2, R3, etc., denote attachment points. For example: links the R2 site of the 21st monomer in RNA1 to R1 of the single monomer in CHEM1. Hydrogen bonds and annotations Non-covalent interactions, such as base pairing in double-stranded RNA, are captured in the hydrogen bond list as follows: Note that hydrogen bonds do not define bonds between specific atoms, but rather between two monomers, which is why the word pair is used instead of specific attachment points such as those in the connection list. Finally, polymer-specific metadata are provided in the attribute list: Implementation Requirements and installation The helmkit library is designed for compatibility with modern Python environments and depends only on Python version 3.11 or higher, along with the RDKit cheminformatics library. No additional third-party packages are required for core functionality. The package is officially distributed through PyPI and can be installed using pip install helmkit. Further instructions, including guidance on the development environment setup and custom monomer library configuration, are provided in the repository’s README.md file. helmkit design The helmkit library is engineered with a focus on modularity, efficiency, and extensibility to facilitate seamless integration into cheminformatics pipelines. The primary entry point is the Molecule class constructor, which accepts a single HELM string as input. This class encapsulates all necessary methods for parsing the HELM notation and converting it directly to an RDKit Chem.Mol object. Internally, the class maintains state for the RDKit molecule, inter-monomer bonds, individual monomers, and polymer chains. The parsing process begins by dissecting the HELM string into its constituent sections: simple polymers, connections, hydrogen bonds (if present), and attributes. For each simple polymer, the monomers are parsed sequentially. In peptide chains, connections are formed by linking the R2 attachment point of one monomer to the R1 of the next. For RNA polymers, the logic accommodates branched structures: bases enclosed in parentheses are attached via their R1 to the R3 of the preceding sugar monomer, whereas the backbone continues from the R2 of the sugar to the next monomer (e.g., a phosphate). Unutilized R-groups are capped with appropriate substituents, such as hydrogens or hydroxyls, based on the monomer definitions. Connections between polymers are applied post-parsing, and the specified attachment points are used to form covalent bonds. Hydrogen bonds in HELM are specified at the monomer level using pair annotations, which represent non-covalent interactions such as Watson–Crick base pairing in nucleic acids. Due to potential ambiguities in mapping these to specific atoms (e.g., multiple hydrogen bonds per pair), helmkit parses and stores them as metadata attributes on the Molecule object but does not integrate them into the covalent RDKit graph, due to their non-covalent nature and the ambiguity in atom-level mapping. Future extensions may include optional atom-level resolution based on standard pairing schemes. Error handling is robust, with descriptive exceptions raised for invalid HELM syntax, undefined monomers, or incompatible attachments. These exceptions include contextual information such as the problematic HELM substring and the specific parsing stage where the error occurred, facilitating debugging. This design ensures that the library fails gracefully without terminating the parent process, enabling batch processing workflows where individual failures should not halt the entire operation. Differences with pyPept The pyPept library is a Python tool designed for parsing and manipulating peptide structures, supporting conversion from HELM to RDKit molecules via intermediate representations such as Boehringer Ingelheim Line Notation (BILN) and sequence objects. While pyPept is effective for its intended domain, helmkit addresses several limitations and design choices that impact both performance and usability. A comprehensive comparison of key differences is presented in Table 1. Table 1Feature comparison between pyPept and helmkitFeaturepyPepthelmkitPeptide support✓✓Nucleic acid support✘✓Chemical linker support✘✓Hybrid macromolecules✘✓Inline monomer definitions✘✓Special characters in monomer names✘✓Parallel parsing✘✓Session-wide monomer cache✘✓Single-file monomer library input✘✓Exception-based error handling✘✓Conversion pathHELM → BILN → Sequence → RDKitHELM → RDKitDependenciesrdkit, pandas, biopython, requests, igraphrdkit only Feature comparison between pyPept and helmkit The most fundamental architectural difference lies in the conversion pathway. Whereas pyPept employs a multi-step pipeline (HELM → BILN → Sequence → RDKit), helmkit performs direct conversion from HELM to RDKit, eliminating intermediate representations. This design choice reduces computational overhead, minimizes potential error sources, and simplifies the codebase. The streamlined approach contributes significantly to the performance improvements demonstrated in Sect. Performance, where helmkit achieves speedups of over 300× compared with pyPept. In addition to architectural differences, helmkit extends support to a broader range of biomolecules. While pyPept is restricted to peptides, helmkit natively handles nucleic acids, chemical linkers, and hybrid macromolecules, making it suitable for a wider variety of HELM-encoded structures. This expanded scope is particularly valuable for applications involving RNA therapeutics, peptide–nucleic acid conjugates, and other complex biomolecular systems. Operational differences also distinguish the two libraries. helmkit loads the monomer library once per session and reuses it across multiple parsing operations, whereas pyPept reloads the library for every peptide. This design, combined with the simpler dependency footprint (RDKit only, versus five dependencies for pyPept), reduces both the initialization overhead and the installation complexity. Additionally, helmkit requires only a file path to the monomer library, whereas pyPept demands a directory structure organized as a Python module with __init__.py. Robustness is another key differentiator. helmkit tolerates monomer names containing special characters such as whitespaces, hyphens, and parentheses, provided that they do not disrupt bracket or parenthesis balancing. In contrast, pyPept enforces strict naming conventions and fails on such inputs. This flexibility is crucial for processing real-world datasets such as CycPeptMPDB, where pyPept often encounters parsing failures due to non-standard monomer names. Finally, error handling approaches differ substantially. helmkit raises Python exceptions that can be caught and handled programmatically, enabling graceful error recovery and integration into larger workflows. pyPept, however, calls exit() upon encountering errors, which abruptly terminates the entire process. This design choice makes pyPept unsuitable for batch processing scenarios where individual failures should not halt the entire operation. Custom monomer libraries To accommodate diverse macromolecular datasets, helmkit allows loading custom monomer libraries via the load_monomer_library utility function, which accepts a path to an SDF file. This function employs a least-recently-used (LRU) cache to prevent redundant loading of the same library, optimizing memory and time in batch processing scenarios. The loaded library is structured as a dictionary, with top-level keys representing monomer types (e.g., aa for amino acids, rna for nucleic acid components, and chem for chemical linkers). Each type maps to a sub-dictionary where keys are monomer names and values are dictionaries containing the RDKit molecule, R-group indices, substituents, and attachment points. These details must be annotated in the SDF file using tags compatible with pyPept: symbol (monomer ID), m_Rgroups (substituent specifications), m_RgroupIdx (R-group atom indices), and m_type (monomer category). Unlike pyPept, helmkit infers attachment points automatically from the R-group indices, eliminating the need for explicit definitions. Additionally, the SDF file can reside at any filesystem path, without requiring encapsulation in a Python module. In-line monomer support Public repositories such as PubChem frequently embed monomer definitions directly within HELM strings using SMILES notation augmented with R-group placeholders. These inline definitions typically omit unused substituents, including only attachment-relevant R-groups. For instance: helmkit natively parses such inline monomers by extracting the SMILES, identifying R-group labels (e.g., _R2), and integrating them into the molecule assembly. This feature ensures compatibility with real-world data sources without requiring external monomer databases. Automatic R-group inference In cases where inline or custom monomers lack explicit R-group definitions, which occurs in PubChem for several in-line amino acids, helmkit employs heuristic substructure matching to infer attachment points. This is activated only for peptide monomers to maintain specificity. The matching is performed using SMARTS (SMiles ARbitrary Target Specification) patterns, a cheminformatics language that extends SMILES to describe molecular substructures with precise atom and bond constraints. SMARTS allows specification of atom types, hybridization states, hydrogen counts, and bond orders, enabling robust pattern matching against molecular graphs. For the N-terminal R1 (amine group), the library searches for patterns such as [#6][NX3H][#6] (alpha-amino carbon) or [NX3H2][#6] (primary amine). If exactly one match is found, a placeholder atom is appended as the R1 group, with the attachment indexed accordingly. For the C-terminal R2 (carboxyl group), patterns such as [CX3H1]=O (aldehyde) or CX3[OH] (carboxylic acid) are matched. A similar placeholder is added if exactly one match exists. This inference prevents parsing failures and enables the processing of underspecified monomers, with the placeholders later replaced during chain assembly. Parallel processing For high-throughput applications, helmkit provides the load_in_parallel function. This accepts a list of HELM strings and an optional custom monomer library path, returning a list of RDKit molecules. Leveraging Python’s multiprocessing module, it distributes parsing across available CPU cores, potentially achieving linear speedups on multicore systems. Usage examples This section demonstrates how to use helmkit for converting HELM notations into atomistic representations. The examples cover basic usage, custom monomer libraries, parallel processing, and complex real-world scenarios. Basic HELM to RDKit conversion The simplest use case for helmkit is converting a HELM string into an RDKit molecular object. The following example demonstrates parsing a HELM notation containing two peptide chains connected by a covalent bond: By default, helmkit uses an internal library containing 644 amino-acid monomers and 343 RNA monomers, covering both common and unusual building blocks. The peptide monomers originate from pypept, CycPeptMPDB, and a small set manually curated to match data from PubChem. The RNA monomers are based on the Pistoia Alliance HELM set, supplemented with additional entries curated from PubChem. This default library provides immediate, configuration-free support for most standard macromolecules. Key attributes are available to inspect the resulting structure: molecule.monomers: A list of dictionaries, each describing a single monomer (chain identifier, name, type, abbreviation, etc.). molecule.monomers: A list of dictionaries, each describing a single monomer (chain identifier, name, type, abbreviation, etc.). molecule.monomer_indices: An array mapping each atom in the molecule to its parent monomer. For example, [0, 0, 0, 1, 1] means that the first 3 atoms belong to monomer 0 and the next 2 to monomer 1. molecule.monomer_indices: An array mapping each atom in the molecule to its parent monomer. For example, [0, 0, 0, 1, 1] means that the first 3 atoms belong to monomer 0 and the next 2 to monomer 1. molecule.bond_indices: The list of 0-based indices of all inter-monomer bonds in the atomistic structure. molecule.bond_indices: The list of 0-based indices of all inter-monomer bonds in the atomistic structure. molecule.hydrogen_bonds: A list of tuples, each describing a single hydrogen bond (source chain, source monomer, target chain, target monomer). molecule.hydrogen_bonds: A list of tuples, each describing a single hydrogen bond (source chain, source monomer, target chain, target monomer). Custom monomer libraries Custom monomer databases can be loaded in SDF format to override the default set: Parallel batch processing For high-throughput tasks involving large batches of HELM strings, helmkit supports parallel parsing using all available CPU cores: Examples The following examples illustrate helmkit’s capabilities with complex macromolecular structures. Figure 1 presents a HELM string defining a peptide–RNA conjugate using the PAD4 (phosphoramidite derivative 4) linker [12]. Note that chain integer identifiers only require uniqueness within each chain type. Peptide-RNA conjugate using the phosphoramidite derivative 4 linker and the corresponding HELM Figure 2 shows a HELM string for a lariat-shaped peptide containing non-standard amino acids from the CycPeptMPDB database [27]. helmkit can process special characters and complex monomer names that often break other HELM toolkits. Lariat peptide from CycPeptMPDB with special characters in the monomer identifiers of the corresponding HELM helmkit also reliably parses HELM notations containing monomers defined by inline SMILES and can infer missing R-groups, which is something essential for poorly specified inputs. Figure 3 illustrates such a scenario with an example from PubChem [13], where the first and third monomers lack explicit R2 and R1, but are correctly interpreted by the library. Example peptide from PubChem, featuring monomers with missing R-groups in their inline SMILES Real-world therapeutic conjugates emphasize why robust HELM support matters in practice. Clinical candidates frequently mix canonical residues, heavily modified monomers, and small organic payloads inside a single notation, stressing parser flexibility. Figure 4 shows the approved 177Lu-DOTATATE radioligand [16], where a cyclic octreotide core is connected both internally (disulfide between residues 2 and 7) and externally to a DOTA-lutetium payload. Similarly, Fig. 5 shows zoptarelin doxorubicin [21], a GnRH decapeptide linked through a glutaric spacer to a doxorubicin payload, illustrating two independent CHEM polymers attached to a single peptide chain. These examples underline how helmkit faithfully resolves complex attachment logic into RDKit graphs that can be directly used for property calculations or visualization. 177Lu-DOTATATE and the corresponding HELM encoding Zoptarelin doxorubicin and the corresponding HELM encoding Results Testing The validation of helmkit employed a multi-tiered approach combining systematic random generation and large-scale dataset validation to ensure both correctness and robustness across diverse macromolecular structures. The testing strategy addresses the inherent complexity of HELM parsing, where errors in monomer connection, R-group handling, or attachment point resolution can propagate to produce incorrect molecular graphs that may still be chemically valid but structurally distinct from the intended representation. Integration tests were implemented using Python’s pytest framework, exercising core parsing functionality, monomer library loading, R-group inference, and connection handling. To validate end-to-end correctness, tests compared HELM-derived RDKit molecules against equivalent structures parsed from alternative representations using well-established tools. The International Chemical Identifier (InChI) served as the primary validation metric, providing a canonical representation that is sensitive to structural differences while remaining invariant to the representation format. For each test case, InChI strings computed from HELM-parsed molecules were compared against reference InChI values derived from equivalent input formats. Figure 6 illustrates this process. Validation flow for HELM parsing with helmkit Systematic validation employed randomly generated macromolecules to exercise the parser across a broad parameter space. Monomers were sampled from standard biological sets: the 20 canonical amino acids for peptides, and the four standard RNA bases (A, C, G, U) along with ribose sugar and phosphate linker for nucleic acids. Peptides were constructed as linear chains spanning 2–50 residues, while RNA structures tested both common monomer orderings: [sugar](base)[linker] and [linker][sugar](base) formats, with chain lengths ranging from 5–40 nucleotides. For each set, 1,000 random HELM strings were generated, parsed, converted to an RDKit molecule, and cross-validated by parsing the equivalent sequence representation (FASTA) using RDKit’s native parsers and comparing the resulting InChI identifiers. Large-scale validation leveraged real-world datasets to assess the performance on structures encountered in production environments. The PubChem database provided 878,442 entries containing HELM notations for peptides and RNA, including 867,922 peptide entries as of August 11, 2025 and 10,520 RNA records. Prior to validation, double-bond stereochemistry and isotopic specifications were intentionally stripped, as these features cannot be consistently or unambiguously represented within the constraints of HELM. The CycPeptMPDB dataset (version 1.2) comprised 7,298 cyclic and lariat peptides, including complex topologies and non-standard modifications that challenge parsing robustness. For each entry with available monomer definitions, the HELM string was parsed, converted to an RDKit molecule, and the computed InChI was compared against reference values. Discrepancies underwent manual inspection to distinguish library errors from database inconsistencies, leading to iterative refinements in R-group inference algorithms and connection-handling logic. Table 2 summarizes the full set of validation results, which demonstrate that helmkit performs accurately across all datasets. For PubChem, pyPept was evaluated only on the peptide subset because of its limited domain support. Among the 867,922 peptide HELM entries, 90,095 (≈10.38%) were successfully parsed, with most errors stemming from its inability to handle inline monomers. In contrast, helmkit achieved over 99% concordance across the full PubChem HELM dataset. All RNA-related failures were manually inspected, and every case was traced back to incorrect structures embedded in the in-line monomers, with the vast majority caused by a missing oxygen atom in diphosphate or triphosphate groups. Peptide discrepancies were also examined on a sampled basis, and all checked cases were confirmed to have originated from database errors, although the full set was too large to review exhaustively. Table 2Summary of dataset-level success rates for the synthetic and large-scale testsSynthetic testsDatasethelmkitpyPeptRandom peptides (1,000)✓ 1, 000/1, 000 (100%)✘ 992/1, 000 (99.2%)Random RNA (1,000)✓ 1, 000/1, 000 (100%)✘ 0/1, 000 (0%)Real-world datasetsCycPeptMPDB✓ 7, 298/7, 298 (100%)✘ 4, 694/7, 298 (64.3%)PubChem peptides✓ 864, 102/867, 922 (99.56%)✘ 90, 095/867, 922 (10.38%)PubChem RNA✓ 10, 355/10, 520 (98.43%)✘ 0/10, 520 (0%) Summary of dataset-level success rates for the synthetic and large-scale tests Performance Performance benchmarks were conducted using the CycPeptMPDB dataset, which comprises 7,298 cyclic peptides in HELM format. To enable the comparison, entries with monomer names incompatible with pyPept (e.g., containing whitespaces, hyphens, or parentheses) were excluded, yielding 4,694 peptides for benchmarking. We measured the total and average parsing time for each tool (Table 3): Table 3Performance comparison on the CycPeptMPDB datasetToolTotal time (s)s/peptidePeptides/sSpeedup vs pyPeptpyPept676.650.144006.941.0×helmkit (Forced DB reload)252.670.0538318.582.7×helmkit2.070.000442267.63327×helmkit (parallel loading)0.950.000204926.11712× Performance comparison on the CycPeptMPDB dataset helmkit outperforms pyPept by approximately 327× when the monomer library is loaded once per session. When forced to reload the library for every peptide, helmkit is still approximately 3× faster. If we use parallelized loading in helmkit, we achieve an additional 2× speedup, resulting in a total speedup of approximately 712× over pyPept. Benchmarks were run on an Intel Core i7-4790 (4 cores, 8 threads, 3.6 GHz) with 31.1 GiB RAM and SSD storage, using Python 3.12.10 on Arch Linux (kernel 6.15.7). Key package versions: polars 1.31.0 (CSV parsing and dataframe processing) polars 1.31.0 (CSV parsing and dataframe processing) rdkit 2025.3.3 (target output format and structure processing) rdkit 2025.3.3 (target output format and structure processing) pypept 1.0.0 (commit ade9f5840691ad1f8fa22d13939a665c25175d5a) pypept 1.0.0 (commit ade9f5840691ad1f8fa22d13939a665c25175d5a) helmkit 0.7.0 (local development version) helmkit 0.7.0 (local development version) Conclusion We have introduced helmkit, a Python library that addresses fundamental limitations in existing HELM parsing tools through architectural innovation and comprehensive biomolecule support. The library’s direct HELM-to-RDKit conversion pathway, which eliminates intermediate representations used by tools such as pyPept, achieves speedups exceeding 300× in standard configurations and over 700× with parallelization, enabling a throughput of nearly 5000 HELM entities per second on commodity hardware. In addition to performance, helmkit extends functionality to nucleic acids, chemical linkers, and hybrid macromolecules, addressing a critical gap where existing tools are restricted to peptides. The implementation’s robustness is demonstrated through successful processing of real-world datasets that challenge other parsers: helmkit achieves 100% concordance on CycPeptMPDB and >99% on PubChem’s HELM entries, handling monomer names with special characters, inline SMILES definitions, and missing R-groups that cause failures in alternative tools. Key design decisions contribute to both performance and usability. The single-dependency architecture (RDKit only) simplifies deployment, whereas session-level monomer library caching eliminates redundant I/O operations. Programmatic error handling via exceptions enables batch processing workflows that are impractical with tools that terminate the process on errors. These features, combined with support for arbitrary monomer naming conventions, make helmkit suitable for production cheminformatics pipelines that process diverse macromolecular datasets. Validation across thousands of structures from public repositories confirms both correctness and scalability. The library’s ability to process datasets like CycPeptMPDB that are partially incompatible with existing tools demonstrates its practical value for modern macromolecular informatics. As the field increasingly relies on hierarchical representations for complex therapeutics, helmkit provides a foundation for high-throughput analysis of peptides, oligonucleotides, and hybrid constructs within unified computational workflows. Potential extensions to helmkit include atom-level resolution of hydrogen bonds based on standard pairing schemes, which would enable explicit representation of non-covalent interactions in the molecular graph. Support for more HELM notation features, integration with conformer generation tools, and export formats that preserve hierarchical information represent additional directions for expansion. The development of formalized benchmark suites and enhanced monomer curator tooling could facilitate broader community adoption and contributions to monomer libraries. Acknowledgements The authors acknowledge support from the PubChem team at NCBI, who assisted in compiling HELM and related biologic notation data used for testing in this work. Author contributions RA conceptualized the project, designed and implemented the helmkit library, conducted validation and performance testing, and wrote the original draft of the manuscript. GS and TM provided supervision, resources, and critical revisions of the manuscript. IZ contributed to project conceptualization, provided supervision, and reviewed the manuscript. Funding This research was conducted with the support of Pla de Doctorats Industrials del Departament de Recerca i Universitats de la Generalitat de Catalunya (grant number 2023-DI-00006). Availability of data and materials • Project name: helmkit • Project home page: https://github.com/adaliaramon/helmkit • Archived version: https://doi.org/10.5281/zenodo.17909787 • Operating system(s): Platform independent • Programming language: Python • Other requirements: Python 3.11 or higher • License: MIT • Any restrictions to use by non-academics: None Declarations Conflict of interest The authors declare no conflict of interest. Footnotes Publisher's Note Springer Nature remains neutral with regard to jurisdictional claims in published maps and institutional affiliations. References Associated Data Data Availability Statement • Project name: helmkit • Project home page: https://github.com/adaliaramon/helmkit • Archived version: https://doi.org/10.5281/zenodo.17909787 • Operating system(s): Platform independent • Programming language: Python • Other requirements: Python 3.11 or higher • License: MIT • Any restrictions to use by non-academics: None