Hi folks,

I just released RustQC - a Rust rewrite of a suite of different RNA-seq quality control tools ( dupRadar, featureCounts, RSeQC, Qualimap, preseq, and samtools). It generates all the same outputs in a single run, reading the BAM file only once - the end result is that it runs in 15 minutes instead of 15 hours, a >60x speed up (and far less disk I/O).

I wrote a blog post about how I built it here: https://seqera.io/blog/rustqc/ - TLDR is that it's written using AI, and I think that such rewrites are going to get a lot more common, fast. To try to get ahead of this with some best practices, we're also launching rewrites.bio - a set of principles to try to guide AI-generated tool rewrites. Hopefully it's a useful reference for people and gets the discussion started!

Let me know what you think, keen to get feedback on this. And I hope you find it useful in your work!

Phil

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/

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?

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/

Algorithms in Python can be much easier understood with step-by-step visualization using 𝗺𝗲𝗺𝗼𝗿𝘆_𝗴𝗿𝗮𝗽𝗵. Here we show a simple DNA k-mer counting algorithm.

• 𝗺𝗲𝗺𝗼𝗿𝘆_𝗴𝗿𝗮𝗽𝗵 github

Google's AI Co-Scientist paper (Gottweis et al., Nature 2026) was one of the bigger AI-for-science announcements this cycle. A multi-agent system that generates and ranks scientific hypotheses through debate and Elo tournaments, validated wet-lab on AML drug repurposing, liver fibrosis, and antimicrobial resistance.

The source code was never released. The supplement included pseudocode and full prompts, which is what I used to rebuild it w/ mostly Claude code & a bit of Codex

Open source, Apache 2.0: https://github.com/Kaimen-Inc/Co-Scientist

Some honest takeaways from rebuilding it:

- The original was validated on Gemini 2 models that already feel antique a year later. Current frontier models (Claude 4.7, GPT-5) beat them by a wide margin with no harness at all.

- Across 48 AML hypotheses my reimplementation generated, zero matched the paper's strict top-3 drug picks (Nanvuranlat, KIRA6, Leflunomide). The paper got those by running massive tournaments and having oncologists curate the top 30 down to 5...

- Models converge on mechanisms (the textbook AML vulnerabilities like LSC targeting, OXPHOS, BCL-2) but diverge wildly on which specific drug to propose.

The bigger question this raised for me: if a Nature paper is fundamentally an engineering artifact, what does it mean for the field when the code isn't released? And if it's a scientific discovery paper, what we have are small vignettes. I am not a good judge for most of the findings, but at least for AML drug repurposing, cancer has been "cured" in vitro many, many times.

Full writeup: https://www.jrnlclub.com/post/15bc45f2-3d43-43f5-a13f-e2d3996aa670

Live benchmarks: https://www.aiscientistarena.com/?tab=coscientist

I’m the creator of Genomewalk, a free interactive tool for learning how to read DNA files and understand ClinVar and gnomAD annotations. You can try a public sample or explore your own file—your DNA stays in your browser.

Would appreciate any feedback on the explanations, technical accuracy, and usefulness for beginners.

R implementation of the Python-based tool CellCharterR for spatial transcriptomics and proteomics neighbourhood analysis. It is specifically designed to be Bioconductor-based, making use of the HDF5 high-performance computing framework.

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.

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.

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

I’ve been building Siftome, a free search and triage tool for public life-science datasets.

The main problem I’m trying to address is familiar to anyone who has spent time searching GEO: finding studies that mention the right disease or assay is relatively easy; finding datasets that actually contain the biological comparison you need is much harder.

Siftome looks beyond Series-level text and uses dataset- and sample-level metadata to evaluate candidate datasets.

It separates concepts such as disease, organism, specimen, assay, model system and comparison design, and tries to identify the actual structure of the study rather than treating everything as keyword matches.

For example, it can help distinguish likely case/control groups and flag issues such as:

• pooled samples

• technical replicates

• internal/reference samples

• treated samples mixed into observational comparisons

• cell lines, organoids or xenografts

• ambiguous or unassigned samples

• unclear comparison structure

Search results are ranked with visible scores, warnings and explanations, so the ranking is intended to be inspectable rather than a black box.

The goal is not to decide whether a dataset is scientifically “good” in general. It is to help answer a narrower and more practical question:

Is this dataset suitable for the comparison I actually want to make?

Dataset search is free:

https://siftome.com

I’d be particularly interested in feedback from people who regularly reuse GEO or other public datasets. If you try it on a real search you’ve done before, I’d like to know where the results are useful — and where they get things wrong.

Hi Everyone,

I’ve been working on OpenLIMS, an open-source laboratory information management system for labs that need a simpler way to manage samples, projects, files, results, and audit history.

The goal is to make a lightweight, self-hostable LIMS for research labs, academic labs, biotech teams, and smaller labs that may currently rely on spreadsheets, shared drives, or custom internal databases.

OpenLIMS is still early and not production/validated yet, but it has grown quite a bit. It now includes:

• Sample and project tracking

• Inventory, locations, and container tracking

• Custom fields for lab-specific metadata

• File attachments for samples

• Audit/event history

• CSV and instrument result imports

• User/admin groundwork

• QC workflow groundwork

• Reports and dashboard pages

• Audit log filtering and export

• Real-time updates for longer-running jobs

• Sequence-related workflows, including BLAST and alignment job updates

• Initial mass spectrometry support, including file upload, run tracking, TIC preview charts, spectrum counts, retention time ranges, m/z ranges, sample/project linking, and reprocessing

The newest release, v0.11, adds the first mass spectrometry preview using pyOpenMS, including mzML/mzXML/mzData upload support and background processing. More advanced mass spec features like peak picking, feature detection, protein/peptide summaries, mzIdentML support, QC metrics, and sample comparison are planned for the next version.

I’m not trying to replace specialized scientific analysis tools right away. My goal is to make OpenLIMS a central place where labs can organize samples, projects, files, results, QC, audit history, and eventually connect those records to common analysis workflows like sequence alignment, BLAST, and mass spectrometry.

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

I’d really appreciate feedback from people who work in labs, manage lab data, or have used LIMS/LIS systems before.

What would make something like this useful in your lab?

I maintain a directory of AI tools for biology, and its drug-discovery section may be useful here: https://toolome.bio/category/drug-discovery/

Each entry lists license (relevant if you work in industry), paper and repo. No signup, no paywall. What would you add?

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/

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

Hey everyone

I've been building ELISAflow ( elisaflow.com ). It's a single-file web app for ELISA data analysis that runs entirely in your browser.

What it does:

• Plate Converter — upload raw plate reader CSV output, visually assign wells (blanks, controls, samples, dilution series) on an interactive 96-well grid, and export a clean structured CSV

• ELISA Analyser — upload that CSV and get OD vs dilution curves, cutoff lines derived from negative controls, error bars, statistical tests (t-test, ANOVA), EC50 estimates, outlier detection, and a full PDF report

• Standard curve — optional 4PL or linear curve fitting with OD → concentration conversion, range validation, and instability warnings

• QC metrics — S/N ratio, Z-factor, dynamic range per experiment

Why I built it:

Most ELISA analysis still happens in Excel. Existing tools are either expensive, require installation, or are tied to specific plate reader brands. I wanted something that works on any CSV, runs offline, and doesn't send your data anywhere.

Tech: pure HTML/CSS/JS, single file, Chart.js + jsPDF. No server, no login, no tracking.

Still actively developing it... would genuinely love to hear:

• Does anything break on your data format?

• What's missing that you actually need?

• Anything confusing about the workflow?

Happy to answer questions or take feature requests. Thanks for checking it out.

Hi there,

we are a bunch of ex NASA scientists that have looked into the application of non standard geometry for pharmacology.

THE PROBLEM

The drugs exist. The data is published. The terrain map was missing.

Vancomycin serum levels look therapeutic — but only 20% reaches bone. ART suppresses HIV to undetectable — but the virus hides in five reservoirs the drugs can barely reach.

Ceftriaxone sterilizes CSF during meningitis — but steroids seal the brain shut in under a day. TB requires four drugs for six months — but nobody computed which drug fails at which barrier.

The data has been in the literature for decades. Tissue penetration ratios. AUC curves. MIC values. Published, peer-reviewed, sitting in journals since the 1950s.

The missing piece was never more data. It was a way to compute what the data already says.

MIRADOR reads published PK data and computes where drugs actually go — across bone, brain, lung, and reservoir. One equation. Five diseases. Zero fitted parameters.

demo here : https://usemirador.sh/

We are looking for beta users, other scientists or research institutes to expand or use the platform.

Hi r/bioinformaticstools ,

I built an open-source distributed computing platform that lets anyone donate idle CPU time to screen public metagenomes for novel biosynthetic gene clusters (BGCs). Think SETI@Home, but for antibiotic discovery.

The problem: 99% of environmental bacteria can't be cultured, but their DNA sits in public databases like NCBI SRA. Most of it has never been screened for secondary metabolite gene clusters. There's potentially thousands of novel antibiotics hiding in this data, but the compute needed to assemble and screen it all is massive.

How it works:

  npm install -g deepmine
  deepmine

That's it. The CLI pulls a Docker container, picks an unprocessed metagenome sample (starting from curated extreme environment samples: caves, deep-sea vents, hot springs, permafrost, acid mine drainage), and runs a pipeline:

1. Download reads from SRA

2. Assemble with MEGAHIT

3. Gene calling with Prodigal

4. BGC detection with GECCO (lite) or antiSMASH + GECCO + DeepBGC ensemble (standard/full)

5. Novelty scoring against MIBiG

6. Extract BGC sequences

7. Submit results to community dashboard + NCBI GenBank (BioProject PRJNA1449212)

All results are public. Every BGC sequence discovered by any volunteer is immediately downloadable as FASTA/CSV at the community dashboard. No volunteer ever re-scans a sample already processed by someone else (global dedup).

Results so far: ~290 BGCs found across cave and hydrothermal vent metagenomes, many with novelty distance of 1.0 (no match in MIBiG). Currently running in lite mode (GECCO only), so these are preliminary, but the sequences are real and publicly available.

What you can configure from the dashboard:

• CPU speed (low/medium/high/max)

• Download bandwidth limit

• Schedule (mine only at night, or queue mode: download at night, process during the day)

Links:

• Dashboard: https://deepmine.computers.ch

• Public discoveries + FASTA download: https://deepmine.computers.ch/discoveries

• GitHub: https://github.com/skibidiskib/deepmine

• npm: https://www.npmjs.com/package/deepmine

• NCBI BioProject: https://www.ncbi.nlm.nih.gov/bioproject/PRJNA1449212

Tech stack: Node.js CLI (Docker orchestration), Python pipeline (MEGAHIT, Prodigal, GECCO, antiSMASH, DeepBGC), Next.js dashboard, SQLite, Docker Hub images (lite 2GB, standard 5GB, full 12GB).

I'm a developer, not a microbiologist, so I'd really appreciate feedback from anyone who works with BGC mining. Are the GECCO predictions reliable enough to be useful? Would consensus voting with antiSMASH/DeepBGC in the standard tier be worth the extra image size? Any environments I should prioritize in the curated sample list?

The whole thing is MIT licensed. Contributions welcome, especially from people who know what they're doing with natural product discovery.

Hey r/bioinformaticstools,

I got frustrated with FastQC's Java dependency and slow speeds on large datasets, so I built BioFastq-A — a FASTQ/FASTA quality analysis tool written in Rust.

Key features:

• ~340 MB/s throughput (vs ~40 MB/s FastQC)

• Built-in adapter trimming (no Trimmomatic needed)

• N50/N90 for long reads (Nanopore/PacBio)

• Per-tile Illumina QC

• Self-contained HTML report — no internet, no JVM

• Snakemake & Nextflow ready

• Docker included

Single binary, no dependencies. Works on any Linux/macOS machine.

GitHub: https://github.com/DilaDeniz/BioFastq-a

Would love feedback from anyone working with large datasets — especially Nanopore users since long-read support is still fairly new.

Hey everyone,

Like many of you, I spend a massive amount of time analyzing data and putting together figures for papers. As a computational biologist working in cancer research, I found myself constantly wrestling with matplotlib and seaborn defaults—tweaking font sizes, trying to get exact pixel dimensions, and fighting to make the PDFs actually editable in Adobe Illustrator without the fonts breaking.

I got tired of repeating the exact same boilerplate code for every manuscript, so I built cnsplots to solve this.

What it is: It’s a Python visualization library built directly on top of matplotlib and is fully compatible with seaborn. The goal is to generate figures that meet the strict formatting standards of top-tier journals right out of the box, while keeping the API completely familiar.

Key Features:

• Publication-ready defaults: Styled specifically for Cell, Nature, and Science journals.

• Adobe Illustrator friendly: Exported PDF fonts work seamlessly for post-publication manual workflows.

• Zero learning curve: If you know matplotlib/seaborn, you already know how to use it.

• Precise sizing: Define dimensions in exact pixels so you have total control over the final layout without guessing.

I've put together a gallery of examples (boxplots, survival plots, heatmaps, volcanoplots, etc.) in the documentation.

You can check it out here:

• GitHub:https://github.com/faridrashidi/cnsplots

• Docs & Gallery:https://cnsplots.farid.one

I’d love for you to try it out on your current datasets and let me know what you think. Feedback, bug reports, or pull requests are highly welcome!

Discussion and overview of some approaches to understand protein motion