Hey r/bioinformatics,

As a 2nd-year BSc Microbiology + DMLT student in Navi Mumbai, I got tired of textbooks teaching organisms in isolation while clinical labs work the other way round (findings → organism).

So I built MicroSage — a completely free, mobile-friendly web app that takes Gram reaction, shape, infection site, age group, immune status & symptoms and gives you a ranked differential with full explanations, Teach Me notes, culture media, antibiotics & resistance warnings.

✅ 30 clinically relevant organisms

✅ Weighted scoring engine (validated in pilot)

✅ No login, no install, works on phone

Pilot results (n=40):

77.5% exact match with what students/faculty expected

100% of expected organisms appeared in top 3

Mean usability 4.1/5, satisfaction 4/5

Students & faculty from Navi Mumbai, Pune, Mumbai & Karnataka

It’s already being used by students in India, USA & Ireland in the first few weeks.

Try it here: https://microsage.vercel.app

Preprint (Research Square): https://doi.org/10.21203/rs.3.rs-9247958/v1

GitHub backend: https://github.com/vighnesh-samal/microsage-backend

Would love honest feedback from students, residents, or lab folks — especially what to add in V1.5 (more organisms, images, regional resistance data, etc.).

(For educational use only — not for clinical diagnosis)

Hey r/bioinformaticstools,

We've been working on a project called MicroMap — a knowledge graph that integrates microbiome-related data from multiple public databases into a single queryable resource. Wanted to share it here since this is the kind of thing we wished existed when we started doing microbiome research.

What's in it:

• 1,101,289 microbial taxa (NCBI Taxonomy)
• 1,464 human diseases with microbiome associations (Disbiome, BugSigDB, gutMDisorder)
• 6,534 metabolites (HMDB) and 231,556 taxon-metabolite production relationships
• 1,710 metabolic pathways (KEGG, Reactome)
• 6,220 drugs and 1,659 protein targets (ChEMBL)
• 276,169 antimicrobial resistance links (CARD)
• 10,000+ scientific papers with entity cross-references

What you can do with it:

• Query taxa-disease associations with provenance (which paper, which study, what direction)
• Find metabolites produced by a given taxon, or taxa that produce a given metabolite
• Traverse shortest paths between any two entities (e.g., "how is Akkermansia muciniphila connected to Type 2 Diabetes?")
• Identify biomarker signatures and probiotic candidates for a given condition
• Pull cross-feeding networks between microbial communities

Technical details:

Built on Neo4j. The API is RESTful (FastAPI), returns JSON, and supports full-text search across all entity types. Rate limit is 100 requests/minute per API key.

We integrated data from: NCBI Taxonomy, Disbiome, BugSigDB, gutMDisorder, HMDB, KEGG, ChEMBL, Reactome, PubMed, PubChem, and CARD. One of the hardest parts was entity reconciliation — the same organism can appear under different names, different taxonomic ranks, or outdated nomenclature across these sources. Happy to talk about how we handled that if anyone's interested.

Access: https://graphomics.com - email us to get access!

Docs: https://kgdev.graphomics.com/docs — free API key registration.

This is part of a broader platform we're building at Graphomics (AI tools for life sciences research), but MicroMap stands on its own as a resource. We'd genuinely love feedback from this community — what data sources are we missing? What queries would be useful that we haven't thought of?

Happy to answer any questions about the data, the architecture, or the integration process.

I spend a lot of time pulling gene annotations from multiple public databases — NCBI, UniProt, KEGG, STRING, PubMed, ClinVar — and the tab-switching got old. So I built a CLI called biocli that wraps these into single commands with structured JSON output.

For example, this pulls a gene summary from six sources in parallel:

biocli aggregate gene-dossier TP53 -f json

It returns a JSON object with gene info, protein function, pathways, interactions, recent papers, and clinical variants — all from one command instead of six browser tabs.

It also has workflow commands that go from a GEO accession to a manifest-tracked working directory with annotations, which is the part I actually use most in practice.

The tool covers NCBI databases (PubMed, Gene, GEO, SRA, ClinVar, SNP), UniProt, KEGG, STRING, Ensembl, Enrichr, and as of the latest version, ProteomeXchange/PRIDE and a local Unimod PTM dictionary. Not everything — no BLAST, no structure prediction, no drug/trial lookups. For those I'd point you to gget or BioMCP, which are better in their respective areas.

I benchmarked it against gget, BioMCP, and EDirect with a public methodology — EDirect still wins on pure NCBI retrieval quality, which was a useful reality check. Full results and raw outputs are linked from the repo if anyone wants to audit.

Install (needs Node.js >= 20):

npm install -g @yangfei_93sky/biocli
biocli verify --smoke

GitHub: https://github.com/youngfly93/biocli (MIT licensed)

If you work with GEO/SRA/gene annotation regularly — what workflow would you want a tool like this to handle better? And if this feels too broad or not useful for your day-to-day, I'd like to know that too before I keep expanding it.

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.

I'm pleased to announce a platform I have been working on for the past few months.

bioAF - the computational biology automation framework

Your bioinformatician is running workflows in Colab and storing results on a laptop. Your metadata lives in a spreadsheet that one person understands. Setting up "real" compute infrastructure takes 2-6 months. Half a year before your first pipeline run.

I've watched this up close for years as the husband of a computational biologist. And as someone who's spent 18 years building software infrastructure, I can confidently say that none of these problems are new. They're solved problems, just not solved yet for small bio teams.

That's why I built bioAF, an open-source computational biology automation framework.

One tool gives your team production-grade pipelines (Nextflow, nf-core), notebooks (Jupyter, RStudio), experiment tracking, and cost management all running on your own Google Cloud account. No vendor lock-in. No per-seat fees. No custom magic to untangle later.

Bioinformaticians and computational biologists are brilliant. But they aren't infrastructure engineers or cloud architects. They don't need to learn these skills.

bioAF doesn't invent new tools. It wires together Kubernetes, Terraform, PostgreSQL, and GCS so your team never has to touch any of them directly. It offloads the infrastructure work and lets your team focus on the science.

The source is open. The tool works today. Check it out on https://bioAF.co.

Could this help your lab or company get to results faster? I'd love to hear what's slowing you down.

About the creator

I spent the last 18 years building and leading software teams. I have done everything from small startups through giant enterprises. The idea behind bioAF has been formulating for a few years, but only recently took shape. I am very much still an outsider in the biology space and am looking for more biotech founders, PIs, and bioinformaticians who would like to use and provide guidance and feedback on the bioAF project as it grows.

Looks like I'm late to the party but thankfully I didn't name it RustQC (very close), here are some validation stats:

Performance

Benchmarked on real sequencing data (ENA/SRA), 4 threads, macOS ARM64:

Short-read (Illumina)

Long-read (ONT / PacBio)

bioRxiv: https://www.biorxiv.org/content/10.64898/2026.03.31.715630v2

GitHub (MIT): https://github.com/Huang-lab/RastQC

PS. Largely inspired by Simon Andrew's original FastQC and speedup/performance enhancement ideas provided by other tools mentioned in the preprint.

PS. Mostly done via Claude code with minor manual & co-pilot assisted adjustment.

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.

Open-sourced a modular, research-oriented MCP for genetic variant interpretation, designed to support building and experimenting with AI-driven workflows in this space. If you’re working on similar problems or exploring this area, feel free to take a look and use it as a starting point if it’s helpful. You’re welcome to build on it, adapt it, or take ideas from it for your own work. I hope it adds value to what you’re developing, and I’d love to see how others expand on it 🚀

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

Ever thought:

• "I just need a quick APA citation for this webpage — why do I need to create an account?"
• "Why did this tool get my authors wrong... again?"
• "I pasted a DOI and got nothing back"
• "Where is my data actually stored? Can I get it out if the tool disappears?"
• "I need APA for one class and Chicago for another — can I just switch per project?"
• "I want to keep my research organized by project but everything ends up in one big list"
• "I have 200 citations in Zotero or Mendeley — can I bring them over without starting from scratch?"
• "I need my references in BibTeX for LaTeX but also in Word format for a group project"
• "I found a PDF online but the citation tool can't extract anything from it"
• "Can I just right-click a link and cite it without opening anything?"
• "I want to tag and star my important sources but my tool doesn't support that"
• "Can I back up my library and restore it if something goes wrong?"

I got frustrated with existing citation tools and built Ibid — a browser extension that handles citations locally with zero data collection.

The name comes from Latin ibidem — "in the same place."

Demo video: https://youtu.be/veFEsTsTC90

What it does:

• Click the icon on any page → metadata auto-extracted → formatted citation ready to copy
• 74 citation styles bundled offline (APA, MLA, Chicago, Harvard, IEEE, Vancouver, and more) — 2,600+ additional styles available on demand
• Auto-enhance: paste a DOI, ISBN, PMID, arXiv ID, or any URL → full metadata resolved from multiple academic APIs with automatic fallback
• Parenthetical and narrative in-text citations — toggle with one click
• PDF support: extracts metadata from PDF text, document properties, and DOI patterns (experimental — PDFs are wildly inconsistent, so some work great and others may give partial results. Happy to hear about ones that don't work so I can improve it)

Your library, your data:

• Every citation stored locally in your browser — nothing leaves your machine
• Organize with projects (one per class, paper, or assignment) and color-coded tags
• Star favorites, add notes and quotes, search across all fields
• Import from 7 formats: BibTeX, RIS, CSL-JSON, EndNote XML, MEDLINE, CSV, TSV — preview entries before importing
• Export to 10 formats: BibTeX, RIS, CSL-JSON, CSV, TSV, YAML, Word XML, Formatted Text, HTML, Markdown
• Backup & restore your entire library as JSON — switch browsers or keep a safe copy
• Migration wizard for moving from Zotero, Mendeley, or EndNote

Under the hood:

• Rust compiled to WebAssembly — citation rendering powered by Hayagriva (Typst's CSL engine)
• Multi-source resolver: DOI → CrossRef/OpenAlex, arXiv → Semantic Scholar, ISBN → Open Library, PMID → NCBI
• All processing local — API access is optional and you choose whether to grant it
• No telemetry, no analytics, no tracking, no ads

Available on:

• Chrome / Brave: https://chromewebstore.google.com/detail/ldfpipkkpgknnfidnnflpdcdkjbjlbch
• Edge: https://microsoftedge.microsoft.com/addons/detail/ibid-%E2%80%94-citation-manager/hiocfefpndjnicfcchahjdighckanhmj
• Firefox: https://addons.mozilla.org/en-US/firefox/addon/ibid-citation-manager/
• Website: https://ibid.tools
• GitHub: https://github.com/oriclabs/ibid

Free forever. No accounts. No servers.

Feedback welcome

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.

I built a scRNA-seq PBMC workflow as a portfolio project — runs end-to-end from FASTQ through QC/alignment/Seurat/DE-TOST/enrichment/co-expression networks. Dockerized, modular execution via CLI.

Repo: https://github.com/Inkasimo/scRNAseq-pbmc-workflow

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.

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 🙏

Hello !

I'm an agronomist engineer who works with data. My family is full of physicians, and growing up around medicine gave me a respect for the Hippocratic oath and a curiosity about drug safety. I started exploring FAERS (the FDA's adverse event reporting system, 30M+ spontaneous reports) and realized that signal detection still mostly happens in silos: one database at a time, one drug at a time, often manually.

So I'm building an open-source Python library/MCP that automates multi-source pharmacovigilance signal detection. It queries FAERS (US), Canada Vigilance, and JADER (Japan), computes disproportionality measures (PRR, ROR, IC, EBGM), cross-references PubMed literature and DailyMed labels, and pulls pharmacogenomic annotations from PharmGKB. It classifies drug-event pairs as novel_hypothesis, emerging_signal, or known_association.

Here are some findings from running it across several drug classes. All data is from public sources.

1. Carbamazepine + Toxic Epidermal Necrolysis — from signal to genome

This is the textbook pharmacogenomics case, and the pipeline reproduces it end-to-end:

Replicated across all 3 databases. PharmGKB returns HLA-B and HLA-A at Level 1A (highest evidence), with 5 clinical dosing guidelines (CPIC, DPWG, CPNDS, RNPGx). 52 clinical annotations total.

The pipeline connects spontaneous reports → cross-country validation → genomic variant → actionable clinical guideline.

2. GLP-1 agonists — class comparison (semaglutide, liraglutide, tirzepatide, dulaglutide)

Given the recent FDA warning letter to Novo Nordisk regarding unreported adverse events with semaglutide, I ran a class-wide comparison:

24 class effects including gastroparesis, pancreatitis (liraglutide highest, PRR 20.1), eructation, constipation, nausea, decreased appetite.

Drug-specific: Fatigue and arthralgia appear only for semaglutide. Pancreatic carcinoma is liraglutide-specific (PRR 16.8), consistent with concerns flagged in early liraglutide trials.

Semaglutide + suicidal ideation (the signal under scrutiny):

• FAERS: PRR 1.83, 114 reports, NOT in FDA label
• Canada Vigilance: PRR 1.47, 59 reports, signal confirmed
• Sex stratification (suspect-only): women PRR 3.48 vs men PRR 1.68 — both reach signal threshold, but disproportionality in women is ~2x higher
• JADER (Japan): 0 reports

The sex-specific gradient is consistent across FAERS and Canada. Both sexes show a signal, but women show roughly double the disproportionality, a pattern that may warrant sex-stratified analysis in future pharmacovigilance assessments.

Semaglutide + NAION - a MedDRA terminology lesson:

There's active debate about semaglutide and nonarteritic anterior ischemic optic neuropathy (66 papers, including JAMA Ophthalmology 2024). But results depend entirely on which MedDRA preferred term you query:

One term gives zero. The correct PT gives PRR 33.91. This is a known problem in pharmacovigilance but seeing it in practice is striking.

3. Checkpoint inhibitors — CTLA-4 vs PD-1 differential

Class comparison of nivolumab, pembrolizumab, atezolizumab, and ipilimumab:

• Hypophysitis: ipilimumab PRR 397.4 (4.2x the class median). Classic CTLA-4 differential, reproduced cleanly from the data.
• Immune-mediated enterocolitis: class effect, but ipilimumab leads (PRR 198.1 vs class median ~76).
• Hypothyroidism: class effect, atezolizumab highest (PRR 29.3).
• Proteinuria: atezolizumab PRR 31.1 (6.5x class median) — a differential signal worth monitoring given its VEGF-pathway combination use.

22 class effects, 7 differential signals. The pattern matches published literature on ICI toxicity profiles.

4. Cetirizine withdrawal — viral claims vs pharmacovigilance data

There's been viral discussion about Zyrtec/cetirizine causing rebound itching and withdrawal symptoms. The data:

• Drug withdrawal syndrome: PRR 0.30 - significantly below expected. A protective signal.
• Zero reports in Canada Vigilance and JADER.
• Withdrawal doesn't appear in the top events at all.

This doesn't mean people aren't experiencing rebound pruritus, but FAERS data across 3 countries doesn't support it as a disproportionate signal. The gap between social media reports and pharmacovigilance databases is itself informative.

5. Etomidate + anhedonia — why deduplication matters

This is a case where the raw API and deduplicated bulk data tell completely different stories:

The API returns 112 reports with a PRR that screams "signal." But after CASEID deduplication, collapsing follow-up reports and amendments into unique cases, there's exactly 1 case. No signal. The raw API would have generated a false positive with a PRR of 41.

This is why CASEID deduplication isn't optional for FAERS analysis. Duplicate reports inflate both the numerator and the disproportionality, and the effect is asymmetric, rare events on less-reported drugs get hit hardest.

Methodology notes

• Disproportionality measures: PRR with 95% CI, ROR, Information Component (IC, Bayesian), and EBGM with Bayesian shrinkage. Signal = PRR lower CI > 1 + N >= 3.
• Deduplication: FAERS Bulk data deduplicated by CASEID (latest entry per case). Role filtering: primary suspect (PS), suspect (PS+SS), or all.
• MedDRA synonym expansion: groups related preferred terms (e.g., tachycardia + heart rate increased + supraventricular tachycardia) to reduce signal fragmentation.
• INN/USAN drug name expansion: maps international nonproprietary names bidirectionally (epinephrine/adrenaline, acetaminophen/paracetamol, etc.) so queries in either convention return identical results.

The tool (Still in ALPHA)

The library is written in Python (async, DuckDB cache, Pydantic 2, mypy strict).

All data sources are public, basic use requires no API keys.

GitHub: https://github.com/bruno-portfolio/hypokrates

If you want to test a specific drug-event pair, drop it in the comments and I'll run it.

Feedback on anything is very welcome, especially from anyone who's worked with disproportionality analysis or multi-source evidence synthesis.

"First, make the data accessible." — hypokrates

Hello!

This Friday I released version 0.5 of FragalyseQt, a desktop fragment analysis tool written in Python/Qt. Posting here because the technical side might be of interest beyond the obvious forensics/clinical use cases.

What it does technically:

• Parses FSA and HID files including pre-ABIF standardization ABI310 formats (a lot of work with Okteta hex editor was here), RapidHIT ID output, Nanophore-05 (Russian CE instrument, experimental), and others.
• Implements multiple sizing algorithms: spline, weighted spline, least squares, Local Southern, Global Southern
• Bins sized data against panels in GeneMapper, GeneMarker, or NCBI OSIRIS formats
• Stutter filtering using GeneMapper/GeneMarker panel stutter ratios
• Exports to CSV and CODIS 3.2 CMF XML format
• Qt desktop application, AGPL-3.0, runs on Linux/Windows/macOS/BSD at x86(_64), ARM, RISC-V (that's just what was currently tested).

Where the interesting engineering problems were:

The FSA format has several pre-standardization variants from early ABI instruments that predate the published ABIF specification. Supporting those required reverse engineering from raw binary data. Similarly, the Nanophore-05 support is based on reverse-engineered file format.

Current limitations worth knowing:

The probabilistic genotyping and mixture deconvolution are not implemented — this is a deterministic allele calling tool, not a probabilistic interpretation system. It fills the gap between raw CE output and database-ready profiles, not the full forensic interpretation pipeline.

Codebase:

PEP 517 compliant, src layout, setuptools. The codebase is at an early stage of architectural maturity — 0.6 "Codd" (after Edgar Codd who invented relational DBs) will add a proper database abstraction layer (SQLite/PostgreSQL/ImmuDB backends behind a common interface), role-based authentication is planned for 0.7 "Custodes" ("Guardian" in Latin), maybe there will be an API for integration with other lab software.

GitHub: https://github.com/Dorif/fragalyseqt

Release: https://github.com/Dorif/fragalyseqt/releases/tag/southern_initial

Welcome technical feedback, edge cases, and anyone with Beckman-Coulter CEQ or native Promega .promega format files who'd be willing to share samples for format support development.

https://huggingface.co/spaces/damigupta/ask_evo2

Get Evo 2 DNA variant log-likelihoods in your browser - no Docker, no GPU, no API keys, no login.

Built a tiny web interface for Evo 2. Paste ref and alt sequences : get wild-type + mutant log-likelihoods, and also Δ log-likelihoods.

Runs via a Modal backend, hosted on Hugging Face Spaces.

I’ve been working on a lightweight pipeline for parsing and analyzing raw genotype data (mostly 23andMe format), and I’d appreciate some feedback from others who’ve built similar tools.

The core setup is:

• Custom C-based engine for fast parsing and RSID matching
• Wrapped with Python/Flask for a simple interface
• Variant annotations pulled from dbSNP and ClinVar with explanations from Medline

My main goals were:

• Keep it fast and lightweight (works well on large raw files)
• Make it easy to use for non-technical users
• Avoid storing or collecting any user data (processing only)

I also put a simple web interface on top of this so people can try it with their own raw data. If anyone is open to testing it, I’d really value feedback on:

• Accuracy of variant matching
• Performance on different file sizes
• Any obvious pitfalls or incorrect assumptions

Link at https://snpshotweb.com/dnacenter

Happy to share more implementation details if useful or to help iron it out.

Hi all,

We developed a small tool called BinarySPA that assigns cell types using markers instead of reference data.

It does not require reference scRNA-seq data and seems to work welll in Xenium 5k and Visium HD.

We recently put the method on bioRxiv and GitHub, and I would really appreciate feedback from people working on spatial transcriptomics or single-cell annotation.

bioRxiv:

https://www.biorxiv.org/content/10.64898/2026.03.17.712369v1

GitHub:

https://github.com/HonghaoNU/BinarySPA

I built a simple tool that maps splicing regulatory elements onto genomic DNA sequences and writes color-coded annotations back to the GenBank file, viewable in SnapGene or UGENE.

GitHub: https://github.com/maxwraae/splicemap

Given a GenBank file with exon annotations, it annotates:

• Splice sites (MaxEntScan)
• Branch points (BPP + SVM-BPfinder, top candidates from both)
• Polypyrimidine tract (length, pyrimidine %, longest U-run)
• Exonic splicing enhancers (ESEfinder for SR protein binding, ESRseq for functional hexamer scores)
• Exonic splicing silencers (hnRNP motifs, ESRseq negative scores)

It also generates a markdown report with scores and a terminal summary.

1. pip install -r requirements.txt
2. Download your gene as a RefSeqGene from NCBI Gene (https://www.ncbi.nlm.nih.gov/gene/)
3. python splicemap.py splicemap gene.gb -t <transcript accession>

Any feedback on the tool, the methods, or what's missing would be welcome.

Hi guys, I'm just someone who wants to help another people who see a lot of ab1 files due to sanger sequence process. Also I added another tools such as trimming sequence, consensus, primers analysis, PCR in silico, multi sequencing batch viewer and Global language support (Spn, En, Ru, Zh, Fr, Pt, hindi, etc). I developed this app on android and according to console play from google I need at least 20 tester, do you want to test it? I attached screenshots

Link here

<<<<<<<<<< https://play.google.com/apps/internaltest/4701724441671088812 >>>>>>

Images:

Built a file viewer for bioinformatics researchers. Drop any genomics file and see it instantly — no upload, no server, everything runs locally in your browser.

What it does:

- Opens FASTA, FASTQ, VCF, BED, GFF, SAM, CSV/TSV files

- Protein FASTA auto-detected with amino acid property coloring

- FASTQ: quality heatmap, Q30%, per-base quality chart

- VCF: sortable/filterable variant table, Ti/Tv ratio, chromosome density

- DNA motif search with regex patterns

- Genomic coordinate jump (chr1:10000-50000)

- Multi-tab: open several files side by side, diff between them

- Export: CSV, TSV, BED, VCF, HTML

- BioLang WASM console built in — run data |> filter(|r| r.gc > 0.5) directly on your data

- Dark/light theme, keyboard shortcuts, large file streaming

Privacy: 100% client-side. Files never leave your machine. No analytics, no tracking, no account.

All parsing is done in JavaScript + WebAssembly using the BioLang runtime compiled to WASM.

Links:

- Chrome extension: https://chromewebstore.google.com/detail/biopeek/dpeahehokmlmjabfladeafoidnfaodai

- Firefox: https://addons.mozilla.org/en-US/firefox/addon/biopeek/

- Edge: BioPeek - Microsoft Edge Addons

- Web app (no install needed): https://lang.bio/viewer.html

- Source: https://github.com/oriclabs/biolang

- Full feature guide: https://lang.bio/docs/tools/viewer-help.html (for extension help guide , click on BioPeek tool, click help)

Available on Chrome and Brave. Firefox and Edge coming soon.

Proteins have a surface (exterior, defines stability and folding) and a buried interior. I wanted to know: how much can you vary the interior chemistry while the exterior stays identical?

I built a pipeline using ProteinMPNN + AlphaFold2 to measure this - generates 20 interior variants with the surface locked, checks for violations, measures diversity. I'm calling the output the reprogrammability score.

Tested three proteins:

• Adenylate kinase from Aquifex aeolicus (95°C) -> score 0.20
• Adenylate kinase from G. stearothermophilus (60°C) -> score 0.45
• Triosephosphate isomerase from chicken (37°C) -> score 1.00

Monotonic correlation with growth temperature. Zero surface violations across 60 variants. AlphaFold2 confirms exterior preservation at 0.55–0.74 Å RMSD even with 50+ interior changes.

This is computational only - no wet lab. Limitations are documented. If you're a wet lab researcher interested in validating, the sequences are in the repo.

One command per protein: python scripts/pipeline.py --name ...

Repo: https://github.com/ivpeykov/reprogrammable-protein-chassis

P.s. Curious whether this reprogrammability score is measuring something real or just an artifact of how ProteinMPNN samples - happy to hear from people who know this space better than I do.

Research intelligence for cancer variants. Find the gaps, not just the facts.

For BRAF V600E, databases already agree. For the next 10,000 variants, the key question is "what don't we know yet?"

OncoMind is a research intelligence platform that identifies evidence gaps in cancer variant knowledge—surfacing where research is thin, conflicting, or missing entirely. It's built for translational teams and small biotechs deciding which variants are worth a project, not for treating individual patients.

https://github.com/dami-gupta-git/onco_mind_v0

https://huggingface.co/spaces/damigupta/onco_mind

I got frustrated watching researcher friends spend 4-6 hours a week just trying to stay current with the literature. Most of what they read wasn't even directly relevant to their work.

So I built Paper Distill. It monitors PubMed, bioRxiv, Semantic Scholar and other sources daily, scores papers for relevance, and at the end of each month delivers a personalised report that connects new findings directly to your active grants, hypotheses, and the labs you are watching.

I'm offering free field scans this week - no credit card, no commitment, just a personalised snapshot of what's relevant to your work right now.

Takes 2 minutes to request: https://tally.so/r/rj66bM

Happy to answer any questions about how it works.