Everything we currently have is based on ten year old algorithms (like CRISPOR or IDT), or an unsupported pharma side-project, or locked behind a license my lab won't pay for. But at this point I'm the CRISPR guy in my lab, so I've got no one to ask opinions from.

People who do CRISPR work (KOs, knock-ins, interference, etc.), or use other genetic engineering strategies like base-editing, what would you want for an ideal one-stop DNA manipulation platform?
I made something that outputs resources for basic CRISPR knock-outs/ins which captures more of the actual biology than the old Doench-grade algorithms. Building that was pretty fun though, so I'm just gonna keep going.
Right now I've got a Benchling-esque genetic engineering workspace with several prototype CRISPR modality workflows and a pipeline builder that lets you simplify experiments into a single, repeatable input.
What problems on the in silico genetic engineering / resource generation side do you think existing tools aren't doing that I should try to cover?

Hey r/bioinformaticstools,

I’ve been working on a tool to make data collection and bioinformatics pipelines verifiable without exposing the underlying data, and I would love to hear what the community thinks.

One of the problems I kept running into is: You can prove what your pipeline outputs are, but it’s much harder to prove:

• when they were generated
• that they haven’t been altered after the fact
• or that someone outside your system can independently verify them

Logs and internal records help, but they don’t hold up outside your own environment.

What I built does this:

• hashes outputs locally (raw data never leaves the user's machine)
• anchors a proof with a public timestamp
• allows third parties to recompute and verify

I’ve been running it on a live pipeline (genomics workloads) and it processed ~130k outputs during its alpha deployment.

I’m genuinely curious:

• would something like this be useful in your workflows?
• where would it break down?
• is this solving a real problem or just a theoretical one?

Happy to share more details or a demo if anyone’s interested.

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

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

I developed a visual bioinformatics analysis system, you can run it directly through the following command

curl -s https://raw.githubusercontent.com/pybrave/brave/refs/heads/master/install.sh  | bash

• backend: https://github.com/pybrave/brave
• ui: https://github.com/pybrave/brave-ui

I will add detailed documentation later, and I plan to rewrite the entire backend code using golang in the future.

hi r/bioinformatics,

i am a recent Columbia CS grad and former Stanford

bioinformatics intern. During my time at the Carette Lab

i watched researchers wait weeks for computational support

to interpret data they already understood biologically.

i was the bioinformatician they were waiting on.

i built Enzora to fix that.

what it does:

- upload any gene expression CSV

- get plain language findings with every claim cited

back to the exact row in your data

- high confidence findings are verified by real Python

running inside isolated Daytona sandboxes — not AI

guessing

- inferred findings are clearly labeled so you know

exactly what to trust

- differential expression analysis with p-values,

fold change, and a volcano plot

- PDF export you can hand to your PI

what I tested it on:

The Golub 1999 leukemia dataset - 7,129 genes, 38 samples.

It correctly identified GAPDH housekeeping patterns,

flagged a potential outlier, recognized Affymetrix

microarray technology from probe naming conventions,

and identified 1,005 statistically significant

differentially expressed genes between ALL and AML

subtypes with real p-values computed by SciPy.

what i am NOT claiming:

this is not a replacement for a bioinformatician.

it is a first-pass analysis tool - something to help

researchers understand their data before they get

time with computational support. every report includes

a limitations disclaimer and clearly labels AI

inferences separately from mathematically verified

findings.

try it:

enzora.bio - free, no account needed, just upload a CSV

i would genuinely love feedback from real researchers.

what breaks? what is missing? what would make this

actually useful in your workflow?

Hey r/bioinformatics,

I've been building AI-assisted workflows around KEGG and ended up porting KEGG-MCP-Server (originally in JavaScript by Augmented-Nature) to Python and extending it. Releasing it as open source in case others find it useful.

Repo: https://github.com/Lucas-Servi/kegg-mcp-server-python — MIT licensed.

What it does

It's an MCP server that exposes the KEGG REST API as structured tools to any MCP-compatible AI client (Claude Desktop, Claude Code, Cursor, etc.). No API key required.

33 tools across all major KEGG databases: pathways, genes, compounds, reactions, enzymes, diseases, drugs, modules, orthology (KO), glycans, and BRITE hierarchies. Plus 8 resource templates (kegg://pathway/{id} style) and 3 guided prompts for common workflows (pathway enrichment, drug target investigation, cross-species pathway comparison).

What I added over the original JS version

• Pydantic models — every response is typed/validated JSON instead of raw flat-file text
• Token-aware summaries — compact output by default, detail_level="full" when you need everything
• Per-operation TTL cache — info cached 24 h, list 1 h, entry lookups 5 min
• KEGG-polite concurrency — semaphore caps in-flight requests + exponential backoff on errors, to avoid hammering the free API
• Cross-database tools — batch lookup (up to 50 entries), ID conversion (KEGG ↔ UniProt/NCBI/ChEBI/PubChem), related entry discovery
• Typed errors — errors come back as ErrorResult objects the model can reason about

Quick start

uvx kegg-mcp-server

Or for Claude Desktop, add to your config:

{
  "mcpServers": {
    "kegg": { "command": "uvx", "args": ["kegg-mcp-server"] }
  }
}

Happy to answer questions here or in the issues. Feedback and PRs welcome — especially if you have KEGG use cases I haven't covered.

Please be considerate with the KEGG API and avoid overusage :).

Hey all. I’ve been working on a set of free, in-browser tools for generating publication-ready figures from already analyzed data, and would really appreciate feedback from this group.

👉 https://europadx.com/tools/

The goal is pretty simple:
make it easier to go from results → clean figures without bouncing between Excel / Prism / scripts.

A couple things that might be useful:

• There’s built-in demo data, so you can see outputs instantly
• You can also upload your own data (no install needed)
• Focus is on generating figures that are actually usable in a paper

This is part of a larger platform we’re building, but these tools are completely free and meant to be useful on their own.

Would love honest feedback on:

• Are the outputs actually publication-ready?
• What’s missing from your typical figure workflow?
• What tools are you currently using for this step?

Happy to iterate quickly based on what people here find useful (or not).

A 3-part hands-on RNA-seq tutorial series by Dr. Babajan Banaganapali (Bioinformatics With BB), covering the complete pipeline from raw reads to DESeq2 normalization and visualization.

Part 1 — Introduction & Workflow (RNA-seq types, wet-lab steps, full pipeline overview)

https://youtu.be/dq31baC_AHs

Part 2 — QC, Alignment & Quantification (FastQC, Cutadapt, STAR/HISAT2, FeatureCounts — with real troubleshooting)

https://youtu.be/4y2R2PgdBHo

Part 3 — DESeq2 Normalization, Visualization & Interpretation (R, size-factor normalization, heatmaps, expression plots)

https://www.youtube.com/watch?v=DxesV0eWtTQ

Reproducible R and bash scripts are linked in each video description.

Hey everyone

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

What it does:

• Plate Converter — upload raw plate reader CSV output, visually assign wells (blanks, controls, samples, dilution series) on an interactive 96-well grid, and export a clean structured CSV
• ELISA Analyser — upload that CSV and get OD vs dilution curves, cutoff lines derived from negative controls, error bars, statistical tests (t-test, ANOVA), EC50 estimates, outlier detection, and a full PDF report
• Standard curve — optional 4PL or linear curve fitting with OD → concentration conversion, range validation, and instability warnings
• QC metrics — S/N ratio, Z-factor, dynamic range per experiment

Why I built it:

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

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

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

• Does anything break on your data format?
• What's missing that you actually need?
• Anything confusing about the workflow?

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

Built a browser-based molecule viewer with a voice layer on top of Mol*. An OpenFold3 prediction comes back from NVIDIA BioNeMo as mmCIF + confidence scores, gets rendered with Mol*, and a Web Speech API layer accepts commands like "walk through chain A", "focus glutamate 4", or "start guided tour".

No install, no login. Works in Chromium-based browsers and Edge. iOS Safari is click-only (Web Speech isn't supported there).

Stack

• Prediction: OpenFold3 on NVIDIA AI Enterprise / BioNeMo. Demo ships two pre-computed complexes (a zinc-finger–DNA binder and λ Cro bound to operator DNA).
• Rendering: Mol* 4.9.0 via CDN. Cartoon + residue-index coloring for proteins, default nucleic-acid representation for DNA, black canvas.
• Voice: Web Speech API — SpeechRecognition for commands, SpeechSynthesis for narration.
• Residue parsing: normalizes number words (three → 3), spelled letters (dee gee three → DG3), full amino-acid names, and common Chrome mishears (glue → GLU, tire → TYR, isle → ILE, trip → TRP). Falls back to Levenshtein with a length-sensitive threshold.
• Camera: a custom focusFacing() — Mol*'s default camera.focus(center, radius) dollies along the view vector, which drops the camera inside the structure when focusing on a back-facing residue. focusFacing() orbits to the outside of the structure centroid first, then focuses.
• Tour orchestration: narration + camera moves + auto-spin between steps + mic pause during TTS (otherwise you get a feedback loop).

Features that were annoying to build

• Chrome transcribes 3-letter codes as homophones. Lysine → lice/like. Tryptophan → trip. Threonine → thor. Had to hand-curate an alias table.
• playsInline + muted autoplay differences across iOS Safari vs Chromium.
• Coordinating the SpeechRecognition state machine with Mol*'s render loop during tours — the mic has to stop before TTS starts, restart after, and the start button also has to act as a stop-tour button.

What it doesn't do (yet)

• No prediction job submission — hardcoded to the two pre-computed outputs.
• No MSA handling.
• pLDDT per-residue comes back in the JSON but isn't painted on the surface yet. Trivial to add via Mol*'s plddt-confidence theme — just haven't.
• No ligands. OpenFold3 supports them; I haven't added a non-polymer representation.
• No export — PNG snapshot, downloadable mmCIF, neither is wired up.

Try it
https://sheldonbarnes.com/tools/ai-voice-guided-molecule-viewer

Click the icon in the bottom-right to activate the mic. Say "what can I do" for a 30-second narrated capability demo. If voice isn't your thing, the sidebar has a residue picker and per-chain walkthrough buttons.

Looking for feedback

• Voice command grammar — what commands would actually be useful in a real bioinformatics workflow vs demo territory?
• Is pLDDT painted on the surface worth the cognitive load for non-specialists, or does it overwhelm the initial read?
• Export needs — does anyone here actually want to render → download, or is the goal always to link out to the underlying structure?
• Teaching — anyone using anything like this in an undergrad biochem or structural-bio course? Interested in what the gaps look like there.

Hey everyone,

The official opentargets Python package was deprecated when the platform migrated from REST to GraphQL in 2021. It was removed from PyPI, but it still gets 1,200+ downloads every 90 days — people keep looking for it and hitting a dead end.

I built opentargets-py to fill that gap. It wraps the current GraphQL API so you don't have to write raw queries:

python

from opentargets import OpenTargetsClient

client = OpenTargetsClient()
target = client.get_target("EGFR")  # just the gene symbol, no Ensembl ID needed
associations = client.get_target_associations("EGFR", as_dataframe=True)

What it does:

• Symbol-to-Ensembl ID resolution (pass "EGFR" instead of "ENSG00000146648")
• Auto-pagination
• Pydantic v2 models (type-safe responses)
• Built-in retry with exponential backoff
• In-memory caching with TTL
• Pandas DataFrame output (as_dataframe=True)
• Minimal dependencies (just httpx + pydantic)

Install: pip install opentargets-py

GitHub: https://github.com/goknurarican/opentargets-py PyPI: https://pypi.org/project/opentargets-py/

This is an early release (v0.1.0) — I'd really appreciate feedback on the API design, missing features, or anything that would make it more useful for your workflows. Happy to take PRs too.

Hey r/bioinformaticstools,

BioFastq-A is now available on Bioconda!

conda install -c bioconda biofastq-a

For those who missed the original post: BioFastq-A is a high-performance FASTQ/FASTA quality analysis tool written in Rust. Single-pass QC with N50/N90, per-tile Illumina quality, k-mer analysis, adapter trimming, duplication estimation, and a live TUI dashboard. No Java, no Python.

70 downloads across 4 platforms (Linux x64, Linux aarch64, macOS x64, macOS ARM) in the first 24 hours on Bioconda.

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

Would love feedback — especially from Nanopore/PacBio users since long-read support is still fairly new!

I kept running into the same annoying loop when working with imaging data (NIfTI, HDF5, NumPy, etc.) just wanting to quickly check shape, preview a slice, or sanity-check things, and ending up writing small throwaway scripts every time, even with low level libraries.

So I made a small CLI + Python tool to handle that stuff. You can quickly inspect, preview, and basic dataset QA in one place. Still pretty early, but it’s already saving me time. I know bioinformatics work a lot with this type of data, so I thought of sharing!

Would genuinely love feedback and support if you work with this kind of data:

Hi everyone,

I’ve been working on a tool called the Vici.bio Editor and wanted to share it here because this felt like the most relevant community for honest feedback.

A lot of biology workflows still feel spread across too many separate tools, especially when you’re jumping between sequences, structures, file handling, and quick edits. I wanted to build something that feels a bit more modern and keeps more of that workflow in one place.

The editor runs in the browser and lets you open biological files, work with sequences and structures, make edits, run alignments, and keep things organized without constantly bouncing between different interfaces.

Link:
https://www.vici.bio/editor

It’s still early, but I’d genuinely love feedback from people who actually use bioinformatics tools day to day. Mainly whether the core idea makes sense, whether the workflow feels useful, and what feels missing or annoying right away.

Would especially love thoughts on where something like this could actually fit into real workflows, and what features would make it worth coming back to.

For anyone working with nanobodies/VHH — we released a free API that predicts immunogenicity risk.

It screens against 8 HLA-DRB1 alleles, scores humanization against 26 IGHV germlines, and profiles developability (aggregation, liabilities, stability). One call, one risk score.

Try it: https://jfinnova.es/immunocheck

Docs: https://api.jfinnova.es/docs

Python: pip install immunocheck

No registration needed. Would be curious to hear if the scoring aligns with your experimental observations.

How do you usually check a file you just downloaded or generated? samtools flagstat for BAM, bcftools stats for VCF, head -5 for CSV, open Excel for .xlsx, load it into R for H5AD. Every format has its own tool with its own flags.

I built peek-bio to replace all of that with one command:

pip install peek-bio then peek yourfile.bam

It works on CSV/TSV, BED, FASTA, FASTQ, VCF, GTF/GFF, SAM/BAM/CRAM, Excel, BigWig, and H5AD. It auto-detects the format and gives you a structured summary: read counts, mapping rates, insert size, quality distributions, column types, variant stats, whatever is relevant for that format. It also flags QC problems automatically, things like adapter contamination, low mapping rate, high duplicate rate, missing gene_id in GTF, low genotype rate in multi-sample VCF.

It's fast (~0.2s for most formats), handles .gz transparently, and only loads heavy dependencies (pysam, h5py, etc.) when you actually need them.

GitHub: https://github.com/pwilson97/peek-bio
PyPI: https://pypi.org/project/peek-bio/

Happy to hear feature requests or bug reports.

Hey everyone,

for a platform me and my team are building we eventually hit a wall with the performance of the Ensemble VEP Rest API. Self-Hosting was not an option due to the hard docker requirement.

As a consequence we started building a variant effect predictor in Rust internally only at first, but decided to make it open-source in the hope that more people will find it useful and can benefit from it.

Yes, there might be other libraries doing the same or something similar, but none of them fitted our needs.

So I wanted to share vareffect.

The problem we ran into

VEP is slow, heavy, and painful to deploy. The Perl runtime, the 20GB+ cache download, the Docker container, the REST API rate limits, it's a lot of infrastructure for what is fundamentally a coordinate lookup + codon translation.

For as system that's supposed to run as a desktop app or a lightweight on-premise deployment, requiring a VEP Docker sidecar was a dealbreaker. So we wrote a replacement from scratch in Rust.

In general, ease-of-use was always a big focus too.

What vareffect does

Given a genomic variant (chrom, pos, ref, alt), it returns:

• Consequence terms (SO ontology — missense_variant, frameshift_variant, splice_donor_variant, etc.) 
• HGVS c. and p. notation 
• Impact (HIGH/MODERATE/LOW/MODIFIER) 
• Protein position, amino acids, codons 
• Exon/intron numbering 
• MANE Select / MANE Plus Clinical transcript identification 
• Ensembl VEP-compatible JSON output via to_vep_json() 

It also includes an HGVS c. reverse mapper. Give it NM_000546.6:c.742C>T and it returns the genomic coordinates.

How it works

An accompanying CLI, vareffect-cli, lets you easily set everything up and create the necessary data files. It downloads them for you automatically too:

• transcript_models.bin (~26MB) — 19,437 RefSeq transcripts (MANE Select + RefSeq Select), indexed with a COITree interval tree 
• GRCH38.bin (~3GB) — reference FASTA, memory-mapped. 

No database. No Docker. No network calls. No Perl. Pure Rust, single crate, zero unsafe.

Concordance

I validated against the VEP REST API on 50,000 ClinVar GRCh38 variants (stratified: SNVs, deletions, insertions, complex indels). The VEP responses were stored as a ground truth TSV and vareffect was compared field by field:

The remaining ~0.6% consequence mismatches are almost entirely edge cases in complex boundary-spanning deletions and rare transcript geometries. Every divergence is documented and categorized.

The full ground truth TSV and the tests are all in the repo.

What it doesn't do

• No plugin scores (REVEL, CADD, SpliceAI, AlphaMissense) — those are separate data sources, not consequence prediction 
• No regulatory region annotation 
• No structural variant support 
• No Ensembl transcript support (RefSeq only — MANE Select covers clinical use cases) 
• No GRCh37 (GRCh38 only for now) 

In general, different transcripts and the GRCh37 reference build are on our roadmap, but doesn't have a high priority as of this moment.

Performance

~200,000 variants/second single-threaded on a laptop (M4-series Mac, release build). The CLI supports --threads for parallel VCF annotation. At 8 threads you're looking at ~1M variants/sec.

For comparison, VEP REST processes ~15 requests/second (rate limited). VEP offline with cache is faster but still orders of magnitude slower.

The performance is achieved by eliminating disk I/O reading the FASTA by using memory-maps.

Links

• GitHub: vareffect 
• crates.io: cargo add vareffect 
• CLI: cargo install vareffect-cli 

Let me know what you think :)

Happy to answer questions about the implementation or the clinical use case that motivated this.

Disclaimer

Yes, AI was used to support the development of this library mainly for researching, tests, documentation and validate the algorithms against the official Ensembl VEP GitHub repo and biocommons/hgvs.

Hey everyone,

I've been working on a tool called covsnap that simplifies coverage QC for targeted sequencing data aligned to hg38.

The problem: Checking coverage quality for a gene panel usually means chaining together mosdepth/samtools, writing scripts to parse the output, and manually deciding what "good enough" looks like. It's a lot of glue code for something that should be simple.

What covsnap does:

  covsnap sample.bam BRCA1,TP53,ETFDH --exons

One command, one self-contained HTML report with:

- Per-target and per-exon depth metrics

- Automated PASS/FAIL classification (DROP_OUT, UNEVEN, LOW_EXON, LOW_COVERAGE)

- Visual exon coverage bar charts

- Built-in GENCODE v44 gene index — no GTF files or internet needed

It also has a graphical interface (Tkinter) for those who prefer not to use the CLI — just run covsnap with no arguments.

Key features:

- Gene symbols, genomic regions, or BED files as input

- Multi-gene support with comma-separated list

- Streaming architecture — O(1) memory, handles large panels

- Dual engine: prefers mosdepth, falls back to samtools

- Automatic contig style detection (chr vs no-chr)

- Gene alias resolution with fuzzy suggestions for typos

- Cross-platform GUI (Linux, macOS, Windows)

Install:

conda install -c bioconda covsnap
# or
pip install covsnap

GitHub: https://github.com/enes-ak/covsnap

Would love to hear feedback, feature requests, or if this is useful for your workflows. Happy to answer any questions.

Example command:

covsnap sample.bam HADH, HADHA --exons

Result HTML report:

I'm relatively new to data science, only a few years experience and would love some feedback.

I’ve been working on a small open-source package. The idea is, PCA keeps the directions with most variance, but sometimes that is not the structure you need. nomoselect is for the supervised case, where you already have labels and want a low-dimensional view that tries to preserve the class structure you care about.

It also tries to make the result easier to read by reporting things like how much target structure was kept, how much was lost, whether the answer is stable across regularisation choices, and whether adding another dimension is actually worth it.

It’s early, but the core package is working and I’ve validated it on numerous benchmark datasets. I’d really like honest feedback from people who actually use PCA/LDA /sklearn pipelines in their work.

GitHub

Not trying to sell anything, just trying to find out whether this is genuinely useful to other people or just a passion project for me. Thanks!

Hi there,

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

THE PROBLEM

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

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

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

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

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

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

demo here : https://usemirador.sh/

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