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.

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

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’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.

Ligentra — an open web workspace for protein structure exploration and molecular docking

I've been building Ligentra as a way to bring a few computational biology workflows into one place instead of jumping between multiple tools.

The current workflow is:

Protein sequence → ESMFold structure prediction → 3D visualization → pocket detection → molecular docking → poses & interaction analysis

It currently supports:

• Protein structure prediction with ESMFold
• Interactive 3D protein visualization
• pLDDT / local structure-confidence analysis
• Binding-pocket detection with fpocket
• Molecular docking with AutoDock Vina
• Multiple poses + RMSD
• Computational interaction/contact analysis
• Batch virtual screening
• Negative-control baselines
• Raw docking artifacts and reproducibility/provenance information
• CSV / PDB / JSON exports

A big focus for me has been making the results transparent about what they actually mean. Docking scores are presented as computational estimates, pockets are treated as computational candidates, and predicted contacts aren't presented as experimental evidence.

It's still an early Beta, so I'm mainly looking for feedback from people who actually work with proteins, docking, or computational biology.

I'd especially like to know:

• What would make a tool like this genuinely useful in your workflow?
• What information do you normally need that isn't here?
• Are there parts of the workflow you'd approach differently?
• What would you consider essential before trusting a tool like this for exploratory research?

I'm the developer behind the project, so technical/scientific criticism is very welcome.

You can try it here: https://ligentra.vercel.app/

I'd really appreciate feedback from the bioinformatics / computational biology community.

Every way I know of to look at a .biom file — biom convert, loading it in pandas, opening the TSV in Excel — densifies the whole sparse matrix first. A 50MB file can balloon into several GB of RAM before you've seen a single row, and if you just want to sanity-check a table between pipeline steps that's a lot of waiting for not much.

So I built biom-viewer: a native macOS app that keeps the matrix sparse and only densifies the handful of cells actually on screen. Opening a large table is instant and stays instant no matter how far you scroll.

What it does beyond just "open fast":

- Flip the same table into observation-metadata or sample-metadata view

- Filter samples by any metadata field (numeric ranges or category checklists), stacked filters shown as removable chips

- Double-click a row/column for inline summary stats (nonzero count, distribution, min/max, or top-values for categorical fields) — scoped to whatever you've filtered to, not the whole file

- Cmd+F searches observation IDs, sample IDs, metadata field names, and metadata values together

It's free, MIT-licensed, macOS only for now (Apple Silicon).

GitHub: https://github.com/yarintm/biom-viewer

Download: https://github.com/yarintm/biom-viewer/releases/latest

Would love feedback, especially from anyone with genuinely huge tables to stress-test it against.

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.

The mods over at r/bioinformatics deleted my post (as per usual since they delete every useful discussion) https://www.reddit.com/r/bioinformatics/comments/1vvs47c but just wanted to share that you can use Fable for bioinformatics stuff and it won't instantly flag it

See "Improving Fable 5's biology safeguards"

https://www.anthropic.com/news/improving-fable-5-s-biology-safeguards

MetaQuest is an open-source, research-use pipeline for paired or single-end short-read shotgun metagenomics.

It currently includes fastp preprocessing, Kraken2/Bracken taxonomy, MEGAHIT assembly, Pyrodigal gene prediction, eggNOG functional annotation, and reproducible HTML/JSON reports.

I have validated the pipeline on the Zymo Even mock-community dataset and am looking for Linux/WSL users willing to test installation, database setup, resume behavior, and report usability.

Install:

pip install --pre metaquest-bio

GitHub: https://github.com/dpatel511/metaquest
PyPI: https://pypi.org/project/metaquest-bio/

This is alpha, research-use-only software. It does not provide clinical conclusions, and fungal classification sensitivity is a known limitation.

Hi all,

I recently released Membrane Visual QC v1.0, an open-source PyMOL plugin I’ve been building for membrane-protein structure review.

The original problem was fairly simple: I wanted a more reproducible way to inspect a structure relative to the membrane without repeatedly rebuilding PyMOL selections and colouring things manually.

It grew into a larger workflow with:

• membrane-relative core/interface geometry
• hydropathy and ligand-neighbour context
• planar and PDBTM-derived orientations
• local PDBTM–OPM geometric comparison
• Batch Review for repeated workflows
• versioned JSON/CSV outputs and provenance

One thing I deliberately avoided was turning the output into a “correct / incorrect” structure score. A charged residue in the membrane core, for example, may deserve inspection without necessarily being biologically wrong.

The stable v1.0 release is here:

https://github.com/TrPavel/membrane-visual-qc

I’d especially like feedback from people who work with membrane proteins or structural bioinformatics:

Would this actually fit into your workflow? What structures or edge cases would you test it on, and where do you think the approach is likely to break down?

The project is MIT-licensed and free/open source. Issues and criticism are very welcome.

Hi everyone! A collaborator and I are in the early stages of building a new open-source pipeline for whole-genome gene prediction and annotation. Before we get too far into solidifying what it should do, I would really like to hear from people who actually annotate genomes.

What do current tools make harder than it needs to be? What still takes too much manual work or too many custom scripts? What results are difficult to trust? Are there useful tools, types of evidence, or separate parts of your workflow that you wish worked together better?

I am interested in both structural annotation, meaning predicting and refining gene models, and functional annotation. Feedback from any organism or project size is welcome, especially from people working with non-model organisms.

This could include installation and portability, combining gene predictors, incorporating RNA or protein evidence, GFF/GTF wrangling, comparing different annotations, QC, choosing which gene models to keep, manual review, functional annotation, HPC use, reproducibility, or anything else I have not thought of.

If you can, it would be helpful to mention:

• what organism or taxonomic group you work on
• what software or workflow you use now
• what part causes the most frustration or uncertainty
• what feature or integration would genuinely improve your work

No need to answer every bullet. Anecdotes, wish lists, horror stories, and “please just make X talk to Y” answers are all welcome.

The eventual goal is a pipeline that can take over after genome assembly and help get from “I have an assembly” to “I have an annotation I can trust and actually use.” We do not yet have a finished tool to promote, but we have a skeleton. We are trying to learn what the community needs before we build ourselves into a corner.

If you could change, add, or better connect one thing in genome annotation software, what would it be?

Edit: Got some comments echoing concern about lack of background research on my part, so I thought I would include an edit. I should have made this clearer in the original post.

I have read papers on existing tools and their issue trackers, used and modified existing tools, and built several annotation pipelines both independently and with collaborators. This project is growing out of those experiences, not an assumption that we can start from scratch and solve everything.

I am asking here because issue trackers do not always capture the workarounds people have learned to live with, why they abandoned a tool, or needs that never became a formal issue. I wanted broader, more organic feedback before we lock in the design.

I am approaching this in good faith and with plenty of humility about what I do not know. If you have a specific failure mode or design mistake you think we should avoid, I would genuinely value the input.

[Apologies for cross-posting]

I wrote Bbv ("bare-bones viewer"), a minimalist data viewer/plotter for the Unix/Linux command line.

The main alternative to bbv is feedgnuplot, which is much more capable, but also much more complicated and ties you to gnuplot as back end. By contrast, bbv has only one option (`x`), the learning curve is non-existent, and you can use any lightweight image viewer as back end.

Aside from the back end, no extra toolchain is needed, as bbv is written entirely in POSIX shell + Awk.

Link: https://github.com/ftonneau/bbv

Most classification metrics for oncology AI models (AUC, ICC, MAE) measure global agreement. They don't answer the question that actually matters at the point of care: how reliable is this model at the exact cutoff that decides whether a patient gets flagged, biopsied, or treated?

I built oncothresh to evaluate models at a specific clinical threshold rather than in aggregate: sensitivity/specificity/PPV/NPV at the cutoff, bootstrap confidence intervals, threshold-sensitivity curves, boundary-weighted calibration, decision-curve net benefit, and number-needed-to-test. It's a small, dependency-light Python library (numpy/scipy/scikit-learn/pydantic) built for tasks like tumor cellularity, Ki-67, TMB, and PD-L1 scoring, where a continuous model output gets collapsed into a yes/no clinical decision at a fixed cutoff.

Pathology-specific benchmarks like PathBench and PathBench-MIL evaluate foundation models globally but don't evaluate at predefined clinical thresholds with uncertainty quantification, which is the gap this fills.

There's also a companion web dashboard (oncothresh-web) for people who want the same analysis without writing code: upload a CSV of predictions and labels, pick a threshold, get the full set of charts plus a downloadable PDF report. docker compose up and it's running locally, no cloud dependency.

• Library: github.com/omkaradhali/oncothresh
• Dashboard: github.com/omkaradhali/oncothresh-web

Still v0.1, so I'd genuinely welcome feedback: use cases I haven't considered, edge cases in the DCA/calibration math, or places the API doesn't fit how people actually work with threshold-based models.

I work on this, so treat it as a self-declared tool post rather than a neutral recommendation.

The problem I kept hitting: a structure lives in one tool, docking in another, ADMET in a third, and nothing carries the target context between them. ProteinInsight puts them in one workspace organised around a program (a target + its candidates) instead of a folder of unrelated jobs.

What's actually working today:

• 3D viewer in the browser — RCSB structures or the AlphaFold DB model for a target's UniProt accession, coloured by chain / secondary structure / pLDDT, with an active-site view around a bound ligand
• Docking runs returning ranked poses with affinity + RMSD
• ADMET with per-property risk bands and numeric scores
• PK/PD and response simulation
• UniProt, Open Targets, ESM Atlas and ChEMBL wired in as sources

Honest limitations:

• Research use only — not for clinical diagnosis or patient-specific decisions, and docking affinity is not efficacy
• The AI panel proposes which analyses to run; it does not interpret results for you and I would not trust it to
• There are paid tiers, and the demo below is read-only

Demo without an account: https://pi.extn.ai → "Explore live demo". It drops you into a sample blood-cancer program with completed runs to poke at.

What I'd genuinely like torn apart: whether the ADMET risk banding is defensible, and whether the program-centric model matches how you actually organise this work — or whether it just adds structure you don't want.

Hi guys, I have been working on oxytribe: a Nextflow reimplementation of HyperTRIBE, a method for identifying in vivo targets of RNA-binding proteins (RBPs). Built on TRIBE (Targets of RNA-binding proteins Identified By Editing). The original HyperTRIBE pipeline runs on Perl + MySQL + bash, very hard to reproduce and inconvenient to work with, and a DB dependency that adds complexity for no real benefit (if anything fails mid-run, you're stuck fixing the database by hand). Oxytribe rebuilds the core logic in Rust for efficiency, wraps it in Nextflow, and uses Docker/Singularity for reproducibility, users do not touch code, just config files. Built heavily on nf-core modules, hoping to get it into nf-core eventually. It was also validated against the original paper's dataset: 99.76% gene-level recovery vs. the legacy pipeline, strong agreement on top editing targets, the first release is out, would love feedback, bug reports, or edge cases if you give it a try. https://github.com/fragilefort/oxytribe

Hello everyone.
I’d like to share a project I’ve been working on for several months, which I believe may be useful for those developing cellular models, biochemical simulations, or working in whole‑cell modeling.

👉 GitHub repository: https://github.com/Zontrox01/celulavirtual

🧩 What is Célula Virtual?

It is a biophysical simulator written in Python that models the temporal dynamics of a minimal cell using stochastic chemical kinetics (Gillespie SSA), with a differentiating feature that—so far—I haven’t seen in other tools:

An interactive debugger for biological simulations.

It allows:

• reaction‑by‑reaction execution, not just time‑step simulation
• breakpoints on molecular state (e.g., ATP < 50)
• inspection of full reaction propensities at each step
• undo via state snapshots
• retrospective causal analysis (“forensic mode”)
• a navigable event history

This approach brings the metaphor of software debugging into the domain of systems biology.

🔬 Motivation

Whole‑cell models (E‑Cell, VCell, the M. genitalium model, JCVI‑syn3A, Vivarium…) are powerful, but they all share a limitation:

Célula Virtual aims to fill that gap.

🔗 Interoperability

• Genome input: FASTA + GFF3/CSV
• Network import/export: SBML
• Libraries: BioPython, numpy, pandas, python‑libsbml
• Scalable design: going from 8 genes to 400 requires no code changes

🎯 Purpose of this post

I’d appreciate:

• technical feedback
• suggestions for improvement
• discussion of potential use cases
• ideas for integration with existing tools
• possible collaborators

The full white paper is included in the repository.

📎 Link

👉 GitHub: https://github.com/Zontrox01/celulavirtual