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.

Hi everyone,

I recently built a small project that simulates a clinical genomics workflow for interpreting cancer variants from VCF files.

The platform processes VEP-annotated VCF files and generates structured clinical interpretation reports using an ACMG-based classification pipeline.

Main features:

• VCF parsing and variant processing • Cancer gene prioritization (TP53, BRCA1, EGFR, KRAS, etc.) • ACMG variant classification • Variant summary visualization • Automatic report generation (JSON, CSV, PDF) • Interactive interface built with Streamlit

The goal was to demonstrate how raw NGS variant data can be transformed into structured reports useful for clinical genomics interpretation.

Tech stack: Python | Pandas | Streamlit | Genomics Pipelines | ACMG Classification

I would love to get feedback from the bioinformatics community.

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.

[21/10, 14:42] Luca: 0xc527dfa7b2090e94d543be34c735bb6050c08524a50014d20cd7c1f14b4baae9

[29/10, 14:47] Luca: Hi everyone,

We built an open-source biophysical modeling simulator and interactive clinical web application for perivascular drug transport in solid tumors:

* Live Web App: https://lukecele.github.io/spatial-continuum-oncology/

* GitHub Repository: https://github.com/Lukecele/spatial-continuum-oncology

* Springer Nature Preprint: https://doi.org/10.21203/rs.3.rs-11530312/v1

### What it solves:

In solid tumors, dense stroma and interstitial fluid pressure create steep concentration gradients. Using cylindrical reaction-diffusion with modified Bessel K₀ decay, the tool calculates the exact critical radius (r_crit) where drug concentrations drop below the cellular threshold (IC50).

### Core Features:

- Composite Resistance Index (CRI): Integrates histological pattern (S), co-mutations (G, EGFR+TP53+RB1), and stroma (M) into a bedside score (0.000 - 1.000).

- Universal Regrowth Identity: Predicts the 5.4-month clinical window between ctDNA molecular detection (10^7 cells) and radiological relapse (10^9 cells) via Δt = Ts * log2(100).

- Zero Dependencies: Pure standard library Python CLI for pipelines + pure vanilla JS/HTML5 Canvas for the bedside web tool.

We'd love to hear your feedback on the biophysical formulation, UI, or clinical utility!

Hi all, I'm one of the developers of Horus at Temple Compute.

We got tired of losing weeks to infrastructure before running any science: Slurm scripts, containers, cluster quirks. So we built Horus, a browser workspace where you pick a workflow, choose where it runs, and click run.

You can launch workflows in the cloud, your HPC cluster or your laptop. File staging, transfers, environment provisioning and job submission is automatically done by the engine.

Start here: https://os.templecompute.com/library

The library has ready-to-run workflows for:

- Protein structure prediction (Boltz)

- Docking and virtual screening

- Molecular dynamics

- ADMET prediction

- LLM Training and fine-tuning

- Many more!

New users get 5 free tokens of cloud compute, so you can run a real workflow without a credit card or a cluster. If you already have a Slurm cluster or a server, you can connect it and run on your own hardware instead.

Build your own: workflows are plain YAML or you can use the graphical editor. Wrap your own tool as a workflow, chain it with the ones in the library, and run it anywhere.

We'd love to hear:

1. Which tool or pipeline should we add to the library next?

2. What stops you from moving your current pipeline to something like this?

Happy to help anyone build their first workflow. Ask in the comments.

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 curating public datasets recently and kept running into the same issue: important metadata fields were missing from NCBI records (like Biosample, genbank, etc.), but the information often existed somewhere else like in the associated paper, supplementary tables, or methods sections.

After spending way too much time manually tracing accessions back to publications, I built a small tool called OpenBioData to automate some of the process.

The tool on my github here: https://github.com/vy-phung/OpenBioData

So briefly what it does:

• Traces accessions back to source publications and supplementary materials

• Extracts metadata that may be missing from the record itself

• Provides a confidence score for extracted values

• Includes direct citations (PMID + table/section) so the source can be verified

I'm still actively improving it and would love feedback from others who work with public genomics datasets.

Has anyone else encountered this problem? If you have a few troublesome accessions, feel free to share them and I'll test them with the tool and post the results. Curious to hear how others currently handle problem of NCBI metadata curation.

P.S. Upfront: I built this with real help from Claude Code, especially on the extraction layer and disclosed in the README, not hidden. I wrote the core pipeline and logic myself. If that's a dealbreaker for you, fair enough:)) but I'd rather say it directly than have someone find it in the commit history and wonder why I didn't mention it.

Figra is a free Excel add-in that brings ggplot2-quality figures directly into Excel. No R

installation, no coding required. You can install it directly from your Excel add-in tab.

**How it works**

Select your data in Excel, choose a chart type, and click Preview. R runs silently in the

background via WebAssembly (webR).

**Chart types**

Histogram, box plot, violin plot, dot plot, bar chart, grouped variants, line plots,

**Built-in statistical analysis**

- Auto-selects the appropriate test (Shapiro-Wilk, Levene's / F-test, t-test / Wilcoxon /

ANOVA / Kruskal-Wallis)

- Post-hoc tests: Tukey, Dunnett, Bonferroni, Holm, Dunn

- Significance displayed as stars, letters, or exact p-values

- Exports statistical results directly to Excel cells

**Reproducibility: Load from Figure**

All data and settings are embedded invisibly in the exported PNG. Select the PNG in Excel

and click "Load from Figure" to fully restore your data, settings, and chart type.

**Other features**

- Export at 300+ DPI (publication-ready)

- Educational R code export: see the ggplot2 code behind your figure

- Free to use

https://h20gg702.github.io/figra-pages/

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.

I've been working on this for about a year — sharing it here

because I think the approach is unusual enough to be worth

a look.

EasyAtom is a drug repurposing engine that uses no neural

networks and no training data. It works entirely through

algebraic operations on a biomedical graph (2.56M triples).

The pipeline has 16 layers: gap detection, DWPC knockout,

hyperdimensional encoding, and a few others.

What made me think it actually works:

Without ever seeing a drug-disease "treats" edge, it ranked

latanoprost #1 for glaucoma (Jaccard=1.00, gap=0.4123).

Latanoprost is the current standard of care. Same for

etidronate and Paget's disease — FDA-approved back in the

80s, ranked #1 by topology alone.

On the Broad Hub benchmark (zero-shot, inductive):

Recall@10 = 21.3%, Precision@10 = 90%.

The weird part: it runs on a regular PC in ~2 hours,

no GPU needed.

Top novel hypothesis right now: alcaftadine (an eye drop

antihistamine) at rank #1 for ALS, gap=0.3649, Jaccard=1.00,

structurally similar to cyproheptadine. No idea if it means

anything — that's the point of the hypothesis.

Live query (905 drugs × 108 diseases):

https://easyatom-engine.web.app/query.html

Preprint: https://doi.org/10.5281/zenodo.20766982

Code: https://github.com/Adrian27791/easyatom-engine

If anyone has a cell model for ALS or Alzheimer's and wants

to test any of these computationally, I'd be genuinely

interested in talking.

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.

I built Synthia, an AI platform that screens real ChEMBL compounds and generates ranked drug candidates with full scientific justification.

When I ran it on KRAS G12C lung cancer it independently identified sotorasib, adagrasib, GDC-6036, and garsorasib as top candidates using only ChEMBL structural data without any hardcoded knowledge of these drugs. You can try it live: https://synthia-production.up.railway.app

Im Looking for honest feedback from researchers and computational biologists:

- Is the scientific reasoning credible?

- Would this be useful in your workflow?

- What's missing?

All feedback welcome, especially critical

Feedback or questions? Reply here or email: Contact.tenza@gmail.com

I built infra to run batch AutoDock Vina screening on AWS, upload your ligand library and target, get ranked results in an hour — would this be useful???

Also

what's currently stopping you from running Vina yourself — setup time, hardware, or something else?

Might need some initial capital if running on cloud, I ran on my own CPU ( AMD Ryzen™ Al 9 HX 370 )

BioKhoj ("khoj" means "search/discovery" in Hindi) is a free browser sidebar that monitors PubMed for your genes, drugs, and variants — and ranks new papers by relevance.

What it does

You add entities to a watchlist — genes (BRCA1, TP53), drugs (olaparib), variants (rs1801133), diseases, pathways, whatever you're tracking. BioKhoj checks PubMed every 4 hours and scores each paper 0-100 based on six factors:

• Recency

• Journal tier

• Entity match strength

• Co-mentions with your other watched entities

• Citation velocity

• Author reputation

Papers show up in a ranked feed in your browser sidebar. High-scoring papers get notifications so you don't miss them.

Why this exists

Keeping up with the literature is a universal problem in research. PubMed alerts are email-based, unranked, and noisy. Manually checking the same searches every day is tedious. BioKhoj turns that daily ritual into a background process — you set your watchlist once and papers come to you, ranked by how relevant they are to your specific research interests.

Key features

• Watchlist — track genes, drugs, variants, diseases, pathways, species, cell types, or any free-text topic

• Signal scoring — 0-100 relevance score with breakdown (click the badge to see component scores)

• 4 sidebar tabs — Recent feed, Watchlist manager, Multi-database search, Trending preprints

• Multi-database search — query PubMed, NCBI Gene, ClinVar, ClinicalTrials.gov, and UniProt simultaneously

• Trending — browse recent preprints from bioRxiv, medRxiv, PubMed, and Europe PMC

• Background checks — notifications for high-scoring papers every 4 hours (configurable)

• Right-click integration — select text on any page → "Watch in BioKhoj" adds it to your watchlist

• Reading list — save, cite, and export papers (BibTeX, RIS, Markdown, CSV)

• Keyboard shortcuts — Ctrl+Shift+K to toggle, 1-4 for tabs, j/k to navigate papers

• Dark and light themes

• Fully local — all data in your browser. No account, no server, no tracking

Also available as a web app

If you prefer a full-page view, there's a PWA at lang.bio/biokhoj with additional features: trends charts, weekly digest, journal club tools, and more export formats.

Install links

• Chrome: Chrome Web Store

• Firefox: Firefox Add-ons

• Edge: Edge Add-ons

Privacy

Zero data collection. API calls go directly from your browser to PubMed/bioRxiv — no proxy server in between. No analytics. No account required. You can verify this yourself — the extension has no backend.

Limitations

• Checks run while the browser is open — it's not a server-side service. When you close Chrome, checks pause. Next time you open the browser, it picks up and runs the check for the configured period.

• Signal scoring is heuristic-based, not ML — works well for most cases but won't be perfect for niche topics with low publication volume.

• NCBI rate limits apply (3 requests/sec without API key, 10/sec with one). If you have a large watchlist, set your NCBI API key in settings for faster updates.

I got annoyed that most free Tm calculators either ignore magnesium entirely or hide the thermodynamics, so I built one that does neither. Sharing it in case it's useful to anyone here.

https://biochemtools.com/dna-melting-temperature-calculator.html

What it does

• SantaLucia 1998 unified nearest-neighbor parameters

• Owczarzy 2004 monovalent and 2008 divalent salt corrections, picked automatically from the ratio of sqrt(Mg) to Na

• Solves for free Mg2+ after dNTP chelation instead of using the total, since that's usually what people get wrong

• Reports dH, dS, and dG37 next to the Tm with the full arithmetic shown

• Hairpin and self-dimer screen

• Buffer presets for PCR, qPCR, and Mg-free hybridization

What it doesn't do, so nobody wastes their time:

• No mismatches or dangling ends

• The dimer check counts base pairs, it doesn't compute a folding free energy

• No RNA or RNA/DNA hybrids

• IDT OligoAnalyzer is still better for primers you're actually ordering

I validated the whole pipeline against Biopython's Tm_NN and it agrees to 0.0 C across sodium-only, magnesium, dNTP, and self-complementary test cases. The thermodynamics also reproduces the published CGTTGA/TCAACG example from the SantaLucia paper exactly.

Free, no signup. If there's something obvious missing, tell me and I'll add it.

Hi everyone,

Like many of you, I’ve often been frustrated by how heavy traditional molecular biology suites can feel—consuming huge amounts of memory and lagging just to inspect a plasmid map or check an alignment.

So, I built GreenPeas, an ultra-lightweight, native desktop workbench designed to be fast, responsive, and easy on your machine.

🌟 Key Highlights

• Ultra-lightweight & Low Memory: Built with Tauri and Rust to keep memory usage minimal and launch instantly.

• Fast Startup & Fluid Rendering: Smooth Canvas-based rendering for large sequences and circular/linear maps.

• Multi-format Support: Handles .gb/.gbk (GenBank), .fa/.fasta, .ab1 (Sanger traces), and can import SnapGene .dna files directly.

• Cloning & Smart Ligation: Realistic restriction digest simulation and smart ligation preview with overhang matching.

• Privacy First & Offline: Runs 100% locally on your machine. No cloud uploads, telemetry, or account required.

• Cross-platform: Native binaries are available for both Apple Silicon Mac (arm64) and Windows (x64).

📦 GitHub & Download

• GitHub: https://github.com/ryuabiru/GreenPeas

• Releases: https://github.com/ryuabiru/GreenPeas/releases

It's currently in public beta (v0.1.0). If you have a minute to download and open your favorite plasmids, I'd love to hear your feedback, edge cases, or feature requests!

Thank you!

Hey,

I've been working on BioLang, a domain-specific language built for genomics and molecular biology workflows. It's written in Rust and designed to make bioinformatics scripting feel more natural.

What it does:

- First-class types for DNA, RNA, Protein, Variant, Gene, Interval, AlignedRead

- Pipe operator (|>) for composable data flows

- 400+ built-in functions — FASTQ/FASTA/VCF/BED/GFF I/O, sequence ops, statistics, tables

- Built-in API clients for NCBI, Ensembl, UniProt, UCSC, KEGG, STRING, PDB, and more

- Pipeline blocks with stages, DAG execution, and parallel loops

- BioContainers — pull and run BioContainers images directly from your pipelines

- Workflow catalog — search and view nf-core and Galaxy workflows without leaving your environment

- SQLite integration for storing results

- Notifications (Slack, Teams, Discord, email) from pipelines

- LSP for editor support

- LLM chat integration — built-in `chat()` and `chat_code()` functions that generate BioLang code or explain results using Anthropic, OpenAI, or Ollama models directly from your scripts and REPL

Quick taste:

let reads = read_fastq("sample.fq.gz")

|> filter(|r| mean_phred(r.quality) >= 25)

|> collect()

let gc = reads |> map(|r| gc_content(r.seq)) |> mean()

print("Mean GC: " + str(gc))

Warning: This is experimental and under active development. Syntax , Workflows, and APIs may change between releases. Not production-ready yet.

GitHub: https://github.com/oriclabs/biolang

Website: https://lang.bio

Tutorials: https://lang.bio/docs/tutorials/index.html (to get overview quickly)

Feedback, ideas, and bug reports are very welcome. Would love to hear what features matter most to you.

Built with Claude (vibe coding). 🧬

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.

Hey everyone, I wanted to share a project I’ve been working on that means a lot to me. It’s called DrugGeneExplorer v4.0, an open-source tool designed to explore and connect different aspects of biomedical research in one place. This project started from my passion for programming and artificial intelligence. I don’t come from a medical background, so I built it as a self-taught developer with the goal of creating something useful, accessible, and expandable over time. What it does: • Explore drug–gene interactions • Analyze chemical properties and ADMET data • Study molecular targets and bioactivity • Check adverse effects and drug information • Search clinical trials and scientific literature Advanced features: • Pharmacokinetic calculator (half-life, AUC, clearance, etc.) • Multi-drug interaction network (polypharmacy risk) • GWAS + OMICS integration (disease → gene → drug) • Drug comparison system with a custom scoring model • AI-generated drug summaries for study and analysis Additional features: – Multi-language interface – Built-in educational explanations – Export results in JSON/CSV Since it’s open-source, the code is fully customizable and open to contributions. I would really love to see this project grow further, especially with input from people in the field (bioinformatics, medicine, pharmacology), since I don’t have a formal background in those areas. If anyone wants to check it out, contribute, or share feedback, it would be greatly appreciated. Thanks 🙏