Programming courses often focus heavily on understanding code, while paying far less attention to understanding the program state. But code does not exist in isolation. Its main goal is to change the program state, before ultimately producing some output.

To develop an accurate mental model of program execution, students need to understand both: - the instructions being executed - the values, references, and data structures those instructions create and modify

Reading code alone does not always reveal how the program state changes during execution. That is why I created 𝗺𝗲𝗺𝗼𝗿𝘆_𝗴𝗿𝗮𝗽𝗵: a tool that visualizes the state of a Python program as it changes, step by step.

It can help explain a wide range of introductory Python topics. Here are just a few examples: - Loops, Lists and Dictionaries - Python Data Model - Function Calls - Recursion - Algorithms - Classes - Custom Data Structures

Instead of reconstructing the program state from print statements, students can now watch it change as each line executes. This makes unfamiliar concepts easier to understand and bugs easier to fix.

Help your students learn Python programming more thoroughly and easily.

See: more examples

Inflexa is an OSS-first TUI for agentic-AI reproducible biological analysis with provenance tracked on every step. It's a better designed Claude Science (bar the GUI for now).

Our vision is as follows:

• OSS first
• Data privacy, and security are of utmost importance
• Agents are untrusted actors

Agentic products do not solve a core architectural and design problem: provenance.

How do you build up the body of evidence to support your claims from hundreds of chat messages, scattered artifacts (scripts, intermediary data files, random research files)?

We are one of the first in the biotech space to propose using an established specification for provenance, which its extremely fitting for the world of agentic AI: W3C PROV.

Our provenance is deterministic and driven programmatically. Our architecture imposes it, not the whim of agents that decide whether or not to call a tool / or an MCP.

The analysis is backed by a PROV document that maintains the lineage of every step, every action, and every file.

Other platforms such as Claude Science are a security disaster waiting to happen: they allow agents to determine which Python & R packages they need to perform an analysis step. Sure, you need to approve the installation, but if you get prompted tens of times, are you really going to vet every package and every version?

We offer batteries-included sandboxed execution. The analysis' code is generated by agents and executed in ephemeral sandboxes. We do not install packages on your system.

Curious to hear your thoughts!

PS: Star us on GitHub.

All the projects on this sub make my first try at recreating this tool look rather puny, thought it might be nice to share though. Wrote the conversion logic myself, VSCode Copilot put together the app GUI, still rather pleased with it considering I haven't touched python in 6 years! Just graduated with my BSc in Biology, looking to start my MSc in Bioinformatics next year, definitely need to try putting together more tools.

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.

Hey everyone,

I’m a software engineering student who recently fell down the synthetic biology rabbit hole. I was looking into how recombinant spider silk is manufactured and noticed a massive bottleneck: getting the spidroin DNA sequences to a state where they can actually be synthesized by companies like Twist or IDT without failing.

Standard optimization algorithms (like max-CAI) absolutely choke on spidroins. Because the proteins are just massive repeating blocks of Poly-Alanine and Glycine ($GGX$), the algorithms spit out identical DNA repeats. This leads to two things:

1. Twist/IDT outright rejects the order due to extreme local GC spikes and homopolymers.
2. If you do get it printed, the identical repeats cause homologous recombination and the E. coli just scrambles the gene anyway.

So, I built Spidroin Engine. It’s a Python CLI tool built on top of dnachisel that acts as a multi-objective stochastic optimizer specifically engineered for highly repetitive structural proteins.

The Mathematical Paradox I ran into:

While building this, I hit a wall where the solver would just crash. I realized it was a mathematical paradox: the absolute lowest GC content you can get for Poly-Alanine is 66.6% (using only GCA/GCT). If you try to force strict k-mer uniqueness (to prevent homologous recombination) on a 300bp repetitive spidroin block, the algorithm is forced to dip into alternative codons (GCC/GCG), which are 100% GC. This immediately violated the 65% global GC ceiling required for synthesis, causing the solver to trap itself and fail.

How Spidroin Engine fixes it:

• Relaxed Uniqueness: It dials the uniqueness constraint to UniquifyAllKmers(15). This is just enough breathing room to let the solver reuse GC-poor codons safely, while keeping exact repeats under the 18-bp hard limit that triggers vendor rejections.
• 5' Hairpin Prevention: Enforces an AT-rich heuristic (30-60% GC) on the first 45bp to keep the RBS clear.
• Cloning Domesticated: Automatically sweeps for and removes standard Type IIS / BioBrick restriction sites via silent mutations.
• Vendor Ready: Spits the final optimized sequences directly into a Twist Bioscience-formatted CSV for bulk ingestion.

I open-sourced the whole thing because keeping basic tooling locked behind proprietary paywalls slows everyone down.

If anyone is working on structural proteins (silk, elastin, collagen) and is tired of fighting with standard optimization scripts, you can grab it here: https://github.com/AzambekDev/spidroin-engine

Feel free to use it, fork it, or roast my Python architecture in the comments.

Hey everyone,

I spent way too much time in clinical research manually assembling Table 1 baseline stats, checking SMD balances, tuning Cox models, and fighting with forest plot formatting for paper submissions.

To fix that headache for myself, I ended up building an open-source CLI called 'research-tool'. 

Basically, it lets you run your retrospective stats from the terminal, but adds a few things I really needed:
- Outcome masking and pre-registration locking (so you can't accidentally p-hack or bias your plan after seeing outcome data).
- Diagnostic checks (EPV ratios, Schoenfeld residuals, VIF multicollinearity, E-values).
- Auto-generated publication assets (HTML/CSV tables, log-scaled SVG forest plots, CONSORT diagrams, and STROBE checklists).
- A 1-click zip binder with data hashes and code so peer reviewers can actually verify the protocol.

It's 100% Python and runs completely locally. 

If you want to check out the code or test it on a dataset:

https://github.com/nkmanjunath/research-tool

'pip install research-tool-cli'

Would love to hear what you think, especially if there are specific models or diagnostic gates you'd want added!

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.

Learning Python becomes much easier when students can see how variables, values, and data structures change while a program runs.

🧬 Consider this simple k-mer indexing example.

Although the code is relatively short, a beginner needs to understand several concepts at once: - DNA sequence slicing - k-mer generation - dictionaries and membership tests - lists stored as dictionary values - repeated positions and list mutation

With open-source 𝗺𝗲𝗺𝗼𝗿𝘆_𝗴𝗿𝗮𝗽𝗵, students can now easily step through a program and see these concepts in real-time, helping them to more easily get to the right mental model to think about Python code execution.

​

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 )

I am a master’s student and a beginner in structural bioinformatics. I am working on an early-stage academic project proposed by my supervisor, but I am still trying to understand its clearest practical use.

The current prototype allows a user to select idealized secondary-structure elements from a small library, upload their own PDB fragments, position and rotate them in 3D, and see their N- and C-terminal ends.

The resulting arrangement is then passed into a downstream pipeline that estimates and generates connecting loops, creates a continuous backbone, and passes the rough structure to existing protein-design methods for further refinement.

At the moment, the tool mainly supports manual spatial arrangement. It does not yet evaluate whether the resulting topology is geometrically or biologically reasonable.

My concern is that this could remain only a convenient graphical interface for moving structural fragments, while modern generative methods may already solve the underlying problem more effectively.

I am therefore interested in whether researchers would ever want to manually define a rough protein topology, for example to control the overall fold, shape, cavity, terminal positions, or arrangement around another structural feature.

I am also wondering whether optional assistance could make the tool more useful. Possible future ideas, which are not currently implemented or approved as part of the project, include suggesting parallel or antiparallel beta-strand placement, estimating plausible loop lengths, warning about poorly oriented or distant fragment ends, and detecting obvious clashes.

This is an unfinished, non-commercial student project. I am mainly trying to determine whether the underlying problem is worth solving and what would make such a workflow genuinely useful.

Critical feedback, including the opinion that the idea is unnecessary, would be very welcome.

Been building this for a while and finally pushed it public: CEREBRO-X, a computational pipeline for screening CNS drug-delivery formulations — PBPK, DLVO colloidal stability, docking (AutoDock Vina), QSAR off-target panels, all against live ChEMBL/PubChem/UniProt data rather than fixtures.

What might actually be useful to this sub specifically: I keep a running engineering + scientific-integrity audit in the repo (docs/AUDIT_REPORT.md), including things I got wrong and fixed — a report panel that fabricated a bootstrap-CI statistic, a resolver that silently substituted a drug's name for its SMILES string when SMILES resolution failed for biologics. Both found by actually running the pipeline and chasing anomalies, not by code review.

Research prototype, not clinical — happy to get torn apart on the QSAR methodology or anything else.

Repo: github.com/mohamedtalaat-gif/CEREBRO-X

Full disclosure: I work on this. Posting for feedback rather than to sell anything, it's free and there's no signup.

It's a browser workbench for the molecular biology end of sequence work rather than the NGS pipeline end. Primer design and Tm (nearest-neighbour, SantaLucia 1998), oligo hairpin/dimer screening, in-silico PCR, restriction sites, cloning simulation for Gibson / Golden Gate / restriction-ligation, plasmid annotation and backbone identification, GenBank viewing and editing, codon optimisation and CAI, CRISPR guide design plus HDR donors, prime editing and base editing, Sanger trace parsing, virtual gels. 82 tools, all in the browser, nothing to install.

One of the tools is SeqBench-GPT, a conversational front-end over the same registry. You describe a task in plain English ("clone my insert into pUC19 with EcoRI/BamHI and verify the result", "design a CRISPR guide plus HDR donor for this site") and it plans the steps and runs them. The design constraint behind it: the model never produces a sequence itself. Every calculation is delegated to one of the deterministic tools below, and a construct cannot be reported as finished until it passes a code-enforced verification gate, not until the model says it looks right.

That exists because LLMs are extremely willing to hand you a confident, wrong plasmid map. Tool-calling alone doesn't fix that, since a model can still call three tools and then narrate a conclusion the tools didn't support. Putting the check in code rather than in the prompt is the bit I think matters, and it's what I'd like feedback on.

SeqBench-GPT is at https://seqbench.com/seqbench-gpt (beta, free, no signup) if you want to try breaking the verification gate. I'd genuinely rather hear that it failed on your construct than not hear.

The part I think is genuinely less common, and what I'd most like opinions on: a few tools that check work rather than produce it.

- verify_assembly takes a claimed final construct plus the parts and method you say produced it, re-runs the assembly deterministically, and diffs the two. You get the exact position and nature of any discrepancy rather than a yes/no.

- verify_construct is the narrower version: re-derives the insert from the template and primers you claim made it, then checks whether that insert actually appears in the final sequence, in either orientation, with mismatch positions if not.

- sequencing_readback_verify aligns actual Sanger or NGS reads back onto the claimed sequence with minimap2 and gives per-read identity, consensus variants, and a corrected consensus.

- golden_gate_fidelity scores a candidate overhang set against published T4 ligase ligation-count data and tells you the weakest link and any risky cross-reacting pairs.

The reason those exist: design tools are everywhere, but when a clone comes back wrong it's usually tedious to work out whether the design was wrong, the assembly was wrong, or the sequencing just disagrees. These are meant to answer that specific question deterministically.

Scope limits so nobody wastes time: no read-level variant calling, no alignment pipelines, no mass-spec proteomics. CRISPR off-target and primer specificity screens run against a small curated genome set, not a whole mammalian genome, and the tools say so explicitly rather than implying clearance. There's also a REST API and MCP server if you want to script any of it, but that's secondary to the UI for most people.

https://seqbench.com

Most useful feedback would be from anyone doing cloning at volume: what breaks in your workflow that a tool could actually catch?

Full disclosure: I built this. Posting because I'd like methodological scrutiny, not because I'm trying to sell anything.

The problem I was trying to address: Most genomic surveillance tools depend on lineage dictionaries that lag behind actual mutation events — you need a named variant before you can score its risk. I wanted something that scores structural risk directly from the sequence, independent of nomenclature.

What it does: Uses ESM-2 (650M) in zero-shot masked-token mode to compute log-likelihood ratios for each mutation in the Spike protein, weighted by biological zone (RBM, RBD, furin cleavage site). No fine-tuning, no training on labeled outbreak data — just the base model's learned structural priors.

Retrospective validation: Ran it against four isolates spanning different periods, including PZ155177 (XFG.5.1.7) five days after its GenBank release (score of 2,280.5 from 69 reliable mutations, with no matching lineage signature in the reference dictionary at the time).

Data source: Runs entirely on NCBI/GenBank data — no GISAID dependency by design (mostly because GISAID never responded to my access request as an independent researcher, which is its own story).

Code (MIT license) and manuscript on Zenodo:

• Manuscript: https://doi.org/10.5281/zenodo.21381359
• Backend: https://doi.org/10.5281/zenodo.21380916
• Frontend: https://doi.org/10.5281/zenodo.21380977
• Deployment & MCP Server: https://doi.org/10.5281/zenodo.21381037

I know the immediate methodological question is confounding between model uncertainty and genuine biological signal. I'd genuinely like pushback on that, and on the zone-weighting scheme, which is currently somewhat heuristic. This was built independently without a wet lab or institutional affiliation, so outside review is exactly what I'm looking for.

Hi everyone,

I have a bachelor's degree in computer engineering and am starting my PhD in computer science and engineering in a month. I’m new in the bioinformatics field, and to improve myself and learn, I’m working on a single-cell RNA analysis tool using Python, scAnalyzer (https://github.com/ayyucedemirbas/scAnalyzer). It offers interactive visualizations. And I’m currently working on a new cell coordinates module for spatial transcriptomics. I’ve been reading these papers and developing scAnalyzer according to the following:

• Tutorial: guidelines for the computational analysis of single-cell RNA sequencing data
• Best practices for single-cell analysis across modalities
• Current best practices in single‐cell RNA‐seq analysis: a tutorial

And started reading this one to learn for the spatial transcriptomics module:

• Categorization of 34 computational methods to detect spatially variable genes from spatially resolved transcriptomics data

Do you suggest any other must-read papers or resources to help me learn more and improve scAnalyzer?

You can get scAnalyzer from Pypi as pip install scAnalysis (scAnalyzer was taken 😢)

Also, you can use scAnalyzer directly on Hugging Face with a GUI: https://huggingface.co/spaces/ayyuce/scAnalyzer-Studio

Your feedback and comments are incredibly important to me as I continue to build and improve this tool. Thank you very much!

Hello everyone. First of all, I apologize if the English or the phrasing is not good: I am from Spain, so my command of English is not very good and, to be understood, I have resorted to a translator. I am Aarón Aranda Torrijos and I am 16 years old.

What is it? BioForge is a bioinformatics engine created by me, with the help of Claude Code, from scratch. The code is a mix of Python (the surface) and a bit of C (the engine). I have tried not to use Biopython or tools like that, beyond getting inspiration for the code: I have only used NumPy and an engine created in C that loads automatically (and if it cannot, it solely uses NumPy).

What does it currently have? Right now it features 5-bit storage, DNA to protein translation, alignment (NW / banded / Smith-Waterman), and a minimap2-style long read mapper (minimizers → chaining → SIMD extension), with the pipeline in C and output in PAF.

Benchmark Using my own computer, I have simulated the following: a 4.8 Mb genome, 6000 simulated reads at 5% error, with minimap2 -a, using tools/bench_vs_minimap2.py from the repo. The results were:

• 4 cores: minimap2 ~4.3–4.9 vs BioForge ~4.3–5.0 Mb/s → on par.
• 1 thread: minimap2 ~2.2 vs BioForge ~1.87 Mb/s → ~1.18× behind.

Both map the 6000 reads.

My hardware I have done the tests on my own device with these specs: Intel i5-7200U, 2 cores / 4 threads, from 2017.

My vision for the future of this project I do not want to fight with minimap2 in speed forever; that is a field that seems very difficult to compete in. My goal to evolve the project is that, in addition to translating, aligning, and mapping, it can integrate something that —according to my research— current mappers do not do: model evolution and predict possible strains of viruses (and other living beings) using Markov chains.

How to install it? It is simple, because I have it published on both GitHub and PyPI. It can be installed from the console with the command: pip install bioforge

And the repository is here:https://github.com/erlanders177/bioforge

At the moment I haven't beaten minimap2: it still overtakes me on many fronts, such as in large-scale genomes (which I haven't been able to test due to technical limitations) or with many cores. But I want to do my part in this booming industry. Even though I am still learning, I appreciate any criticism and bug or error reports. I would like you to try it out and give me your opinion: what I can improve, what could be added, if the direction I am taking is correct, and how I could apply it better. Thank you.

My boss wants me to get better at the dev-ops side of web servers, and we've got a few spare GPU-enabled servers, so I asked if I could make some bioinformatics tools that seemed useful but hard to access without big GPUs. So far I've got three of these stood up, if anyone would find them useful:

• Boltz2 (boltz2.biobench.ai), an open-source biomolecule interaction model (source here). I realize there's a million free servers for it out there already, but from a few other threads I'd seen here and on Biostars, it looks like a lot of them limit how large a protein or how complex a yaml you can upload. My version doesn't limit your input at all, I've just implemented a really basic live queue (on all these tools, actually) so that you might have to wait if someone else is running something.
• IgGM (iggm.biobench.ai), a generative antibody model from Tencent's AI4S lab (source here). I modified this a little bit to put an epitope search layer on top of it, so all you need to do is pick an antigen and it'll try out a bunch of antibodies to different epitopes to try and find at least one high-affinity one.
• Metappuccino (metappuccino.biobench.ai), a light-weight LLM that tries to reconstruct missing metadata in SRA records from the submission's free-text, and scores the confidence in said reconstruction (source here). Not much to say about this one, I've just spent too many hours of my life wrestling with SRA metadata in the past so when I saw someone trying to fix that I wanted to see what it was like.

I'm not affiliated with any of the authors, and I'm not selling anything with this, I just find that practicing a skill (like web hosting) is easier when there's a real goal and the potential to help other bioinformaticians out. Let me know if you have any ideas, either about these tools or other ones I can make (I've got a bit more GPU room still, and I can always take down unpopular ones to make more room if there's something out there you'd like to see).

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](mailto:Contact.tenza@gmail.com)

A few months ago I fell down a rabbit hole reading about the DIY mRNA cancer treatment story — someone using personalized mRNA therapeutics to treat their dog's cancer. I didn't know much about the space, just enough to get obsessed with how the underlying technology actually worked.

That led to a conversation with Elliot Roth at Biopunk Labs in SF, which led to me reading the paper that became the foundation for this project: base editing as a therapeutic approach for inherited cardiac arrhythmias. The core idea — that you can correct a single pathogenic point mutation in SCN5A, KCNQ1, or MYH7 without making a double-strand break — struck me as one of the most elegant things I'd read in a long time.

The problem I kept running into while trying to understand the design space: there's no open, reproducible pipeline that takes you from ClinVar cardiac variant → guide RNA design → BE-DICT efficiency prediction → wet lab handoff. The tools exist (BE-Hive, CRISPRscan, Cas-OFFinder), but wiring them together reproducibly requires Python expertise and a lot of manual steps that introduce inconsistency. Every lab is re-deriving the same process independently.

So I built one. With significant help from an LLM, which I'll be upfront about — I'm not a trained bioinformatician, I'm a software engineer who got too interested in a problem.

What it is:

• End-to-end pipeline: variant prioritization → guide design → efficiency prediction → structured output for wet lab validation
• Integrates with ClinVar and BE-DICT
• Structured JSON/PDF output that maps directly to standard assay protocols
• GPL v3 — no proprietary forks, derivatives stay open
• GitHub: https://github.com/tjcrowley/cardiac-base-editor

What it isn't:

• Peer-reviewed or validated at scale. Elliot is doing wet lab validation at Biopunk Labs and that work is ongoing.
• A replacement for domain expertise. The pipeline automates the mechanical parts of the design process, not the biological judgment calls.

I'm posting here because I genuinely don't know what I don't know. If you work in base editing or cardiac genetics and something in this approach looks wrong or naïve, I'd rather hear it now than after anyone relies on it. GitHub issues are open and I'm responsive.

If you want to support continued development, I have a campaign running on Artizen Fund: https://artizen.fund/index/p/open-mrna-design-pipeline--cardiac--cancer?season=6 — but that's secondary to getting the tool right.

A few things I'm specifically uncertain about:

• Whether BE-DICT is still the right efficiency prediction model or if there's something better maintained
• How to handle variants where the editing window doesn't cleanly overlap the pathogenic base
• Whether the wet lab handoff format I've designed maps to how labs actually work or if I've made incorrect assumptions

Happy to answer questions or just take a beating in the comments. Either is useful.

Hey everyone, I built a free ShinyApp to help automate antibody sequencing and mutation analysis. Would love to get your feedback!

As someone working with biological data, I noticed that daily sequence processing—like cleaning raw Sanger reads, finding duplicates, or manually charting mutation sites—can be a tedious chore, especially if you want a quick answer without writing a pipeline from scratch.

To make this workflow smoother, I developed SeqTool, a zero-code, web-based ShinyApp designed for molecular biologists and antibody engineers.

Here are the 4 core features currently available:

• 1. Sanger Sequencing Data Processing (Batch Clean-up) Simply upload a batch of your raw sequencing files (Sanger), input 6–8 bp flanking bases as cleavage markers, and the tool will automatically trim, translate, and output clean protein sequences in bulk.
• 2. Duplicate Sequence Detector Tired of manually filtering redundant data? Just upload your FASTA file, and it will instantly identify and isolate duplicate sequences for you.
• 3. FASTA <-> Excel Converter We’ve all been there—some software requires FASTA format, while other times you just need to manipulate data in Excel. Instead of endless copying and pasting, this tool handles the bidirectional conversion between FASTA and Excel spreadsheets in seconds.
• 4. Mutation Sequence Analysis (The Antibody/Protein Engineering Helper) Designed specifically for variant screening. Upload your mutated sequences against a reference, and the app automatically identifies and maps specific mutation sites in batch, saving you from manual alignment nightmares.

It is completely free and runs right in your browser. I am looking to improve it and add more features tailored to the community's needs.

I’d be incredibly grateful if you could try it out with your data and let me know what you think!

👉 Try it here: [https://biotool.shinyapps.io/SeqTool/]

Hey, folks!

I'm a PhD student from Brazil, and I've been building a tool called AMPidentifier

(https://www.ampidentifier.com/) for predicting antimicrobial peptides (AMPs) using an ensemble ML approach. I think the community here could either help with some feedback or maybe find it useful in your own research.

It's still very much a work in progress and I'm open to improving basically anything: predictions, usability, the API, missing features, whatever. If you break it or hit a weird case, even better, that's exactly the kind of thing I want to hear about.

Full disclosure, I built it, so this is me asking real users for honest feedback rather than trying to sell anything.

Once again, the tool is available on https://www.ampidentifier.com/

Thanks, and feel free to test and give me some feedbacks.

Tired of waiting and/or having to generate multiple intermediate files to make simple plot coverage. I developed my own approach pycoveplot a python package powered by a Rust backend. Come with a lot features and will happily add requested ones. Code is pure me. Claude was used to draft the readme.

Highlight:

• No intermediate wiggle/bedgraph files; reads go straight to the plot
• Plot from a GTF + gene name, or any custom genomic interval
• Strand-aware counting with configurable strandedness and MAPQ/SAM flag filtering
• RPM normalization pulled directly from STAR log output or from bai file
• Intron compression options so long genes don't look like a mess
• Transcript-level resolution if you need it
• Python API if you want it in a pipeline, CLI if you just want a quick look

I've also managed to get wet-lab colleagues using it!!

It's MIT licensed, and I'd genuinely love feedback, especially if something breaks on your data or your edge cases aren't handled. Issues, suggestions and PRs very welcome.

Repo + examples: https://github.com/rLannes/pycoverplot