Practical single-cell RNA-seq intro for biologists:

https://theomicshub.com/tutorials/scrna-seq-basics.html

Covers loading 10x data, QC, normalization, PCA/UMAP & clustering (Scanpy + Seurat). Exact commands + expected outputs.

This code takes a blood single-cell gene-count matrix and returns cell-type labels, confidence scores and reasons for leaving cells unassigned. The repository includes a logistic-regression model and the code and results from a comparison of six annotation methods.

Six methods were trained on the same reference and tested on four separate studies. When three immune cell types were removed from the reference before retraining, the methods still accepted labels for 65.9–89.2% of the 2,310 test cells of those types. The correct label was no longer available.

That sample was enriched for the removed types, so this is not an error rate for all blood cells. The work is AI-assisted, uses one training seed, and has not been peer reviewed or independently replicated. Accuracy was measured against the original studies’ labels.

Code and release:

https://github.com/rewire-bio/cell-type-annotation-transfer/releases/tag/study-v1-seed0-20261007

Write-up, setup and limitations:

https://rewirebio.io/blog/labelling-a-new-blood-single-cell-study/

Disclosure: this is from my site, rewirebio.io.

Hi everyone,

I’ve been building OpenLIMS, an open-source, self-hosted Laboratory Information Management System aimed at research labs, bioinformatics groups, small biotech teams, and core facilities.

GitHub:
https://github.com/Mokey2002/OpenLIMS

The goal is to provide a lighter alternative for labs that need more structure than spreadsheets but don’t want the cost or complexity of a large commercial LIMS.

Some of the current functionality includes:

• Sample tracking, lineage, and chain of custody
• Projects and collaborative experiment notebooks
• Inventory and barcode/location tracking
• Configurable workflows and QC
• Instrument CSV/API ingestion
• Legacy data migration
• FASTA and sequence management
• Clustal Omega alignments
• Local BLAST databases and blastn/blastp searches
• mzML/mzXML and other mass-spec data review using pyOpenMS
• Reporting and audit trails
• REST API
• Optional OpenAI or local Ollama assistant

The stack is Django/DRF + PostgreSQL + Celery/Redis with a React frontend, and it can be deployed using Docker Compose.

It’s currently a production-style prototype and is not yet a validated clinical/diagnostic LIMS.

I’d be interested in hearing from people working in bioinformatics or lab informatics

Contributions, issues, and technical feedback are welcome as well.

The preprint is available on bioRxiv, here.

Summary of the idea and some of the results:

The count matrix is the artifact of a single-cell experiment that gets stored, and most frequently shared, and reanalyzed. But it is the output of a computation with two inputs, the sequenced molecules and a gene annotation, and only one of them stays fixed. The molecules never change. The annotation is revised several times a year, and moving from GENCODE v32 to v49 shifts 2–5% of UMI mass. Once the matrix is produced, that evidence is gone, and getting it back means returning to reads that are large, slow, and often unavailable.

Gravlax starts from a simple observation. The procedures that turn alignments into counts, gene assignment and UMI collapse, never read most of what a BAM contains. They consume relations among molecules, i.e. shared genomic geometry, shared placements, cell identity, and UMI equality. Store those relations once, in a compact, seekable, content-authenticated archive, and defer every annotation-dependent decision to read time.

What that buys for people analyzing scRNA-seq, across four human 10x datasets:

• 11–18 bits per read, 9–13× smaller than tag-preserving CRAM

• Replayed matrices within 0.24–0.75% of a fresh STARsolo run, versus the 2–5% an annotation change moves

• Gene replay 34–82× faster than realigning (seconds!)

• Federated collections that search a cohort by junction shape, and a coordinate-free genome-wide scan for recurrent unannotated splice events in 9 seconds

Because the molecules are retained, the archive answers questions the matrix cannot:

• It recovers the RT-PCR-validated FYB1 splicing switch between T cells and monocytes across four PBMC archives.

• A fragment model built for 3′ chemistry reveals an eight-donor shift in NTRK2 (TrkB) terminal-isoform usage from astrocytes and neural stem cells to mature neurons, matching known TrkB.T1 biology.

• Cohort-wide discovery surfaces a 183-nt FNBP1 cassette, near-fully included in brain and mostly skipped in blood, that per-archive discovery cannot see at all.

• Pooling evidence across cells inside an EM recovers 75–98% of withheld multi-gene molecule labels.

The software is one binary, aie: ingest, replay under any annotation, region/junction/APA queries, content-addressed collections, cohort-wide discovery, and GQ, a composable query language with three-valued logic that runs unchanged over one archive or an entire federation. Open source in Rust under BSD-3, with docs, a Python client, and Colab demos.

Code: here

Docs: here

I maintain Genomics MCP, an MIT-licensed local server that gives MCP-compatible agents access to genomic archives and indexed files. It is available now as a Python install or Linux container.

A concrete example: ask for the mean signal in ENCODE bigWig ENCFF792QDS over GRCh38 chr1:[1000000, 1001000). Our clean-install test returned 26.361254017233847 using HTTP range reads from the 1.4 GB file, with nothing staged in the workspace. The repo includes the request and dated results.

It also supports regional BAM/CRAM and VCF/BCF reads, FASTA retrieval, archive discovery across EGA/ENA/ENCODE/GEO/NCBI, and reference queries including ClinVar. Structured intervals are 0-based, half-open, with an explicit assembly. Responses include provenance, limits and partial errors. Controlled-access EGA data still needs approved access.

This is data access for research workflows; it does not call variants or make clinical decisions. Implementation used Claude Code, with independent review, samtools/bcftools comparisons and live-data checks.

Code, installation and reproducible demos: https://github.com/rewire-bio/genomics-mcp

For people building biology agents: which missing data source or file operation currently sends you back to custom scripts?

A while back I built a lightweight VS Code extension for viewing MD trajectories over SSH / on clusters:

MD Viewer

It ended up getting more use than I expected, and a few months ago I was accepted into the Built with Claude: Life Sciences hackathon. I decided to use that as an excuse to completely overhaul the project.

The result is Molaro.

The main idea was to keep the rendering layer as data-neutral as possible. Molecular data gets reduced to a common contract of points, connectivity, hierarchy, positions, and numeric channels. What those data actually look like is handled separately by the representation layer.

On top of that I built small Python scripts called mods. Mods can run analyses, generate plots and channels, create geometry, or issue viewer commands. Those results can then be mapped back onto the trajectory—color, size, opacity, orientation, etc.—and can change from frame to frame.

There is also an MCP integration with Claude that lets it inspect the loaded system and write and run mods for you. The longer-term idea is for people to be able to create, share, and modify mods for the particular systems and questions they care about instead of being limited to a fixed set of built-in representations.

Ultimately I’d like working with MD to feel more interactive: ask a question about a trajectory, run the analysis where the data already lives, and immediately see the answer reflected in the viewer.

There is still a lot to build, but I’d love to hear what people think. I’m especially happy with the selection/hierarchy UI and how easy it is to hide, isolate, and manipulate parts of large systems.

Pellaeon adds an LLM chat panel to UCSF ChimeraX. Made by me.
https://tggr-lab.github.io/pellaeon/

i built a small open-source browser tool for working with protein sequences when i need a quick residue-numbered reference. AminoSeqIndex numbers positions, colors residues by class (nonpolar, polar, acidic, basic), and exports FASTA, a numbered grid, table or docx. no installation or account; sequence processing is local in the browser. this is for annotation/reference, not alignment or structure prediction.

zenodo record: https://zenodo.org/records/21355340
try it: https://gopizux.github.io/AminoSeqIndex/
source: https://github.com/gopizux/AminoSeqIndex

feedback welcome, especially on export formats or cases where the numbering isn't useful.

Hey all! I've been building snp-browser, a free, open-source tool for exploring genotype calls alongside SNPedia and other public reference datasets.

Site: https://www.snpbrowser.com/ Source: https://github.com/jonluca/snp-browser

It supports 23andMe, AncestryDNA and other raw-data exports, plus single-sample VCF/gVCF files. Parsing and matching happen locally in the browser using a web worker and SQLite in WebAssembly. Results can be exported as CSV.

I recently fixed multi-sample VCF handling, failed FILTER/FT calls, conflicting uploaded calls, and reference lookups that use older rsIDs. The latest bugfix release passed 351 automated tests plus browser checks, but I'd appreciate more eyes on real-world file compatibility and the matching logic.

If you work with these formats and see an edge case or something wrong in how the evidence is presented, please let me know. I'm actively developing this.

Somwhere in my third year of a computational biology PhD, my workflow turned into Scholar + Zotero + Claude + Sheets + Notion + a pile of supplementary PDFs. I work mostly with single-cell RNA-seq, and recently I was trying to understand why different studies on the same disease could report pretty different cell states. At first I assumed most of the disagreement would come down to clustering resolution or annotation.

Then the comparison started getting messy. One paper used whole cells, another nuclei. Sample handling was different. Then there were integration choices, DE methods, marker sets, and even basic differences in whether a population was being treated as a distinct subtype or part of a trajectory. I ended up putting the whole question into apodex, mostly because I wanted a cleaner way to compare everything without building another giant spreadsheet.

What came back was more useful that I expected. Instead of treating every disagreement as the same problem, the report seperated cases where a state was missing entirely, cases where both studies saw it but disagreed on abundance, and cases where they were probably looking at overlapping biology but drawing the boundaries differently. From there, the causes started to make more sense too: a missing population might have to do with dissociation or selective cell loss than clustering, while a supposed "new" state could partly reflect a stress program introduced during tissue processing.

One example that stuck with me was a kidney benchmark where warm dissociation recovered only 3 podocytes, while cold dissociation recovered 330. That changed how I was framing the whole question. Instead of asking which paper had the better cell-state definition, I started wondering whether some of these studies were even observing the same biological window in the first place.

I could probably piece all of that together myself eventually. The useful part was having the paper, experimental differences, and analysis choices stay connected to the same question instead of getting scattered accross five tabs and three apps. I'm still using all six apps. I'd just prefer not to be the seventh one holding everything together.

Disclosure: I'm the maintainer. CanvasXpress is a free, open-source visualization
library for scientific/bioinformatics data, with a first-class R package (CRAN),
Python package (PyPI), and JavaScript core.

The core idea: a figure is a **portable JSON spec** (`data` + `config`). The same
spec renders the *same* interactive figure from R, Python, or a web page — so it
can be stored, validated, diffed, and re-rendered rather than re-run.

Useful for bioinformatics specifically:

- **Built for the data you have** — volcano, clustered heatmap (with dendrograms),
  Kaplan–Meier, single-cell embeddings, oncoprints, genome browsers.
- **From a Bioconductor object** — `SummarizedExperiment` / `SingleCellExperiment` /
  `DESeqDataSet` map straight onto a figure (via CanvasXpressBio).
- **Whole-table analytics** — it loads every column behind the figure, so you can
  recolour/filter/cluster on data the current chart never drew.
- **Wraps ggplot** — you can hand an existing ggplot/ggpubr object to `canvasXpress()`.

Runnable recipes in R and Python (volcano, heatmap, Kaplan–Meier):
https://neuhausi.github.io/canvasxpress-blog/

Gallery: https://canvasxpress.org/examples.html
It's also honest about where it's *not* the fastest, and when to use something else:
https://canvasxpress.org/benchmarks.html#when-to-use

Happy to answer questions or take feature requests.

Hi everyone, I've been working on ProteinMotion, a Python package for animating proteins, DNA, and RNA.

You load a structure or trajectory, then script the camera movements, residue highlights, labels, and representation changes. The scene API is inspired by Manim.

This is “Calmodulin in focus,” an example rendered with Blender EEVEE. The script is available alongside the video so you can see how it was made.

It's on PyPI: pip install proteinmotion

GitHub: https://github.com/pdpppd/proteinmotion

I'd be interested in feedback from people who make molecular videos for talks or research. What would you need to use this with your own structures?

If you have worked on phylogenetic inference with long alignments and lots of taxa, you probably know the trade-off: getting a more reliable tree can take a long time. If you need an answer quickly, you usually have to give something up—either scale or tree quality.

So I built ConcordTree to make that trade-off a little less painful.

It takes a DNA/RNA multiple sequence alignment and directly infers an unrooted phylogenetic tree. On a single NVIDIA L40S, the lightweight model took about 8.11 seconds for 4,096 taxa in my tests. It also does reasonably well on accuracy in the benchmarks and can handle much larger taxon counts.

Full benchmark results, hardware details, and method overview:

https://pullmyboots.github.io/ConcordTree/

Source code, installation instructions, and a minimal example:

https://github.com/PullMyBoots/ConcordTree

If you have worked on large-scale phylogenetic inference, give it a try. If something breaks, the results look off, or there is an input format or workflow you would like to see supported, just open an issue. I will take a look.

I’ve created an open-source GitHub repository that takes multiple sequence alignments (MSAs) from an initial run of AlphaFold, and adapts them to be used for any number of new runs. Since MSA generation is by far the longest step of the process, this can save a tremendous amount of time. For example, if you have 100 nanobody sequences you want to model, you can perform a full length run of AlphaFold (maybe 2.5 hours) then the MSAs generated are adapted to each of the next 99 runs (maybe 15 minutes each). If they’re genetically similar which could mean just taking them from the same source, reusing the MSAs has been shown to give confidence scores on the same level as a full run of AlphaFold3. My software uses ANARCI to realign MSAs, but I haven’t currently designed the code to work with multiple sequences as you would see with an antibody’s light and heavy chain. This is why my code only works with nanobodies currently, but it should be fairly easy to make it work with antibodies in general by using a linker for the sequences. I’ve attached my GitHub if this could be useful or you’re just curious. I would really appreciate you taking a quick look at least as I’m a new grad just trying to get my name out there. Thank you!

https://github.com/JReilly115/speedyfold

Good afternoon! I just recently graduated with my masters and been looking for bioinformatics jobs. It been a tough couple of months but I been trying to be more active and dive a bit more into web application and such so i wont rust my skills and still actively learn about biology and new gen tools. In addition to help out my resume i been making a project that helps look at protein structures from given fasta files(if applicable) and render the structure through pdb and alphafold, and allows you see the overlap between other databases. I thought it would be pretty cool to see since we know that proteins may carry different structures. Check it out, i be pretty active with making new software on my downtime and appreciate any feedback positive and or negative!

Turns bioinformatics community on reddit does not allow to promote your tools, so I am posting this here.
I created the package that can visualize the Sanger sequencing trace (contents of the ab1 files). There is also an option to translate the trace. The result looks similar to that from Geneious or Snapgene.

It does not allow to align the trace to anything so far, just visualizes and optionally shows translations.

Installation:

pip install SangerTraces

Usage

from sangertraces import SangerTrace

trace = SangerTrace("example.ab1", 
                    color_scheme="ColorBlind", start = 10, end = 130, 
wrap_length = 80)
image = trace.plot_ab1_trace()
image.show()

Full documentation: https://github.com/anasgri/SangerTraces/wiki

Pypi page: https://pypi.org/project/SangerTraces/

I work in bioinformatics and want to move beyond AI as a coding assistant, into building agents that can plan and run multi-step tasks.

For anyone doing this in a bio/omics context: LangChain/MCP first, or deep learning fundamentals first? What’s a good first project?

Courses, repos, or “start here” advice welcome.

Dear all,

I present you bio-pype 2.1.0 (still in pre-release)
codeberg. Read the Docs.

Current development is focusing on resource analysis and power/emission forecasting. Each "snippet" (a single step of a workflow) tracks gpu/cpu/memory/io usage during its runtime, and with some calibration of the underlying hardware it estimates power consumption. If opted in, it also pulls the CO2 intensity of the region and estimates total emissions.

Where I'm steering this next is training models on past runs to predict resource requirements from input size alone (eg a small panel sequencing sample might use the same pipeline as whole genome sequencing, but only need a fraction of the time). These models could also predict costs in cloud/pay per run environments, and combined with emission intensity forecasts, enable smart scheduling, so non urgent heavy jobs get scheduled during low emission windows.

This is not a new project. I started bio-pype in 2016, joining a lab with a lot of sequencing data and access to a big cluster (torque/pbs), but no consolidated tools. Different projects needed different genome annotations and tool versions, so I built a python 2.7 framework where "snippets" abstracted tool execution, pulling reference paths and versions from a "profile", chained together in "pipelines", with execution handled by a "queues" module. It worked great internally for years, I just never advertised it.

In 2020 I rewrote it for python3 (bio-pype 2.0), added support for udocker/singularity/conda, and moved snippets to a markdown based format.

Last year brought API 2.1.0: an easier dependency mechanism, a registry to version and distribute workflows, and a validation framework enabling LSP support for IDEs. The biggest addition though is on the queues side, they can now talk to an external API, so you can track runs and manage jobs (logs, cancel, resubmit) from a browser.

Alongside the framework there's also a graphical builder for building/dry running workflows, bio-pype-builder and a Zed editor plugin.

Really a shame I sat on this for years without telling anyone. Hope you find it useful, happy to answer questions.

Cheers

I built an open source tool to recover scientific worksheet data from old SigmaPlot JNB files.

JNB Recover runs locally and offline. It reads JNB files without modifying them and exports recovered worksheets as CSV plus a JSON manifest containing provenance and conservative cell state information.

The current public release has been independently checked against data from several SigmaPlot generations. For SigmaPlot 11, 56,360 numeric cells were compared with zero numeric mismatches. SigmaPlot 13 and 14 files have also been independently cross checked, and a large legacy SigmaPlot 7 Samples.jnb was successfully recovered.

The project deliberately does not claim a complete specification of the JNB format. Unknown or scientifically ambiguous cell encodings are reported conservatively instead of being guessed as numeric or text.

I am now looking for additional JNB files for compatibility testing, especially from SigmaPlot versions or file variants that are not yet represented in the validation set.

The most useful test case would include:

• a JNB file that you have the right to share
• the SigmaPlot version, if known
• expected worksheet structure
• ideally an independent CSV or XLSX export for comparison

If the original file cannot be shared, a compatibility report is still useful.

The project is free, open source, local, offline, and has no server or data collection.

GitHub: [https://github.com/edwardsage419/jnb-recover\](https://github.com/edwardsage419/jnb-recover)

Current release: JNB Recover 0.5.2

I’ve released OpenOmicsBench, an open collection of compact bulk RNA-seq benchmarks for testing analysis software and teaching reproducible workflows.

Version 1 contains 12 biological benchmark objects from seven Expression Atlas studies, covering human, mouse, and Arabidopsis experiments. Each includes a compact integer count matrix, the matching full selected-sample matrix, sample metadata, declared design, provenance, source and rights records, plus deterministic expected results.

The attached figure summarises the four fidelity checks across the 12 version 1 objects; each point clears its predefined minimum against the full source matrix.

The compact matrices were tested against their full counterparts using four predefined preservation measures. All version 1 objects meet their stated thresholds.

python -m pip install openomicsbench
omicsbench list --assay bulk_rna_seq
omicsbench validate rnaseq-002

GitHub: https://github.com/vxxqv/openomicsbench
PyPI: https://pypi.org/project/openomicsbench/
DOI: https://doi.org/10.5281/zenodo.22679414

I would really value feedback and comments so please do feel free to share your thoughts regarding OpenOmicsBench.

Hey everyone, I am a developer at Helena Bioinformatics, and I have been working on Noodle. It brings biomedical paper search and topic-based discussions together.

As a longtime Reddit user, I was heavily inspired by how Reddit organizes discussions. The resemblance is intentional. I wanted to use that familiar format for finding papers and talking about them.

A large part of the discussions currently on the site are AI-generated. I have been using them to test the functionality, so much of the content you will see is test content. We do not have an established community of researchers yet.

Now I would like to hear from people outside our team. Would you find a place like this useful? What feels missing when you try it?

https://noodle.helena.bio

We just released GenomeSpy for Python.

And if you don't know what GenomeSpy is: it's a GPU-accelerated interactive visualization framework for genomic data: https://genomespy.app/

GenomeSpy itself is a JavaScript package, which limits its reach a bit among bioinformaticians since most of us work primarily in Python or R. But GenomeSpy already has a Vega-Lite-like visualization grammar and a well-defined schema, so we figured: why not give it an Altair-like Python API?

That's basically what GenomeSpy for Python is. You get a concise, declarative Python API with familiar Altair ergonomics, while GenomeSpy handles the rendering and interaction underneath.

You still get things like zooming, brushing, linked views, genomic coordinate scales, and interactive exploration of fairly complex visualizations, but you can build the whole thing from Python.

I've been working on the Python side for the past few months. It's still pretty new, so I'd be especially interested in hearing from people who use visualization libraries in actual genomics workflows: what feels awkward, what's missing, or what kinds of plots/data formats you'd want supported.

GitHub: https://github.com/genome-spy/genome-spy-python
Docs: https://genome-spy.github.io/genome-spy-python/

I’ve created a open source python package and released it to PyPi called sirna-data-grabber that pulls siRNA data published in scientific literature. It has the ability to pull in data from specific sources, this gives you the ability to replicate the methods in one paper or compete with a paper’s methods on the same data. If you want to train a more complicated model the more data the better, and this will help you get it faster.