I saw today that EvoDevo, one of the key journals in the field of evolutionary developmental biology, has been rebranded as Developmental Biology Advances. The announcement frames it in a positive light:

This change marks an exciting new chapter, continuing to highlight the integrative research that has defined EvoDevo while expanding the journal’s scope and reflecting a broader vision in developmental biology.

But I can’t deny I feel a little sad with the news. EvoDevo (the journal) wasn’t the only journal publishing evo-devo research, far from it; but, in a way, it did wave the flag of Evo-Devo (the field) to the rest of the scientific community.

With the new name, evolution and development are now limited to a single section. I have no insight about the motivation. Probably Evo-Devo (the field) is too niche and low on submissions. Diversifying submissions will be great for the journal, but I doubt that the field will gain from this change.

All that to say that I have added the feed of Developmental Biology Advances to EvoDevo Papers.

PS: Development Genes and Evolution, another classic Evo-Devo journal, has been re-branded as well. It is now named Discover Developmental Biology.

Royal Society feed removal

In other news, The Royal Society Publishing has revamped their website and no longer generate RSS feeds for search terms. Nothing I can do for now but to remove The Royal Society Publishing journals from EvoDevo Papers.

I deposited the codebase that powers EvoDevo Papers on Zenodo. It is now citable:

Vellutini, B. C. (2026). EvoDevo Papers: a literature bot for evolutionary developmental biology. Zenodo. https://doi.org/10.5281/zenodo.18238617

Marina Cuenca, Agustin Corbat, and I (the instructors) gave lectures and practicals ranging from the basics of digital images to advanced workflows for visualizing, processing, and analyzing multiview lightsheet data.

I had a fantastic time. Even though I’ve been an instructor in the EMBO Light Sheet Microscopy courses, organizing this workshop from scratch and teaching lightsheet image processing in Latin America for Latin Americans was special on a different level. Especially now that I’ve just moved from Europe to start a new position in Brazil.

Materials

We have put great effort into preparing the workshop materials and making them available online. And we did so so that the participants could follow the tutorials during our practical sessions and so that anyone could access the materials afterward.

Each individual tutorial and sample dataset is now citable with a DOI from Zenodo and released under a Creative Commons license for ample reuse by the image analysis and lightsheet communities. It’s FAIR to say—they are truly Open Educational Resources.

If you are interested in image processing of lightsheet data or image analysis in general, please look at the tutorials!

Website

Cuenca, M. B., Corbat, A. A., & Vellutini, B. C. (2026). Materials for the Light-Sheet Image Analysis Workshop 2026. Zenodo. https://doi.org/10.5281/zenodo.18247226

Link: https://bruvellu.github.io/light-sheet-image-analysis-workshop-2026

Tutorials

Zenodo Community

Link: https://zenodo.org/communities/lsmunimayor

Principles

I’m calling them the DAFT principles (the reason will be obvious below). There are only three:

• Use DAFT-numbered directories
• Follow a self-contained data flow
• Add one README per subdirectory

These three principles provide an organized structure, a clear workflow, and basic documentation to help research papers be more transparent, understandable, and reproducible.

Structure

DAFT-numbered directories

DAFT stands for Data, Analyses, Figures, and Text. These are the names of the directories that form the backbone of the paper. But their name is prefixed by an incremental sequence of numbers. Here’s how a template of a DAFT paper would look like:

daft-paper/
├── 0-data        # raw datasets
├── 1-analyses    # scripts and outputs
├── 2-figures     # figure plates
├── 3-text        # manuscript text
└── README.md

I find the ordered directory structure incredibly helpful to orient myself when entering the paper’s directory. The folders are always in the same position and clearly direct me to where I need to go, whether it is organizing datasets, performing analyses, making figures, or writing text.

• 0-data/ is where I put the raw data and datasets associated with the paper. The goal is that every observation, analysis, and result is based solely on the files inside this directory—not from elsewhere!
• 1-analyses/ is where I gather analysis pipelines and their associated files. This includes scripts, output data, plots, logs, and other files that process the raw data into results.
• 2-figures/ is where I keep the source files that I use to assemble figure plates. Ideally, every panel will come from files inside the data and analyses directories only.
• 3-text/ is where I keep the source files for the manuscript itself. And, as you might already be guessing by now, the text should only be based on the contents of the data, analyses, and figures directories. See more about the self-contained workflow below.

To organize individual datasets, analyses, and figures, I use subdirectories. Here, I prefer to use a short, descriptive name without a prefix number:

daft-template/
├── 0-data
│   ├── ablation        # tissue timelapses
│   ├── confocal        # microscopy stacks
│   └── README.md
├── 1-analyses
│   ├── fold-depth      # depth measurements
│   ├── germband-speed  # speed analysis
│   └── README.md
├── 2-figures
│   ├── background      # introductory figure
│   ├── conclusion      # summary figure
│   ├── fold-dynamics   # main results figure
│   └── README.md
├── 3-text
│   ├── paper.bib       # file with references
│   ├── paper.md        # manuscript text file
│   └── README.md
└── README.md

Ordered directories ease the burden of finding what I need, even after many months without looking into the paper. They are useful for your future and collaborators over long-term projects, but also for colleagues who might want to check how a specific analysis pipeline was done after publication, which is important for reproducibility.

Workflow

Self-contained data flow

The sequential numbering of the directories also contributes to another essential aspect of DAFT: it makes the direction of the workflow explicit:

data → analyses → figures → text

The structure exposes the underlying logic of the paper’s organization. With that, we can trace back how a specific result was generated from the original data.

That’s already a big win for reproducibility. However, for this to truly work, every piece of data of the paper needs to be self-contained within the main directory.

• Every result in 3-text must be derived from the files in 2-figures, 1-analyses, or 0-data;
• Every panel in 2-figures must be derived from the files in 1-analyses and 0-data;
• Every result in 1-analysis must be derived from the files in 0-data.

In practice, that means having the discipline to incorporate data into the loop. Want to add an image from your Downloads folder to a figure in the paper? Add it first to a subdirectory of 0-data. Want to add that nice plot from the workstation into the paper? Make sure to copy the entire pipeline to the 1-analyses directory. And so on.

Documentation

One README per subdirectory

Logical structure, descriptive file names, self-contained flow… they all help. But to really understand what is going on, nothing beats documentation.

For this reason, the third DAFT principle is to add one README per folder. Every folder should have a README file. Create a README whenever you create a new folder and write on it at least one sentence describing what will be stored there. Something as simple as that:

# Dataset name

Description of dataset.

Adding some new datasets? Create a README to describe what kind of data it is. Beginning a new analysis? Create a README to explain what the goal and approach are.

Turn it into a habit: new folder, new README (with some text in it). A short README is better than no README. Even an empty README is better than no README because it nudges you into writing something.

Template

I created a repository with a DAFT paper template with some placeholder folders and files to exemplify the organization. It is so simple that I’m not sure how useful it will be. In any case, you can check it here:

github.com/bruvellu/daft-template
(or Zenodo doi: 10.5281/zenodo.20499287)

Examples

I’ve used the DAFT principles in my last two papers.

The DAFT prototype emerged when writing the brachiopod Wnt paper. At the time, I had no separate analyses folder yet (they were together with data), but the core concepts were there already. Here’s the repository:

github.com/bruvellu/terebratalia-wnts
(or Zenodo doi:10.5281/zenodo.8312022)

DAFT became mature during the cephalic furrow paper. This was, by far, my most complex and long-runing project, with all sorts of data and analyses over many years. The DAFT principles kept me sane until the end. Here’s the repository:

github.com/bruvellu/cephalic-furrow
(or Zenodo doi:10.5281/zenodo.7781947)

Conclusion

I’m curious to know if these principles resonate with others. As I wrote in the beginning, the DAFT principles aren’t novel; numbered directories and READMEs have been a standard in data science for a long time and there are already great similar templates out there (e.g., OSF Open Data Sharing). DAFT’s purpose is to highlight the simplest actions, which anyone, from any field, could adopt, that would most effectively raise, at least a tiny bit, the basal level of reproducibility in research papers.

Citation

Vellutini, B. C. (2026). DAFT: minimal principles for reproducible research papers. Zenodo. https://doi.org/10.5281/zenodo.20499893

After many years as a postdoc in the Tomancak Lab at the MPI-CBG in Dresden, Germany, I’m starting a new position as assistant professor in the Department of Genetics, Ecology, and Evolution of the Institute of Biological Sciences of the Federal University of Minas Gerais (UFMG).

More news about the lab, research, teaching, and outreach initiatives will come over the following months!

I’ve released a major update to EvoDevo Papers. The database now has all the papers posted since 2015 and a new search form for swiftly exploring the contents.

Full archive

In the previous update, I improved the website by creating separate pages for feeds, posts and individual papers to make the database contents accessible to anyone wanting to discover recent papers in the field of evo-devo. However, the archive was incomplete. None of the papers posted during the Twitter era (2015–2023) were present because the website only had the papers posted after the big refactoring. But, now, this is solved. I imported all the legacy tweets to the database. EvoDevo Papers now has about 1.8k papers.

Search

With this many papers, browsing and finding relevant posts becomes harder. To improve this I implemented a basic search functionality and, I have to say, I’m quite pleased with the results:

Searching is fast and unobtrusive and works great for a quick check using your favorite keywords. But note, however, that only the papers’ titles are indexed. This is a limitation from the original feeds which don’t add other information reliably, like the abstract or the authors; the only field guaranteed to be there is the title.

On the technical side, implementing a search like this was new to me. The website is based on Django but it’s rendered to static files using django-distill. Therefore, I couldn’t use a standard SearchVector, for example, as the website is made of static HTML files. After some searching and testing, I eventually settled on a JavaScript library called FlexSearch. It can index and perform the search entirely on the client-side, and it’s fast. And after a couple of iterations, I even got the autocomplete and the word highlighting to work. I hope these features improve the search experience for the evo-devo enthusiasts using the website.

Outlook

The full archive and search functionality mark a milestone for EvoDevo Papers. I consider the project more or less feature-complete. Maybe I’ll do improvements here and there, but I likely won’t implement major new features. Using RSS feeds as a source of content has its limitations, which I plan to overcome in another project (still in development). Now, for EvoDevo Papers, I will focus on adding more sources, like other journals and preprint repositories, and on improving the filters of search-based feeds to increase the representation of evo-devo papers collected by the app.

It’s adorable to see these newly metamorphosed echinoderms and their long and chubby tube feet learning how to walk.

This scene reminded me of my master’s, when I watched for the first time young sea biscuits take their own first, wobbly steps. And it’s incredible how, in no time, they would be crawling through sand grains like Spider-Man flies through buildings. You can watch them here.

It also reminded me of the video I recorded during my PhD of young ribbon worms learning how to hunt. Also worth watching.

Full disclosure: Alvaro was my supervisor during my master’s degree ;)

The other day I stumbled upon this passage in the Wikipedia page of Piseinotecus, a genus of beautiful nudibranch sea slugs:

The name Piseinotecus comes from the Portuguese sentence “pisei no Teco” (I stepped onto Teco). Teco was the name of a dog of the zoologists Ernst Marcus and Eveline Du Bois-Reymond Marcus. While they were looking for a name for the genus, their friend, the zoologist Diva Diniz Corrêa, was visiting them and stated the sentence while coming down the stairs to announce that she had accidentally stepped onto their dog.

From the Wikipedia page: https://en.wikipedia.org/wiki/Piseinotecus

What a delightful story! Ernst, Eveline, and Diva were brilliant zoologists and contributed immensely to our knowledge of marine invertebrates.

The source is a short paper of recollections written by Eveline:

Piseinotecus is an entire sentence in Portuguese. Our friend, Diva, stated it while coming down the stairs one day. She had stepped upon our dog, Teco, and while we were looking for a new generic name, had told us Pisei (in Portuguese) = I stepped; no = onto; Tecus = the dog’s name. In the meantime, this genus has turned out to be the type of a new family. Piseinotecidae appears in the literature today.

See it here: https://www.biodiversitylibrary.org/page/45940346#page/459/mode/1up

Marcus, E. d. B.-R. (1987). Selected Recollections from My Life. American Malacological Bulletin, 5, 183–184. https://www.biodiversitylibrary.org/part/143207

BHL Image Explorer: https://bhl-gallery.toolforge.org/

It enables us to explore the figure plates present in BHL’s catalog (also on Flickr and Wikimedia Commons), links with other databases, and keeps track of their use in Wikipedia pages. It’s a nice way to expose these images and encourage their use on Wikipedia.

The project was created by Tiago Lubiana who was BHL’s Wikimedian-in-Residence during last semester. He finished his term a couple of months ago are wrote some closing thoughts in BHL’s blog. I enjoyed the quote below.

Via Siobhan Leachman.

It was published back-to-back with another cephalic furrow study:

Research mutualism

This was a wonderful collaborative effort to understand the developmental role and evolutionary origins of this prominent but overlooked tissue fold of fly embryos.

We were two teams working on a similar question, doing similar experiments, and observing similar results. But instead of competing and eventually scooping each other, we decided to join forces. The overlapping experiments became an asset as they were performed independently by different people in different labs. And since we were tackling the problem from different angles and using different approaches, the two studies neatly complemented each other and strengthened the main conclusions.

From the start, we posted the preprints and submitted the manuscripts together, and I’m delighted that the papers got to be published together back-to-back, as we had originally envisioned it.

To top this emotion, our findings and overarching story were carefully summarized in a great overview piece written by Thibaut Brunet:

Some thank yous

I have more to say about this cephalic furrow endeavor, but for now I’d like to highlight the immediate people who made it possible.

Marina Cuenca who performed crucial experiments and analyses that were a turning point for the project into tissue mechanics; Abhijeet Krishna, who did an outstanding job coding the model and running the simulations; and Alicja Szałapak who greatly contributed to the model and visualizations early in the project. Carl Modes, who supervised the theory part and could always explain so clearly the math and modeling intricacies to this biologist here. And, finally, Pavel Tomancak who provided all the support and input along the course of this project and was a guiding light for the entire endeavor. It was a pleasure to work with such talented scientists and wonderful people.

Additionally, I’d like to thank Steffen Lemke and Yu-Chiun Wang and their teams, who agreed to embark with us on this mutualistic scientific collaboration; our reviewers Thibaut Brunet, Alfonso Martinez-Arias, and an anonymous reviewer for their constructive feedback that helped shape and consolidate our work; the editor Henry Gee for handling our manuscripts during the revision process; and the Max Planck Society for paying the article processing charges to make the article open access.

There are many more people to thank. I’m writing it up on a new post, which I’ll link below when ready.

Some related posts

• The Great Divide
• Mechanobiology EMBL Symposium 2022
• The MeMoDEvo QBIO Symposium 2022
• Cephalic furrow on bioRxiv
• Cephalic furrow thread
• Improving Z-resolution of lightsheet data using CARE upsampling
• Cephalic furrow preLights
• In the spotLights
• EuroEvoDevo Helsinki 2024

Tip by Marina Cuenca.

• evodevo.brunovellutini.com
• @evodevo_papers@biologists.social
• @evodevo-papers.bsky.social
• github.com/bruvellu/evodevo-papers

Why have a website?

For many years, EvoDevo Papers’ posts were only on Twitter. Everything was well—until it wasn’t. When I moved it to Mastodon, all the 1.6k posts remained behind. The account was reborn with zero posts and followers. Posting continued in the Fediverse. However, when the botsin.space instance closed down and EvoDevo Papers migrated to biologists.social, the newer posts were also lost. The contents in third-party social media platforms, even of the finest kind, like the Fediverse, are ephemeral.

Ephemeral is fine and fits the original motto of streaming the latest papers. But, over the past years, I began to recognize that having a curated collection of works from a field can have a lot of value and deserves a persistent archive. That’s why when I refactored the bot, I made a website for EvoDevo Papers. It is meant to serve as the main source of content, while the posts are syndicated to third-party social media sites (following IndieWeb’s POSSE practice).

Website updates

The original website was minimal. It had a single page showing the five latest posts, the feeds, and an about section. There was no way to explore older posts or check in more detail the indexed feeds.

With the update, I made the home page simpler but more informative. There are now separate pages for the about, feeds, and posts, where you can browse the contents, and each post got an individual page linking to the associated statuses on Mastodon and Bluesky.

The website also has an RSS feed now to follow EvoDevo Papers directly from your feed reader.

Bluesky posting

In the turmoil of the Twitter exodus, supporting Bluesky posting wasn’t my priority. I was focused on making EvoDevo Papers work for Mastodon, since I believe the non-corporate nature of the Fediverse is a better and more robust option for rebuilding online scientific communities.

However, Bluesky reached a critical mass of scientists, particularly within the DevBio and EvoDevo communities, that I would like to reach. So, I’ve activated the EvoDevo Papers account there, and let the paper posting begin.

Implementing Bluesky support wasn’t trivial. It required substantial refactoring of the database models and publishing pipeline. But it was for the better. The app is now more modular and supports the addition of other accounts.

Next steps

With the refactoring of the publishing pipeline, I have the logic more or less in place to enable the posting of papers from the archive, not only the latest publications. This allows us to publish a random older paper, for example, on days when there are no new papers. This would increase the potential interactions.

For the same reason, I’m also considering increasing the frequency of posting to two times a day (currently it’s only once per day). Although I’m not convinced yet. I like the low posting rate; it feels less overwhelming. Who needs more social media posts on their timelines anyway?

Finally, I’m also importing the entire history of posts back from 2015 to consolidate the database and celebrate the ten years of EvoDevo Papers online.

The Light-Sheet Image Analysis Workshop is a five-day intensive course that will take place in Santiago, Chile, from January 5–9, 2026, designed for students and researchers who wish to gain foundational skills in the processing and analysis of light-sheet microscopy imaging data.

The application deadline has been extended until August 8, 2025! The workshop is free to attend and travel fellowships are available. Learn more and apply here:

https://lightsheetchile.cl/light-sheet-image-analysis-workshop-2026-2/

Mutemi KN, Simakov O, Pan L, Santangeli L, Null RW, Handberg-Thorsager M, Vellutini BC, Peterson KJ, Fromm B, Larsson T, Savage E, Lopez MO, Hercog R, Provaznik J, Ordoñez-Rueda D, Azevedo N, Gazave E, Vervoort M, Tomancak P, Tan W, Winkler S, Benes V, Hui J, Helm C, Özpolat BD, and Arendt D (2025). A genome resource for the marine annelid Platynereis spp. doi:10.1186/s12864-025-11727-2

I only had a small role in contributing to the full-length transcriptome of Platynereis. Congrats to all the other authors and to Kevin and Duygu, who led the project and the paper!

As a solution, I wanted to convert these websites into static web pages. This would allow me to maintain them online using a much simpler setup without databases or configuration, just plain HTML files.

Luckily, the first tool that I tried worked well: the Simply Static WordPress plugin (free version). I generated and exported the static versions of my websites and was impressed. They maintain everything as expected—URL structure, theme and styles, posts and pages, uploads, etc.

I’m happy with how it turned out. The static versions look the same and are much lighter and portable. Here are the newly updated websites.

• ccNeLaS (ccnelas.brunovellutini.com): a music blog promoting Creative Commons licensed albums.
• Bolachas com água e sal (bolachas.brunovellutini.com): website showing photos and videos from my master thesis’ project on the life cycle of sea biscuits.
• PhD Notebook (phd.brunovellutini.com): the WP-based electronic laboratory notebook I used during my PhD.
• Desertores da Escada (desertores.brunovellutini.com): a blog run by a collective of biologists during the golden era of internet blogging.

Fabric is a Python library for running shell commands locally or remotely via SSH. I use it for interacting with the Cifonauta’s servers, like fetching the latest database from production or running the deployment routine after code updates.

Although Fabric works mostly fine, I’ve encountered a few command quirks over the years. I also often get confused when creating tasks because of all its lower level libraries (Invoke, Paramiko, Invocations, and Patchwork…). So, in the back of my mind, I’ve been roaming for a simpler alternative.

just seems to have a nice set of features and appears to be gaining some momentum lately.

Justfile‘s syntax is similar to that Makefile‘s. It was straightforward to create some recipes for the standard manage.py commands of Django, like runserver or shell. Here are a few of them:

# Cifonauta's justfile

# Set the default shell to bash
set shell := ["bash", "-cu"]

# List all available recipes
default:
	@just --list

# Run Django development server
runserver:
	@echo "Starting Django development server..."
	python manage.py runserver

# Run Django shell
shell:
	@echo "Starting Django shell..."
	python manage.py shell

# Run Django database shell
dbshell:
	@echo "Starting Django database shell..."
	python manage.py dbshell

# Run Django makemigrations
makemigrations:
	@echo "Making migrations..."
	python manage.py makemigrations

# Run Django migrate
migrate:
	@echo "Applying migrations..."
	python manage.py migrate

# Run Django collectstatic
collectstatic:
	@echo "Collecting static files..."
	python manage.py collectstatic --noinput

# Run Django test
test:
	@echo "Running tests..."
	python manage.py test

I run the manage.py commands every time I work on the Cifonauta code. They are simple enough, but running just runserver or just migrate is even simpler and feels semantically right. And the autocomplete is also snappier than the standard django_bash_completion. I liked it.

A note: just prints the command itself to the terminal by default. Adding the @ in front hides the command; only the output is shown when running the recipe.

The first issue I had was trying to activate Cifonauta’s Python virtual environment automatically for each of the recipes above. Based on intuition, I created a recipe to activate the environment and added it as a dependency to other recipes. However, this didn’t work out.

It turns out that each line in just runs a new shell instance. After digging a bit, the solutions I found were complicating the code too much, so for now, I’m sticking with activating the environment myself beforehand—it’s quick enough (a one-key alias).

After this initial setup, I started migrating some fabfile tasks of the Cifonauta workflow to justfile recipes. One very nice feature I discovered is that you can run a just recipe in any language using shebangs. Different from regular recipes, the variables will persist across lines like in a standard script.

Here’s a simple Bash recipe to dump the local database to a file for backup:

# Backup local database
backup-local-db:
    #!/usr/bin/env bash
    echo "Dumping local database to file... ({{dbname}})"
    set -euo pipefail
    mkdir -p {{local_bkp_dir}}
    FILEPATH="{{local_bkp_dir}}/$(hostname)_{{dbname}}_$(date +%Y-%m-%d_%H%M).sql.gz"
    pg_dump {{dbname}} | gzip -c9 > "$FILEPATH"
    echo "Backup created: $FILEPATH"

And this one is a bit more complex as it runs a couple of commands remotely via SSH to get the latest production database.

# Fetch latest database from production
get-production-db:
    #!/usr/bin/env bash
    echo "Fetching latest database from production..."
    set -euo pipefail
    mkdir -p {{local_bkp_dir}}
    LATEST_DBNAME=$(ssh {{user}}@{{prod_server}} "readlink -f {{prod_bkp_dir}}/latest.sql.gz")
    FILENAME=$(basename "$LATEST_DBNAME")
    scp {{user}}@{{prod_server}}:"$LATEST_DBNAME" {{local_bkp_dir}}/"$FILENAME"
    echo "File copied: {{local_bkp_dir}}/$FILENAME"

There was only one idea left that I wanted to test: can I run some code from the Django app within a recipe? I made a test recipe to count the number of taxa in our database using the --command parameter of manage.py shell and it works!

# Test recipe for counting taxa
count-taxa-test:
	@echo "Counting taxa..."
	@python manage.py shell --command "\
	from meta.models import Taxon;\
	taxa = Taxon.objects.all();\
	print(f'Total: {taxa.count()}')\
	"

While this type of query is probably better as a standard Django management in the long term, just recipes can be a handy shortcut to quickly draft and test commands before they graduate to the codebase.

To summarize, just feels promising. And it’ll most likely be easier to maintain than Fabric, since I can just create recipes in Bash or Python. But let’s see how it goes. I still need to migrate other, more complex tasks like the staging and production deployment routines, which will be some work.

The authors used time-lapse recordings of whole embryos made with lightsheet microscopy to create a comprehensive staging system for the embryogenesis of the species.

It was one of the first reviews that I signed (disclosed my identity) from the beginning—and it felt right. As much as I understand the advantages of anonymity against power abuse from influential people, signing a review brings accountability and connection among peers.

The authors opted to publish the peer review history along with the paper, so now everyone can read it.

References

Strobl, F., Schmitz, A., Schetelig, M. F. and Stelzer, E. H. K. (2024). A two-level staging system for the embryonic morphogenesis of the Mediterranean fruit fly (medfly) Ceratitis capitata. PLoS One 19, e0316391. https://doi.org/10.1371/journal.pone.0316391

Strobl, F., Schetelig, M. F. and Stelzer, E. H. K. (2022). In toto light sheet fluorescence microscopy live imaging datasets of Ceratitis capitata embryonic development. Sci. Data 9, 340. https://doi.org/10.1038/s41597-022-01443-x

Link: https://cifonauta.cebimar.usp.br

The site now has a responsive interface for mobile devices and a new administrative dashboard for users and curators of the database. Yes! We will gradually open up the database for users to upload and publish their images of marine organisms and habitats on Cifonauta.

With this, we hope to expand the content of the database to represent not only the rich biodiversity of marine organisms, but also the great diversity of people who contribute to marine biology in Brazil (and the world).

Special thanks to Virginia Castilho, who managed the project, and to the IN Junior team who developed many of the new features.

If you encounter any problems, please report them here or here.

The dataset is now available on Zenodo:

Vellutini, B. C., Handberg-Thorsager, M. & Tomancak, P. (2024). Platynereis dumerilii full-length transcriptome of developmental stages. doi:10.5281/zenodo.14250773

The transcriptome was used for the assembly and annotation of the Platynereis genome, currently available as a preprint on bioRxiv:

Mutemi, K. N. et al. (2024). A genome resource for the marine annelid Platynereis dumerilii. doi:10.1101/2024.06.21.600153.

To avoid any downtime, I recently migrated the account to a new server, the biologists.social community managed by The Company of Biologists. I think it’s a great match, and I’m glad they agreed to host. The new address is:

@evodevo_papers@biologists.social

The migration went well and posting has already resumed. I’ve also taken the chance to tweak the website and refactor the code base to pave the way for novel features that I’m planning to implement. Just released v2.2.0

“Science is merely a process of asking questions and searching answers, along with the combined knowledge accumulated from this search.”

I like how casual this definition is. Science is often portrayed as something only professional scientists can do, but that’s not entirely true. Science is hard work, but anyone can follow the basic process of asking questions and searching for answers while considering what’s already known. Building on collective knowledge is science’s best trick. Yet, there’s one important aspect missing from this definition: observation. Good questions arise from observation. That’s why descriptive work—despite being undervalued—is a crucial part of science. A single, careful observational study can enable and sustain hypothesis-driven research for decades.

In magnifying these concealed worlds, we aim to unveil the inherent beauty and undeniable truths that underscore our collective responsibility as stewards of Earth.

From Veritas Magnus Vis Microscopia‘s website

Watch a tour of the exhibition:

Some of my images are being looped-projected there!

Website: http://www.veritasvis.com/

“(…) aims to cultivate interest and curiosity in the life sciences through this portal of stunning images showcasing the largely invisible biological world.”

From their About page.

This is very much aligned with the motivation behind the Ocean: hidden life photo exhibition and the Cifonauta database itself—so I’m excited (no surprises).

The website is gorgeous. It has different view modes, like the Visual spectacle, an endless screen saver with clickable images, and the Scroll and Explore, a series of (outstanding) visual lectures on major concepts of biology.

You can also explore the collection through standard text categories or visually (!), through cell structures, body parts, or organism types.

Each image has an informative and well-crafted description, and even annotations highlighting specific features, so Beautiful Biology also stands out as an extraordinary educational resource.

I’m happy that three of my images are featured there:

• Moss Animal Muscles (the bryozoan larva above)
• Neon Shuttlecock (the skeleton of a pluteus larva)
• A Wave of Division (the famous mitotic wave)

Explore: https://www.hhmi.org/beautifulbiology/

It provides better-defined standards compared to the original Markdown, which make parsing easier while still keeping the sample principles of readability (see Beyond Markdown).

It is being developed by John MacFarlane, the creator of CommonMark (the main Markdown specification) and Pandoc (the universal file type converter).

Here’s a snippet from Djot’s website:

Djot is a light markup syntax. It derives most of its features from commonmark, but it fixes a few things that make commonmark’s syntax complex and difficult to parse efficiently.

Given that I use Markdown (and Pandoc) a lot for documenting code and writing papers, I’m surprised I hadn’t heard about Djot before.

I literally stumbled upon it online while reading this nice post about blogging, which I saw through the blogging hashtag on Mastodon.

But, yes. Now that I have heard about Djot, I love it already.

The mitotic waves made it onto the Sächsische Zeitung, a regional newspaper published in Dresden (thanks to Katrin Boes from MPI-CBG). They wrote a nice little piece about the video. I translated it to English (using DeepL…). You can read it below.

Scientist receives coveted film award

Dresden researcher turns little fruit flies into movie stars. With a serious background.

While Hollywood rolls out the red carpet for the stars, there is a film award that does without a golden statuette. The Japanese company Nikon regularly organizes the “Small World in Motion” video competition. “It’s a world in motion”. Scientists can win there with their films. This time, Brazilian researcher Bruno C. Vellutini from the Max Planck Institute of Molecular Cell Biology and Genetics (MPI-CBG) in Dresden took first place. He didn’t make a love drama or a movie about superheroes—his film shows the breathtaking choreography of cell division in a fruit fly embryo. Sounds unspectacular? Not at all. What happens in these 30 seconds has the potential to advance cancer research and expand our understanding of birth defects.

The main character in Vellutini’s film is a tiny embryo of the fruit fly Drosophila melanogaster. It is one of over 3,000 species in the tau fly family. The fly is one of the best-studied organisms in the world, and has therefore long been used by scientists as a model organism for their research. The fruit fly is barely visible to the naked eye. For the film, the slide under a microscope became a screen. This is where the drama of embryogenesis takes place.

The movie starts at second 0 with synchronized cell divisions and, from second 11, heads towards the turning point—gastrulation. Here, a simple cell layer becomes a complex structure, from which the entire living organism later forms. What can go wrong in this phase is of great interest to scientists, as similar processes also occur in the development of lung and liver cancer, as well as breast cancer.

Bruno C. Vellutini is a biologist and researcher in the field of evolutionary developmental biology. He studies how different embryos form their body parts to understand the evolution of animal diversity. Before joining the MPI- CBG, he completed his studies at the University of São Paulo and his doctorate at the University of Bergen in Norway. He has long been fascinated by the possibilities of photomicrography. He is fascinated by the potential of microscopes to see beyond the limits of our human eyes. “My passion was awakened by the ability of microscopes to capture and observe breathtaking microscopic phenomena in images or films, to make new discoveries and to share this fascinating world with others.” His video would be interesting for everyone because fruit fly embryos can also be found in every household. “This video shows that the fascinating dynamics of cells and tissues take place every day in the most ordinary living organisms around us.”

Microscopes have been indispensable tools of science for more than 400 years. Their history began in the 16th century with the first crude devices of the Dutch spectacle grinders, Hans and Zacliarias Janssen. But it was Antoni van Leeuwenhoek who refined the microscope and opened up the world of microbes to mankind—a world that remains invisible to the naked eye. In the 19th century In the 19th century, Carl Zeiss and Ernst Abbe revolutionized microscopy with their advances in optics.

Later, in the 20th century, the invention of the electron microscope made it possible to look even deeper into the structures of matter by using electron beams instead of light. Today, it is impossible to imagine modern science without microscopes. In biology and medicine, they make it possible to examine the fine details of cell structure and diagnose diseases at a cellular level. In materials science and nanotechnology, they provide insights into the nature and properties of materials.

There were 370 entries from 40 countries in this year’s competition. In the end, Vellutini’s film won over the jury. It proves that even the most inconspicuous creatures can play the leading role in a fascinating story of life. (jam)

In a recent email exchange, someone asked me what the colors in the video of mitotic waves mean and how did I get them.

How the microscope technique results in the array of colors in the cells (purple to yellow and red). Could you briefly explain where the colors come from and how you visualised them?

It’s a great question. The topic is fascinating, and I had a lot to say about it. Since my answer might be helpful to more people with similar questions, I turned it into a blog post.

Answer

The basic approach to obtaining these images is to shine lasers at the sample and capture the resulting glow (or fluorescence imaging). The laser excites the molecules, and some will emit light in response. If we do that with a regular fly embryo, we will not see much because it doesn’t naturally have any fluorescent molecules. So, if we want to study processes in the embryo, we need to create a transgenic fly that expresses fluorescent proteins.

This specific fly from the movie expresses two different fluorescent proteins. One is a green fluorescent protein (GFP) linked to a regular protein that is always together with DNA inside nuclei (histone). The other is a red fluorescent protein (mCherry) linked to another protein that is always bound to cell membranes (Gap43).

After we put the embryo on the microscope, we shine two different lasers at the sample, and the proteins will emit fluorescence in green (~510 nm) and red (~610 nm) of the light spectrum. Using filters in the microscope, we can capture the signal from each protein on two separate images (channels). Despite the original fluorescence being green and red, the data that the microscope records is grayscale. So at the end I have two separate images, one showing the signal from the proteins in the nuclei (Histone-GFP) and another showing the signal from the proteins in the membranes (Gap43-mCherry)—both in grayscale!

What we do, then, is to choose a color for each channel. This can be any color, red/green, purple/orange, yellow/blue, etc., and does not need to match the original fluorescence color. It basically depends on what the researcher wants to highlight in the image. Some color combinations work better than others, depending on the type of signal (tiny dots or large structures), and in the observer. For example, we humans are not good at seeing details in blue but see better in green.

For the membrane signal in the video, I selected a grayscale gradient (from black to white) because it is great and uniform for our eyes. If it is a single-color image, using grays is the standard. In this case, I wanted the membranes to be present but more in the background. They appear more prominently at the beginning of the video and then fade into the background at the end when the main signal is purple.

For the nuclei signal, the main subject of the video (where most action happens), I wanted something more colorful and chose a gradient named “mpl-inferno”. It is a colormap that goes from black-purple-magenta-red-orange-yellow (see it here), and it is great to highlight small differences in signal intensities. It also comes with several technical advantages, like being color-blind safe.

In the video, this colormap creates a captivating effect. As you noticed, the nuclei at the center of the image are bright yellow, and the color fades to orange and purple towards the edges of the embryo. This happens because the embryo is like a cylinder. Since its central portion is closer to the lens of the microscope, the camera can capture a brighter signal. In contrast, the nuclei at the edges of the embryo are further away from the lens, making the signal dimmer and more purple with this colormap.

My post, mitotic waves and gastrulation, has a few more details about the creation of the video if you want to take a look. I hope this is helpful. Please tell me if something wasn’t clear or if you have other questions.

Vellutini, B. C., Martín-Durán, J. M., Børve, A. & Hejnol, A. Combinatorial Wnt signaling landscape during brachiopod anteroposterior patterning. BMC Biol. 22, 1–23 (2024). https://doi.org/10.1186/s12915-024-01988-w

To learn more about the video, check out Nikon’s press release and their article for the series Masters of Microscopy.

There’s also a blog post that I wrote a couple of years ago with some biological information and technical details about how I created the video.

If you are wondering about the size of the embryo and how fast it really develops, there’s a version with a scale bar and time label on YouTube and available for download and re-use on Wikimedia Commons.

Thanks for your support :)

The venue and organization were impeccable, and I thoroughly enjoyed the program overall. My feeling is that there was a greater diversity of topics compared to earlier editions. More ecology, more (actual) evolution, more theory. Or, maybe, it was just me attending more diverse subjects. Not sure. But there were many new participants attending EuroEvoDevo for the first time, which probably contributed to this feeling. And, of course, it was wonderful to see friends and colleagues again. I liked it very much.

I gave a talk in the “Evolution of Morphogenesis” symposium. It was about how mechanical forces can influence the evolution of developmental processes. I showed some of the latest updates of our cephalic furrow paper, which now has more comparative gene expression data from different fly species.

The first spotLights episode is out, and it features… me

The conversation was about the cephalic furrow preprint, which was also reviewed by preLighters earlier this year.

Participating in a podcast was something new for me!

It was a pleasure to be a part of such a fresh initiative. Big thanks to Reinier Prosée, Matthew Davies, and Ethan Ewe for the invitation and for hosting me.

You can hear the interview below. But, before that, I recommend reading the preLights post and the thread about the paper for context.

To add data from a ManyToManyField to a SearchVectorField, you can join the related values in a string and pass this string as a Value() expression to the SearchVector object:

class MainModel(models.Model):
    (...)
    title = models.CharField(blank=True)
    tags = models.ManyToManyField('TagModel', blank=True)
    search_vector = SearchVectorField(null=True)

    def update_search_vector(self):
        tag_values = ' '.join(self.related.values_list('field', flat=True)

        self.search_vector = (
            SearchVector('title', weight='A', config='english') +
            SearchVector(Value(tag_values), weight='B', config='english'))
        )

class TagModel(models.Model):
    (...)

Cifonauta’s full-text search

During the past year, we’ve been working on several updates for modernizing the Cifonauta database. The website now has a fully responsive design and a new dashboard for contributed user uploads. The new version will be live probably later this year.

As part of this effort, I needed to update our full-text backend. Cifonauta is a thirteen year-old Django/PostgreSQL-based application. In ancient times, the search was powered by ElasticSearch. It worked fine, but brought a heavy maintenance burden (for me). As Django’s full-text search capabilities became more established, I migrated to a built-in search setup using the great SearchVector.

Dynamic SearchVector

Initially, I was populating the search vector dynamically in a view, adding data from the plain CharField and TextField of our model, as well as data from different ManyToManyField and ForeignKey related models. For the latter to work, I had to use the StringAgg function to concatenate the “name” field from the related models:

def search_view(request):
    (...)

    query = request.GET.get('query', '').strip()
        if query:
            vector = SearchVector('title', weight='A') + \
                     SearchVector('caption', weight='A') + \
                     SearchVector(StringAgg('person__name', delimiter=' '), weight='A') + \
                     SearchVector(StringAgg('tag__name', delimiter=' '), weight='B') + \
                     SearchVector(StringAgg('sublocation__name', delimiter=' '), weight='B') + \
                     SearchVector(StringAgg('city__name', delimiter=' '), weight='B') + \
                     SearchVector(StringAgg('state__name', delimiter=' '), weight='B') + \
                     SearchVector(StringAgg('country__name', delimiter=' '), weight='B')

    media_list = media_list.annotate(search=vector).filter(search=query)

    (...)

Although this worked, searching was painfully slow.

Static SearchVectorField

To improve search performance, I created a SearchVectorField in our model to store all the indexable information. This search vector field is updated every time the object is saved, via a post_save signal that calls the model’s update_search_vector() method. It is also indexed with GinIndex in the model’s Meta to speed up the searches:

class Meta:
    indexes = (GinIndex(fields=['search_vector']),)

ManyToManyField problem

However, I ran into a problem. While it worked fine for CharField, the StringAgg approach for ManyToManyField does not work and throws this exception:

django.core.exceptions.FieldError: Aggregate functions are not allowed in this query

And other exceptions when I tried something else (and I tried many things), like:

django.core.exceptions.FieldError: Joined field references are not permitted in this query

Value() solution

After some struggling, the solution was simpler and more obvious than I thought. You just need to fetch and pass the values as a single string wrapped in the Value() expression, like this:

def update_search_vector(self):

    authors = ' '.join(self.authors.values_list('name', flat=True))
    taxa = ' '.join(self.taxa.values_list('name', flat=True))

    self.search_vector = (
        SearchVector(Value(authors), weight='B', config='english') +
        SearchVector(Value(taxa), weight='B', config='english') +
    )

Good performance–maintenance ratio

Now everything works as expected. I can search for “bruno larva” and get relevant results, relatively fast.

I recently finished the revision of our paper about the Wnt signaling landscape in brachiopod development. This is work from my PhD time in the Hejnol Lab in Norway. We posted it on bioRxiv last September, and sent to a journal later that year.

Following the reviewers’ feedback, we added new data, made significant improvements to the results and discussion. These include:

• New in situ hybridization data for late blastula stages.
• Germ layer information for expression domains.
• Better spatial and temporal description with several additional figures.
• Refocused discussion on a comparative angle, toning down functional speculations.

The new version is already on bioRxiv (same address):

Vellutini BC, Martín-Durán JM, Børve A, and Hejnol A (2023). Combinatorial Wnt signaling landscape during brachiopod anteroposterior patterning. https://doi.org/10.1101/2023.09.03.556047

But, it also has its boring parts.

Today, for example, I spent four hours pipetting, non-stop. 280 tubes. No robots, no multichannel pipette. Just manual labor.

The pipetting marathon is for an experiment, which I’m very much looking forward to seeing the results. And, just thinking about that now, the thrill of observing something new, already made today’s boring parts worthwhile.

In December 2022, I set up a pipeline using the feed2toot library to consume RSS feeds from academic journals and post the articles on Mastodon. Although I wasn’t very satisfied with it, it worked fine for about a year. However, after my server’s Python version was updated, feed2toot stopped working which caused EvoDevo Papers to break. There was no simple workaround and no solution for the issue.

Because of this, I took the opportunity to completely restructure the pipeline and lay the foundation for the future of EvoDevo Papers.

You can check out the results in the links below or continue reading to learn more details about the pipeline.

• evodevo.brunovellutini.com
• @evodevo_papers@biologists.social
• github.com/bruvellu/evodevo-papers

Django-based application for EvoDevo Papers

To develop the application, I opted for a framework I’m familiar with—Django. Since I used it to develop the Cifonauta database, it feels natural to use it again.

My goal was to create a minimal working EvoDevo Papers app that can post the most recent papers from relevant journals. Here’s the workflow I followed:

1. Retrieve the journal’s RSS feed.
2. Collect new articles from the feed.
3. Generate the text for each post.
4. Publish the posts to Mastodon.

Consuming feeds with django-feed-reader

I was confident that there was a Django package available for reading, and I was right. The first I came across was django-feed-reader. And it’s funny how sometimes I can immediately tell if a library or package will be a good fit for me. In the case of feed2toot, I knew it wasn’t. There’s something about the organization of the code, how options are handled, and other small details that didn’t fit well with me. However, with django-feed-reader, it was a great match!

The package provides all the basic functionality I need for reading feeds, as well as some useful additional features. It’s straightforward to add new feeds, check for feed updates, and import new entries. It also keeps track of the update frequency based on the activity of the feed. Additionally, there’s a management command available to refresh the feeds, which is incredibly helpful for my specific use case, as I’ll explain below.

Creating posts using a custom package

With the Sources (journals’ feeds) and Articles (feeds’ entries) being handled by django-feed-reader, I only needed to use this information to create a Mastodon post.

What I find useful is simply the article’s title and the article’s link with a couple of hashtags:

Developmental and genomic insight into the origin of the tardigrade body plan https://doi.org/10.1111/ede.12457 #EvoDevo #Papers

Example from here.

To process this information, I wrote a custom Papers app that takes the details from new articles and creates the Mastodon posts. This is also conveniently controlled by a custom Django management command for automation named createstatuses.py.

Posting to Mastodon using Mastodon.py

To handle the communication with Mastodon, I used what seems to be the only feature-full Python library for the Mastodon API, Mastodon.py.

I created a simple Clients app with a model for storing the client credentials and access tokens for the current Mastodon account of EvoDevo Papers. This will allow me to add and manage new clients for other social networks in the future if needed.

With all of these set, EvoDevo Papers needs to initiate the conversation with Mastodon’s API to publish the post. There’s a management command named publishstatus.py that takes the oldest unpublished article in the database and publishes it to the @evodevo_papers@botsin.space account.

The cool thing is that after publishing a post, I get and store Mastodon’s JSON response with the boosts, likes, and replies. This allows for using this information on the website and maybe even making the bot interact with the Fediverse.

Building a static website with django-distill

Yes, another thing I wanted is for EvoDevo Papers to have its website. But due to a limitation with my server, I can’t host a fully fledged Django app on it. I can, however, run Django on the backend.

Therefore, I decided to try running the Django application not only for updating the feeds and creating/publishing posts but also to generate a static website with these contents, which I could serve as simple HTML pages.

I searched for Django packages for building static websites… and found one, django-distill. It looked practical, and it was. Setting up and compiling simply worked. Great!

Designing the frontend with Simple.css

I’m a fan of minimal CSS frameworks, such as Skeleton. But I researched a bit more to see what else was out there. I was looking for something simple following HTML standards that would work out of the box. I found Simple.css.

For the home page, I put a list of the latest articles and of the feed sources. Some descriptions. Not much else. It looks fine for now!

Defining posting frequency with cron jobs

With all the components set, the app needs to run periodically to:

1. Check feeds for updates
2. Generate and publish posts
3. Build static website

For that, I set a cron job that runs all the management commands once a day. As there aren’t many EvoDevo articles being published every day, the posts will spread across multiple days. It’s also good practice to not post 20 articles at once, something I had no control over when I was using feed2toot. But I’ll fine-tune this as it goes.

Exploring ideas for the future

This short burst of full-stack development got me thinking about other cool things I could do with this type of scholarly data.

The bot could, for example, extract keywords from the articles and use them as hashtags. Discover and post related articles sporadically. Interact with people that like or boost it on Mastodon.

Going a bit further, I could fetch articles directly from OpenAlex or CrossRef. In this way, I could get even more data and metadata and extract the current hot topics, authors, or organisms, similar to what I already did with Living Bibliography.

This would be super informative to reveal the broader landscape of the EvoDevo field of research.

For the past years, I used a subprocess.call() to run a FFmpeg command to scale down and convert video files for the Cifonauta website (which is Django-powered). The ffmpeg command has some niceties like adding a watermark and including some metadata in the output file. The code looks like this:

# Import subprocess module
import subprocess

# Build FFmpeg command
ffmpeg_call = [
    'ffmpeg', # Executable
    '-y', # Overwrite output files
    '-hide_banner', # Don't print software information
    '-loglevel', 'error', # Show errors
    '-threads', '0', # Use optimal thread number
    '-i', input_path, # Path to input video file
    '-i', watermark, # Path to input watermark
    '-metadata', f'title={metadata.title}', # Add title to video metadata
    '-metadata', f'artist={metadata.author}', Add author to video metadata
    '-b:v', '600k', # Set bitrate for small file size
    '-filter_complex', 'scale=512:-2,overlay=0:main_h-overlay_h-0', # Scale input and overlay watermark at bottom left corner
    output_path
]

# Run FFmpeg command
subprocess.call(ffmpeg_call)

Note: This is a relatively old command. It might not be up-to-date with the latest FFmpeg versions.

Despite its complex syntax, I love FFmpeg and use it all the time, from creating GIFs to scientific videos. However, a native video processing library in Python would simplify the Cifonauta project’s dependencies and facilitate contributions. After all, adding a line to pip requirements.txt and having pythonic methods to manipulate videos is easier than figuring out and editing FFmpeg complex filters, at least for new contributors.

For images, I accomplished this by replacing the subprocess calls to ImageMagick (another open-source project I love) with Pillow. Although I’m not a fan of Pillow’s methods—why Image.convert() creates a copy and Image.thumbnail() modifies the image in place?—it’s very convenient to have a native Python solution for manipulating images.

Here are some of the libraries I looked into:

• ffmpeg-python: Seemed like the obvious choice, with many features and nice syntax. But unmaintained since ~2019.
• python-ffmpeg: Similar library (confusing name) but newer and actively maintained. Promising but with fewer methods and a smaller community.
• vidgear: Actively maintained, large community, and packed with features. Too many for the Cifonauta’s use case. And it’s still a wrapper for FFmpeg.
• moviepy: Still maintained, but seems more focused on video editing and manipulation than video processing (scaling/converting formats).
• opencv-python: Looks super-advanced, perhaps too much for what we need.
• PyAV: Another wrapper around FFmpeg, but the bindings look great to get and access video information. And the project is still maintained. I only couldn’t find a way to perform the scaling/conversion routines.
• scikit-video: Also looks good and might be a good fit, since there are methods to extract metadata, generate thumbnails, and convert videos. But the latest release is from 2018, although there are some recent commits in the repository.

Unfortunately, most (if not all) libraries are wrappers for FFmpeg. That means I would still need to have ffmpeg binaries installed. In this case, I don’t think it’s worth it to add yet another dependency with custom methods to the project. Moreover, in terms of functionality, none of the libraries were a perfect match for the Cifonauta pipeline. And there’s always the risk of the library you chose to be no longer maintained—it happens often!

So I think it’ll be safer and more practical to continue with my custom subprocess calls to FFmpeg for now.

Did I miss any obvious library? Please let me know!

As an alternative to regular comments, I added a reply by email option to every post on this website. Now, you can start a conversation with a click. Just hit the “Reply by Email” link below and your email app will open a draft with the post’s title in the subject.

Looking forward to hearing from you!

On the technical side, it was straightforward to implement. My blog runs WordPress (since 2007) and a Twenty Twenty child theme with a few modifications. For the “Reply by Email” option, I added the HTML below to the comments.php file, using _e() for the text translation and the_title_attribute() to fill in the title of the post.

<div id="email-reply">
    <h2 id="email-reply-title" class="comment-reply-title"><?php _e( 'Reply by', 'twentytwenty' ); ?> <a href="mailto:bruvellu@brunovellutini.com?subject=[Bruno C. Vellutini] <?php echo the_title_attribute(); ?>">Email</a></h2>
</div>

The videos are based on Ota’s book Goldfish Development and Evolution and are super informative for evo-devo and goldfish enthusiasts (like me). They touch upon the history of goldfish domestication and establishment of ornamental strains, their phylogenetic relationships and genomic traits, and the potential of goldfish as an experimental model to uncover the basis of morphological evolution.

Episode 01: History

Episode 02: Taxonomy, Phylogeny, and Genome

Episode 03: Goldfish as an Experimental Animal

I was delighted to hear that they were going to highlight our cephalic furrow preprint (Vellutini et al.) combined with the cephalic furrow preprint of Lemke and Wang labs (Dey, Kaul, Kale et al.). Which is great since we submitted the papers back-to-back.

Led by Reinier Prosee, the preLighters Amanda Ivanoff, Jennifer Ann Black, Benjamin Dominik Maier, and Chee Kiang Ewe, reviewed the papers in journal club style, wrote comments, and asked follow-up questions about our works. We, the authors, had the chance to read them and write a response.

They raised excellent points! It’s great to get feedback and have a space to extend the discussion like that. Thanks, everyone!

You can read the entire review and responses at:

https://prelights.biologists.com/highlights/patterned-embryonic-invagination-evolved-in-response-to-mechanical-instability-divergent-evolutionary-strategies-preempt-tissue-collision-in-fly-gastrulation-final/

I never imagined that one day I’d be looking at the embryology of fleas… But here I am.

I am curious about some details of your “Pre-patterned epithelial invagination prevents mechanical instability during fly gastrulation” paper. You mention that you trained a model to increase the z resolution of your microscopy data using the care framework. Would you mind sharing the model, or do you have some code on how you trained the model that you are willing to share? Additionally, I am trying to wrap my head around your mounting method in the Z1 Lightsheet, but I am having a hard time imagining it. Would you mind shooting a small video or simply one or two images the next time you or someone else mounts some fly embryos on the lightsheet?

Edited for clarity and to remove personal information.

I wrote a fairly detailed reply but had forgotten about it. Because the information might be useful for other people, I converted my reply into a blog post. Read it below.

CARE workflow

The code for training the CARE model is available in the paper’s GitHub repository and in the Zenodo archive.

Take a look at the Python notebook file named CoverCARE.ipynb. It’s a notebook modified from the original upsampling3D example provided by the developers of CARE. I used it to test the best training parameters. However, to train a proper model, which can take several days to finish, I made scripts for running the training in a cluster.

Essentially, there’s a config.py file with information about the dataset and parameters for the UpsamplingCARE model; there’s a train.py which is the code that does the training; and there’s a predict.py which is the code that restores your other datasets using the trained model. The files train.sh and predict.sh are just bash scripts that create the jobs for running the python code in the cluster.

Re-usability of CARE models

The models I trained for the paper will be in the Zenodo repository for the next release. I can send them to you but, unless you’ve got the same imaging setup, they’re not going to work well.

The model is specific for the data it got trained on (fluorescent signal, optics, lasers, medium, stage, etc.). If it’s only denoising, there’s a chance that other people’s models could work as long as the type of signal and the microscopy setup are the same. But I wouldn’t trust it.

Furthermore, the CARE upsampling parameters used to train the model are specific for the dataset and for the acquisition parameters, making it even more unlikely to work well—or at all. Therefore, I highly recommend training your own model.

Acquiring training data

The trick with CARE is that you need to acquire the training dataset properly. You need identical images with high and low signal-to-noise ratio. If you have 3D data, that means acquiring both conditions slice by slice. And when you do it, you’ll probably need to customize the microscope parameters to optimize this acquisition. Requires some work.

But most importantly, the acquisition parameters of your training data need to match the acquisition parameters of your experiments. After all, they’re the data that you want to restore. That means you must optimize your experimental conditions before acquiring the training data for the CARE model.

The good news is that, if done right, the results are excellent.

Of course, one needs to be sure that the model is not making structures up. But using CARE upsampling on a membrane marker for improving segmentation, for example, works great. I’m also not aware of other denoising methods that do upsampling.

High-throughput mounting

As for the mounting, I’ll include a supplementary figure to describe it better. The approach is sticking several embryos on a coverslip or glass capillary in a single row. It’s based on this protocol. Here’s how it looks in my hands:

I hope this helps! Happy to answer other questions if you have.

I wanted to share the wonderful things I saw under the microscope—cells dividing, tissues folding, embryos spinning, larvae metamorphosing, juveniles crawling between sand grains.

But I also wanted to convey the thrill I felt, seeing these creatures so strange and beautiful for the first time in that marine station’s microscopy room.

More than a year before the actual paper was published, I released “A Sea Biscuit’s Life”. The video went “viral”.

As a young scientist, this was a turning point because it taught me a way to reach people and, most importantly, that people are reachable.

Now, it’s been fifteen years since this epiphany. Watching it again after all this time, and it still tickles.

If you haven’t watched it, put some headphones on:

1. Opening

Our paper on cephalic furrow mechanics got updated with an exciting evo-devo twist :)

From the labs of Pavel Tomancak and Carl Modes:

What can a fold tell us about the interplay between genetic patterning, tissue mechanics, and the evolution of morphogenesis?

https://www.biorxiv.org/content/10.1101/2023.03.30.534554v2

2. What’s the role?

The cephalic furrow is a puzzling fold.

While its formation is under strict genetic control, the invagination is transient and doesn’t give rise to specific tissues. It simply unfolds, leaving no trace.

It has no obvious function. Or does it?

3. Instability in mutants

To investigate, we analyzed the tissue dynamics in cephalic furrow mutants.

We found that without the invagination, the head-trunk epithelium becomes unstable and buckles, forming what we call ectopic folds (see bottom embryo).

What’s causing this instability?

4. Sources of stress

We identified two potential sources of mechanical stress…

Mitotic domains (groups of dividing cells in the head) and germ band extension (tissue movement towards the head).

…and analyzed their contribution using biophysical modeling and experimental perturbations.

5. Biophysical model

The model developed by Abhijeet Krishna and Alicja Szałapak from the Carl Modes lab allowed us to simulate epithelial dynamics in different conditions, and make predictions for what’s happening in vivo.

For example, would ectopic folds appear if there was no germ band extension?

6. Germ band cauterization

To test this, Marina Cuenca mechanically blocked the germ band extension by laser cauterization in cephalic furrow mutants. No ectopic folds appear.

This indicates that mitotic domains alone cannot induce buckling, only when combined with the germ band push.

7. One double mutant

Similarly, inhibiting mitotic domains in cephalic furrow mutants (double mutant btd–stg) also abolishes ectopic folds.

This indicates that germ band extension alone cannot induce buckling, only when combined with mitotic domains.

8. Head–trunk under stress

These data suggests that, without the cephalic furrow, the simultaneous formation of mitotic domains and germ band extension generates mechanical instability.

Could the cephalic furrow be counteracting these increased compressive stresses during gastrulation?

9. Early fold prevents buckling

Our simulations point in this direction, showing that an early head invagination can effectively absorb these stresses and prevent epithelial instabilities at the head-trunk boundary.

10. A mechanical role

Putting all the data together, we propose the cephalic furrow has a function, it plays a mechanical role during Drosophila gastrulation.

This raised an intriguing evolutionary question for us: Could the cephalic furrow have evolved in response to these mechanical stresses?

11. Evolutionary novelty

We were lucky that Steffen Lemke and Yu-Chiun Wang had been working on the cephalic furrow from an evolutionary perspective because they reveal a crucial insight:

The cephalic furrow is an evolutionary novelty limited to a derived group of dipteran flies.

https://www.biorxiv.org/content/10.1101/2023.10.09.561568v1

12. Instability impacts development

They also provide evidence that other flies experience increased head-trunk stresses, and that this instability may impact developmental robustness, supporting the idea that the cephalic furrow evolved in response to mechanical conflict. Their thread:

13. Patterning evolution

Now, we wondered.

The cephalic furrow is a patterned fold. The initiator cells driving the invagination are specified genetically by the narrow overlap between btd and eve domains.

So, which genetic changes are associated with the evolution of this novel invagination?

14. Novel head-trunk domain of btd

We compared gene expression between Drosophila and Clogmia, a fly that has no cephalic furrow.

Clogmia lacks btd expression at the head-trunk, a domain crucial for cephalic furrow formation, suggesting the appearance of this domain was a key event in cephalic furrow evolution.

15. Evolutionary scenario

Altogether, the integrative scenario we are establishing is that mechanical instability acted as a selective pressure for the evolution of the cephalic furrow, and that this occurred through the cooption of a new molecular player at the head-trunk boundary.

16. Mechanoevolution

To us, the cephalic furrow case illustrates an example of a possibly more widespread mechanism on how mechanical forces can influence the evolution of patterned morphogenetic innovations in early development.

17. Thank yous

I’d like to thank Pavel Tomancak, Marina Cuenca, Abhijeet Krishna, Alicja Szałapak, Carl Modes for their crucial contributions, the MPI-CBG facilities for support, and the Steffen Lemke and Yu-Chiun Wang teams for this unique collective effort on such ephemeral but remarkable invagination ;)

18. Data availability

For more the details: https://www.biorxiv.org/content/10.1101/2023.03.30.534554v2

For high-res figures/videos: https://zenodo.org/record/7781916

For main data/analyses: https://zenodo.org/record/7781947

For model/simulations: https://zenodo.org/record/7784906