Contribution

Our contributions this year span both the technical and educational dimensions of synthetic biology.

We developed resources to support team formation, experimental design, and data management. These include the SynBio Speed-Dating activity, which we used in our kick-off event to introduce applicants to key concepts in synthetic biology. We also created an iGEM Registry API and an eLabFTW visualization script to improve data accessibility and lab documentation. Additionally, we prepared a bilingual Python cheat sheet for our educational outreach. We launched software development streams to share information about research software development and to educate others about MESA construction. Furthermore, we established a computational workflow that combines SPELL, AlphaFold2, and Rosetta for split protein design.

Together, these tools and materials embody our commitment to sharing knowledge, improving documentation practices, and fostering collaboration within the iGEM community for current and future teams.

SynBio Speed-Dating

Are you looking for a new way to introduce the new generation of iGEMers into the world of synthetic biology outside of a lecture hall? Or perhaps you are looking for a fun activity for educational workshops for students?

That’s where our SynBio Speed-dating comes in! We have prepared a document containing 100 SynBio terms, ranging from genetic parts, wet-lab techniques, dry-lab tools to socio-technical frameworks. Each term is explained in a concise description based on scientific literature. Where relevant, we also referenced past iGEM teams working with a respective tool or framework.

Moreover, we envision this activity, as not only a way to learn new biology tools, but also as an opportunity for the participants to get to know each other. That’s why each of the sheets contains also a “Get-to-know-each-other Bingo”. Just like in a classic bingo game, participants mark off fields when they meet someone who fulfills a certain criteria for example, “Speaks more than 3 languages”.

We implemented this activity during our kick-off events, where more than 50 future iGEM Munich 2025 applicants took turns in explaining synthetic biology terms to each other in a fast-paced speed dating format. Additionally, as part of our collaboration with the CJUH-JLU-China iGEM Team, we presented our sheets to them, hoping they help future teams in their initial Kick-off activities.

Instructions

For Participants:

1. Pick a handout with your assigned term/tool/framework.
2. Preparation (10 min): Review your term and its explanation. If needed, search for additional explanation online or ask organisers for help.
3. Speed-dating rounds (6 min each):
   • Introduce yourself.
   • Present your term/tool/framework to your partner.
   • Play the “Get-to-know-each-other Bingo”.
   • Switch partners and repeat.

For Organisers:

1. Prepare the room: arrange chairs in pairs so participants sit opposite each other.
2. Print out the handouts and categorize them by topic or required prior knowledge.
3. Use a timer to keep rounds on schedule.
4. Allocate time for participants to switch partners between rounds.
5. The number of rounds will depend on the group size and time constraints, but we recommend 8-15 rounds.

Depending on the number of participants and prior-biology knowledge level, adaptation of following instructions might be needed.

iGEM Registry API

Background

The iGEM Registry of Standard Biological Parts underwent a major overhaul August 2025. The new version introduced not only a modernized user interface, but also, for the first time, a comprehensive REST API, which serves as a dedicated programmatic access to all Registry’s main feature, including parts retrieval, modification, and publishing.

The launch of this new API brought exciting possibilities, but also a significant entry barrier. No existing package allows potential users to interact with the Registry in the programming languages they already know. Moreover, there is no easily accessible documentation describing the API’s functionality, endpoints, or the structure of request payloads and response objects. The only available insight is an internally generated Swagger reference, which remains incomplete: it lists endpoints but provides no schemas, field definitions, or data types.

To address this gap, we developed the iGEM Registry API package: a fully validated, Pythonic, and biologist-friendly wrapper for the new Registry API.

Features

By manually analysing the Registry’s public backend source code, we reconstructed many of the missing details about the API’s elements. Our package now spans over 7,500 lines of Python code, written to be both developer- and user-friendly. It includes extensive inline comments and complete docstrings for every submodule, class, and method. All components are rigorously typed and include detailed logging, ensuring clarity, stability, and consistency across the entire codebase.

Built with both Registry integration and end-user experience in mind, the package offers a streamlined authentication workflow and robust handling of the Registry’s conservative rate limits, which is a critical improvement for large-scale operations such as bulk part downloads. Registry data is represented by more than 15 Pydantic models, including Part, Annotation, Author, Organisation, License, Type, and others. These models not only validate API responses but also provide a structured, predictable, and interdependent interface that mirrors the actual architecture of the Registry.

Every aspect of the package was designed for intuitive and modular use. Complex REST interactions are abstracted into straightforward Python methods, allowing users to perform advanced operations through concise, readable function calls, such as session management or bulk operations.

While conceptually simple, our package extends iGEM Registry’s functionality with new sophisticated applications: unlike in the current beta version of the Repository (as of Oct 8th 2025), with our package users are able to run local BLAST searches on downloaded Registry sequences; using our package one can integrate Registry data with tools like Geneious Prime or other bioinformatics pipelines for local part analysis; our package enables bridging the gap between wet lab and dry lab serving as a bridge between the Registry and lab automation or electronic lab notebook software, such as Benchling or eLabFTW.

We thus hope that this package would serve as a valuable contribution for any future iGEMers and have published it on the Python Package Index (PyPI) repository for Python packages. While our project already provides a full programmatic read interface to all public Registry resources, write operations (e.g., creating or updating parts) and support for Collection and Documentation models are still planned for future releases. The code for of the package is available at both the iGEM GitLab and Github, where the development will continue.

Usage

The iGEM Registry API package can be easily installed from PyPI:

pip install igem_registry_api

The package is designed for immediate usability with minimal setup. For example, to connect anonymously and list public parts:

from igem_registry_api import Client, Part

client = Client()
client.connect()

parts = Part.fetch(client, limit=5)
for p in parts:
    print(p.name, p.uuid)

To authenticate with an iGEM account and access private data:

client.sign_in("username", "password")
account = client.account()
print(account.parts())

For more comprehensive usage, including authors, annotations, and composition loading, we included several example scripts, which are provided under examples/:

• quickstart.py: basic connection, authentication, and simple part retrieval.
• users_orgs.py: querying user accounts and their affiliated organisations.
• part_retrieve.py: fetching and inspecting specific parts by UUID or name with their sequences, annotations, and compatibilities.
• part_metadata.py: exploring part metadata, including part types, categories, and licenses.
• registry_dump.py: downloading the entire Registry catalogue with automatic pagination and rate-limit handling.
• registry_blast.py: running a local BLAST search against downloaded Registry sequences (a capability not provided by the Registry itself).

Example scripts can be easily executed as follows:

cd examples/
python3 examples/registry_blast.py

They were designed to produce clear, understandable outputs. The BLAST results are provided as an example:

eLabFTW Graph Overview

Every iGEM team has to somehow keep a record of their lab work and in some way publish it to their wiki. For the sake of keeping an overview that is accessible at all times to everyone and easily exportable to the wiki, many teams use an Electronic Lab Notebook, probably your team has been using one too. One of the most popular Electronic Lab Notebooks is eLabFTW. Its advantages over proprietary competitors are that it is completely open source and can be hosted on any machine. On top of this, eLabFTW provides a useful feature of linking experiments to each other.

Over the course of the iGEM year with multiple experiments going on simultaneously, it was very hard to keep a good overview of the work being done in the lab. For this, we wrote a Python script that generates a pdf containing all experiments done in the lab and their links to other experiments - whenever an experiment uses the results of another, they are linked. This way we could properly keep track of ongoing experiments.

Here is an example of a graph generated with the Python script:

pip install graphviz elabapi-python

# Import libraries
import graphviz as gv
import elabapi_python
import datetime

configuration = elabapi_python.Configuration()

# Enter elab api endpoint, typically ends with /api/v2, e.g. "https://elab.igem.org/api/v2"
configuration.host = "" 
if configuration.host == "": configuration.host = input()

# Enter ElabFTW bearer API key
key = "" 
if  key == "": key = input()

# Output filename
filename = "" 
extension = "pdf"

api_client = elabapi_python.ApiClient(configuration)
api_client.set_default_header(header_name='Authorization', header_value=key)
exp_client = elabapi_python.ExperimentsApi(api_client)
d = gv.Digraph()

# Download experiments
# Configure limit to your liking, for us, 200 is enough
experiment_list = exp_client.read_experiments(limit=200)

experiments = []

for exp in experiment_list:
    experiments.append(exp_client.get_experiment(exp.id))

# constructing graph

elab_graph = gv.Digraph(graph_attr={"nodesep":"0.15", "ranksep":"0.15", "splines": "True"})
for exp in experiment_list:
    col = "#"+exp.status_color if exp.status_color is not None else None
    elab_graph.node(str(exp.id), exp._date + " "+ exp.title[:exp.title.find("@")]+"\n"+exp.title[exp.title.find("@"):], color=col, shape="rectangle")

for exp in experiments:
    try:
        for j in exp.experiments_links:
            elab_graph.edge(str(exp.id), str(j.entityid))
    except: pass



elab_graph.render(filename if filename != "" else datetime.datetime.today().strftime('%Y-%m-%d')+"-elab-tree", format=extension)

Python Cheat Sheet

Our educational events Girl's day and iGEM@School , in which we gave teenage students hands-on wet-lab experience, also consisted of an introduction to bioinformatics and Python. Since a majority of the students had never written a line of code before these events, we compiled a cheat sheet that elucidates fundamentals of the Python programming language

How to split a protein and evaluate its function

Introduction

Protein splitting is a powerful biotechnology approach where a functional protein is divided into two inactive fragments that can be conditionally reassembled. This technique enables precise control of protein activity in living cells, making it invaluable for studying protein function, cellular signaling, and developing biosensors. However, identifying optimal split sites remains challenging. Poor split site selection can lead to spontaneous reassembly (high background activity) or inefficient reconstitution upon induction.

The computational workflow described in the video addresses these challenges by combining machine learning-based structure prediction with physics-based refinement to validate split protein designs. This multi-step validation pipeline ensures that proposed split sites maintain structural integrity while minimizing unwanted spontaneous assembly.

SPELL

SPELL (Split Proteins regulated by a ligand or by light) is a computational tool designed to identify promising split sites in target proteins. The algorithm calculates a “split energy” metric by comparing the summed energies of separated protein fragments to the energy of the intact protein. This thermodynamic approach helps predict which split sites will result in stable, yet controllable, protein fragments.

SPELL uses several criteria to identify optimal split sites. Split energy profiles identify regions where splitting minimizes destabilization, rating Surface accessibility favors exposed loops over buried structural elements, and Sequence conservation avoids disrupting functionally critical regions.

Dagliyan, O., et al. (2018). Computational design of chemogenetic and optogenetic split proteins. Nature Communications, 9(4042). https://www.nature.com/articles/s41467-018-06531-4

AlphaFold-2

After SPELL identifies candidate split sites, AlphaFold2 provides critical structural validation through deep learning-based protein structure prediction. AlphaFold generates highly accurate 3D models of both the intact protein and the proposed split fragments, enabling assessment of how splitting affects structural integrity.

Evaluation of AlphaFold-2’s output is aided by multiple metrics provided by the service. The pLDDT (predicted Local Distance Difference Test) is a per-residue confidence score ranging from 0-100 that indicates local structural accuracy. Scores above 90 indicate very high confidence in both backbone and side chain placement, while scores between 70-90 suggest confident backbone prediction. Low scores (below 50) often indicate intrinsically disordered regions or areas where the model lacks sufficient information. These scores help identify whether split sites occur in well-structured or flexible regions. Additional confirmation comes through PAE (Predicted Aligned Error), a pairwise confidence metric measuring the expected positional error between residue pairs. PAE is particularly valuable for split protein design as it reveals whether different domains or protein fragments maintain well-defined relative positions. High PAE values between split fragments suggest they may not reliably reassemble, while low values indicate stable spatial relationships. Finally pTM (predicted Template Modeling score) is an integrated measure of overall structural confidence, with scores above 0.5 suggesting the predicted fold may resemble the true structure. This global metric complements the local information from pLDDT and PAE.

Together, these metrics allow systematic evaluation of whether proposed split sites preserve essential structural features while introducing appropriate destabilization to prevent spontaneous reassembly.

Sources:

• Jumper, J., et al. (2021). Highly accurate protein structure prediction with AlphaFold. Nature, 596, 583-589. https://www.nature.com/articles/s41586-021-03819-2
• Tunyasuvunakool, K., et al. (2022). AlphaFold Protein Structure Database: massively expanding the structural coverage of protein-sequence space with high-accuracy models. Nucleic Acids Research, 50(D1), D439-D444. https://pmc.ncbi.nlm.nih.gov/articles/PMC8728224/

Rosetta Relaxation

The final validation step uses Rosetta’s Relax protocol to refine AlphaFold-predicted structures through physics-based energy minimization. This crucial step addresses potential structural artifacts from machine learning prediction and optimizes the geometry of split protein fragments.

FastRelax operates through iterative cycles:

1. Sidechain repacking uses rotamer sampling to explore alternative conformations
2. Gradient-based minimization of the backbone and sidechain torsional degrees of freedom
3. Ramped repulsive forces that cycle from 2% to 100% strength, enabling the structure to escape local energy minima and explore the conformational landscape

This “pulsing” approach of alternately compressing and expanding the structure allows atoms to settle into energetically favorable positions that may be inaccessible through simple gradient descent. The protocol performs at least 5 cycles and selects the lowest energy conformation.

For split protein validation, Rosetta relaxation serves several purposes. It resolves steric clashes and improves local geometry that AlphaFold may have missed. By providing energy scores that can be compared between intact and split versions, stability can be assessed. This protocol is also capable of identifying structural strain at or near the split site that might compromise function. By ensuring compatible surface geometries though the iterative force cycle it validates reassembly interfaces.

By combining Rosetta’s physics-based force field with AlphaFold’s structural predictions, this step provides critical validation that split sites are both structurally sound and energetically reasonable.

Sources:

• Tyka, M.D., et al. (2011). Alternate states of proteins revealed by detailed energy landscape mapping. Journal of Molecular Biology, 405(3), 607-618.
• Conway, P., et al. (2014). Relaxation of backbone bond geometry improves protein energy landscape modeling. Protein Science, 23(1), 47-55. https://pmc.ncbi.nlm.nih.gov/articles/PMC3892298/

Conclusion

This three-stage computational workflow of using SPELL for split site prediction, AlphaFold for structural validation, and Rosetta for physics-based refinement, provides a robust framework for designing split proteins with predictable behavior. By combining thermodynamic prediction, machine learning-based structure modeling, and energy minimization, researchers can confidently identify split sites that balance structural stability with inducible reassembly. This integrated approach reduces experimental trial and error, accelerating the development of split protein tools for cellular research and biotechnology applications.

The synergy between these complementary methods addresses limitations of any single approach. SPELL narrows the search space to thermodynamically favorable sites, AlphaFold provides atomic-level structural context with confidence estimates, and Rosetta validates these predictions under physics-based energy landscapes. Together, they enable rational design of split proteins for diverse applications in optogenetics, chemogenetics, and biosensor development.

Software Development YouTube Streams

Throughout MESA Designer’s development, we streamed the entire design and coding process on YouTube, creating transparent educational content that demystifies research software development. These streams served multiple educational goals: demonstrating practical software engineering approaches for scientific applications, providing insight into the iGEM software development process, and explaining MESA receptor biology to a broader audience. By showing real problem-solving and including debugging sessions, design decisions, and iterative refinement, we created authentic learning resources that go beyond polished tutorials to reveal the actual workflow of building computational tools and including a public audience in the creation of MESA Designer. The streams accumulated over 200 views, reaching students and other iGEM Teams in the intersection of software development and biological engineering while establishing a replicable model for transparent, educational open science communication. Check out our YouTube Channel