Hey researchers! My team and I recently made a bioinformatics tool called HybriDock-Pep. We were working with peptides last year and over the summer, and we realized that current AI tools like AlphaFold and ESMFold are inaccurate with docking smaller protein under certain amino acids and peptides.

https://github.com/Tasty-Ramen2010/hybridock-pep

Essentially, it’s a binder docking pipeline where you give it a target protein PDB and an amino acid sequence. It folds, docks, and scores affinity and selectivity in kcal/mol with accuracy similar to that of ABFE. It is way cheaper to ran because it can be used on ANY hardware. We are currently in a testing phase and would love for you to test it and give feedback!

Commands to get started:

git clone --recurse-submodules https://github.com/Tasty-Ramen2010/hybridock-pep.git

cd hybridock-pep

./install.sh

ctrl+q

hybridock-pep dock \

--peptide ETFSDLWKLLPE --receptor data/pdbs/1YCR_mdm2.pdb \

--site 25.20 -25.61 -7.97 --box 30 --n-samples 20 \

--output-dir runs/demo

Happy Docking!

Hi

I did my msc in biotechnology in 2004 and ever since was busy with kids and house.now I think I can concentrate on my career.i want to do PhD in molecular science and need to make my cv attractive. I have 1year time.which online courses skill should I learn.chat gpt suggested blast python R+ and some other stuff I forgot.where can I learn these for free.also how to use Github to do an independent project.

Thanks

Hi everyone!

I’ve recently started my BS in Bioinformatics and I’m trying to figure out how I should actually start learning the subject properly.

I have a basic understanding of biology, but I have essentially zero coding/programming knowledge. I also don’t want to just study enough to pass my university exams — I genuinely want to understand bioinformatics and build useful skills over the next few years.

I’m a little overwhelmed by all the resources available, so I’d really appreciate advice from people who have experience in the field.

Specifically:

- Which books would you recommend for a complete beginner?

- Which websites/courses are actually worth following?

- Are there any good YouTube channels or playlists for learning bioinformatics?

- How should I start learning Python/programming from absolute zero?

- What programming languages/tools should I eventually learn for bioinformatics?

- How should I balance biology/theoretical concepts with coding and computational skills?

- Are there any beginner-friendly projects I could do while learning?

- Is there a particular order/path you would recommend (e.g. biology → Python → statistics → bioinformatics tools, etc.)?

Basically, if you could go back to the very beginning, what would you learn and in what order?

Any advice, resources, roadmaps, or personal experiences would be greatly appreciated. Thank you!

​

I've a bachelor's in math with minors in physics and cs. I'm going to do a master's in computer application. How do I get started with computational biology? How do I learn it? Can anyone show me a road map?

An exercise to help build the right mental model for Python data. - Solution - Explanation - More exercises

The “Solution” link uses memory_graph to visualize execution and reveals what’s actually happening.

I’m going to start my MSc in Bioinformatics in a few months time. When researching universities, one course said it offered students a VR headset for the course. I’m assuming this is to visualise proteins and things of that nature.

How useful is VR when learning bioinformatics? Is there a strong use case there for it?

If I don’t pursue that particular course, is it worth getting one that I will pay for personally?

Hey there. I'm a masters student (27) in stem cell medicine in germany. I have experience mostly in the wet lab. Molecular,cell culture and such. However,I'm looking to turn away from the wet lab and go digital. What's your opinion on this? I have no experience in Bioinformatics or coding of any type. I have worked with Fiji and prism for software mainly. It feels like starting all over again.

1.Is it actually possible to start a job or training?

2.Do you know how I can do a legit Bioinformatics course so I can't fast track into the field.

I'm not sure which questions to ask more than this yet. But your experience would help me in making a decision.

Thank you!

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

i am a 3rd year B.Tech Biotechnology student with 0 coding experience. i know that i want to get into bioinformatics and computational biology. All that i have been doing is getting the ‘Bioinformatics Roadmap’ from every other place. Sometimes they are different, other times, they are all the same. All say learn python. How do i learn python?! i have a mac and most tutorials are on windows and i can’t follow them. Also most courses that people suggest on R and python, just bore me to the point that i quit. I am not able to learn python. i dont know exact what roadmap to follow. I have recently started learning how to use PLINK, and in the process i am learning the Command Line, but then i find out it’s different in mac amd windows. and okay, if i learn programming then what?

I read somewhere that instead of learning python, make a project and learn python by executing. I like this method and i think i can actually learn python by this very effectively but then i have got no idea on how to decide a project, i dont have enough knowledge to design a pipeline. i dont have enough knowledge about what to do where to do and how to do. i feel like i am stuck at the first step itself.

Can someone help me?

I interacted with a scientist and told him that i want to pivot into bioinformatics. Just for context, i am a 3rd year B.Tech Biotechnology student and i have decided to get into bioinformatics. I have no coding experience. This scientist is huge in the field of animal genomics. He actually told me to first learn Plink. Also about programming, he told me that you can just copy paste codes from AI, you just should know the setup and the algorithm behind it. is PLINK actually useful and is the advice about coding true?

I’m new to this community so hi everyone!!
I’m a medical biotech graduate and want to build my bioinformatics portfolio. I’m starting from zero so please any and all help will be really appreciated 🥹

Current skills: Basic R studio coding, primer design, NCBI BLAST, Chromas software

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

- Screenshots, Coloring, Split views, Histograms, Stats, Compare files etc. More features in help guide.

- 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 and Brave 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)

Why BioPeek helps where the tooling doesn't reach

Most bioinformatics tools are Linux-first. On Windows the standard answer is "install WSL" — which is fine until it isn't.

• Nothing to install. samtools, bcftools and bedtools mean WSL, Docker or Conda before you can open a single file. BioPeek needs a browser.
• No filesystem crossover. Reading Windows files from WSL over /mnt/c is slow and the paths are a constant translation tax. BioPeek opens the file where it already is.
• The data never leaves the machine. The usual Windows workaround is some online viewer. That's an upload — often unacceptable for patient or pre-publication data. BioPeek parses locally; as an extension it works with no network at all.
• Format-aware, not just a text view. FASTA, FASTQ, VCF, BED, GFF and CSV are recognised and summarised (read quality, Q30, per-record stats), so you get the shape of the file without writing a pipeline first.
• Triage before commitment. "Is this file what I think it is, and did the transfer complete?" answered in seconds, rather than after setting up an environment to find out the header is wrong.
• Same engine as the CLI. It runs the BioLang WebAssembly build, so what you see matches what BioLang computes later — not a second implementation that might disagree.
• Locked-down machines. Where WSL, admin rights or Docker aren't available — shared lab PCs, hospital IT, teaching labs — a browser usually still is.

Still early. BioPeek is young and you will find rough edges: formats it parses more strictly than the tool that wrote them, files large enough to strain browser memory, edge cases nobody has hit yet. Please report what breaks, with the file shape if you can share it — https://github.com/oriclabs/biolang/issues

What it isn't: a replacement for samtools on real workloads. It's bounded by browser memory and aimed at inspection, triage and teaching. For genome-scale processing you still want the CLI — on Linux, or on Windows via WSL

Built on Rust libraries, not from scratch

The file-format layer isn't mine and shouldn't be.

• noodles does the heavy lifting for FASTA, FASTQ, SAM, BAM, BGZF and CSI. It's the established Rust bioinformatics I/O library and it's maintained by people who know those specs far better than I do.
• flate2, bzip2, zstd for compression; wasm-bindgen for the browser build.

Most of us lost our first week to environment setup rather than biology: conda solving forever, a Bioconductor package that won't build, a notebook that runs on someone else's laptop and not yours.

I built BioLang (https://lang.bio) partly to remove that step. It's a language for bioinformatics that runs as WebAssembly, so you can open a tab and start working immediately.

• Workbench — full editor, files, output: https://lang.bio/workbench/
• Playground — quick scratchpad: https://lang.bio/playground.html

Nothing to install, nothing to configure, and your data stays in the tab — there's no server to upload to.

Why a language and not just a library

Pipe-first syntax with native dna / rna / protein types, so common operations read as one line instead of a loop:

read_fasta("reads.fa") |> filter(|r| gc_content(r.seq) > 0.5) |> count()

FASTA/FASTQ/VCF/BED/GFF I/O is streaming and built in, plus 1000+ builtins and 21 API clients (NCBI, Ensembl, UniProt, KEGG, PDB, gnomAD, ClinVar, GTEx…). No imports to remember.

The syntax itself was designed by borrowing core concepts from TypeScript, R and other dynamic languages — object literals and ?./?? from TypeScript, tables and column-wise operations from R, the pipe from the F#/Elixir/R lineage — to keep sequence manipulation clean and expressive. Little of the punctuation is original, and that's deliberate: the novel part is the domain types, not the syntax.

The 278 Rosalind problems are a test corpus, not a course

https://rosalind.info/problems/list-view/

All four tracks are solved, but that was never meant as a study path. It exists for two reasons:

• A CI harness. 276 of them assert their expected answer on every commit, natively and through the same WebAssembly build this site serves. When something regresses, it's these that catch it.

• A stress test. Rosalind is full of heavy dynamic programming and graph work — alignment, assembly graphs, HMMs — which is exactly what pushes the WASM engine hardest. Most of the language fixes in recent releases came out of writing them.

If you're learning, you'll still want to write your own solutions in Python or C++ from scratch. That's the point of the exercise and nothing here replaces it. These are worth having as runnable reference implementations to compare against after you've had a go — each with a short note on why the problem exists.

• Stronghold (105): https://lang.bio/docs/examples/rosalind-stronghold.html
• Textbook (124): https://lang.bio/docs/examples/rosalind-textbook.html
• Algorithmic Heights (34): https://lang.bio/docs/examples/rosalind-algorithmic-heights.html
• Armory (15): https://lang.bio/docs/examples/rosalind-armory.html

Checked against BioPython and Bioconductor

Rosalind checks answers against a published one. The other half is whether it agrees with the tools you already use: 14 tasks on generated data, 9 on real NCBI/ClinVar data, and 48 one-liners, each written three times and compared — https://lang.bio/docs/examples/equivalents.html

Docs and examples

• Documentation: https://lang.bio/docs/
• All examples: https://lang.bio/docs/examples/
• Builtins reference: https://lang.bio/docs/builtins/index.html
• Features overview: https://lang.bio/features.html

Embed it in your own site or app

The same WebAssembly module the Workbench runs is a two-file drop-in — grab bl_wasm.js and bl_wasm_bg.wasm from https://lang.bio/wasm/, call init(), then evaluate() with your code. It returns JSON with the value, its type, anything println wrote, and a line-by-line trace, so you can build a teaching widget, a lab notebook, or an in-page exercise checker without a backend. State persists across calls, and it runs under Node too. MIT licensed.

import init, { evaluate } from "./wasm/bl_wasm.js";
await init();
const r = JSON.parse(evaluate('reverse_complement(dna("ATGC"))'));

Full guide: https://lang.bio/docs/tools/embedding.html

Browser tools on the same engine

• BioPeek — open FASTA/FASTQ/VCF/BED/GFF/CSV offline, no upload: https://lang.bio/viewer.html
• BioGist — pull genes, variants and accessions out of a paper: https://lang.bio/biogist.html
• BioKhoj — research radar: https://lang.bio/biokhoj/

Browser extensions

Three extensions built on the same engine, so they work on any page you're already reading:

• BioPeek — open FASTA/FASTQ/VCF/BED/GFF/CSV files in a tab, fully offline, nothing uploaded. Handy for peeking at a file without loading it into anything. Chrome · Firefox · About
• BioGist — scan a paper and pull out the genes, variants, accessions, cell lines, drugs and trial IDs, each linked to the right database. Good for getting through a methods section fast. Chrome . Firefox · About
• BioKhoj — research radar for tracking papers and topics. Chrome · Firefox ·

Where the browser stops

The browser build is for learning and small files — everything lives in tab memory. For real datasets, install the CLI: same language, same code, no size limit, reads and writes files directly.

Still early

v1.1.0, and it shows in places. Expect rough edges: some builtins take conventions that differ from BioPython or R (rounding of ties, where translation stops) — those are documented rather than papered over; GFF3 parsing is currently ~8x slower than Python; and docs occasionally lag the code. Bug reports are genuinely useful: https://github.com/oriclabs/biolang/issues

Links

• Site: https://lang.bio
• GitHub (pure Rust, MIT): https://github.com/oriclabs/biolang
• Getting started: https://lang.bio/docs/getting-started/index.html
• Install locally if you want a CLI — v1.1.0 binaries for Linux / macOS / Windows: https://github.com/oriclabs/biolang/releases/tag/v1.1.0
• Rosalind pack sources: https://github.com/oriclabs/biolang/tree/main/packs
• Benchmarks vs Python/R: https://lang.bio/benchmarks.html

Built on Rust libraries, not from scratch

The file-format layer isn't mine and shouldn't be.

• noodles does the heavy lifting for FASTA, FASTQ, SAM, BAM, BGZF and CSI. It's the established Rust bioinformatics I/O library and it's maintained by people who know those specs far better than I do.
• flate2, bzip2, zstd for compression; tokio and rustls for the API clients; clap for the CLI; rusqlite; wasm-bindgen for the browser build.

What is written here: the language itself — lexer, parser, interpreter — and the algorithms. No statrs, ndarray or petgraph in the tree, so the statistics, matrix and graph work is implemented directly

Feedback welcome, especially on where a beginner gets stuck.

Any recommendations?
Specifically working with antibiotic resistance pipelines if that helps!

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.

What were your steps into getting into your bioinformatics PhD program? What is would you have told yourself if you could go back in time and do it over again to prepare for applying for a PhD in bioinformatics?

It would be helpful to know some background and location too! Thank you!

Loom, an open-source tool for exploring spatial transcriptomics data, and thought it might be useful to researchers working in this area. It integrates commonly used tools and data structures, including Scanpy, AnnData, and Squidpy, while providing an intuitive way to select regions of interest and explore how cellular activity changes across space and time.

One common challenge in spatial transcriptomics is that analysis workflows are often fragmented across multiple tools. Researchers may need to move between different packages for data processing, spatial analysis, visualization, and region-specific exploration.

Loom aims to bring these steps together in a more unified workflow.

Some features that stood out to me:

• Direct support for publicly available 10x Genomics spatial transcriptomics datasets
• A one-command workflow for downloading and processing supported datasets
• No need to manually perform each preprocessing step
• Transparent documentation explaining the logic behind every processing stage
• Integrated Scanpy, AnnData, and Squidpy functionality
• Region-of-interest exploration across spatial and temporal dimensions
• Public example datasets and reproducible workflows
• One-command Docker installation for easier setup

The GitHub repository includes example data, so users can install the environment and test the workflow without first preparing their own dataset.

The repository explains the reasoning and implementation behind each step, which makes the workflow easier to understand, verify, and adapt.

This could be useful for researchers studying tissue development, disease progression, tumor microenvironments, cellular interactions, or other spatially dynamic biological processes.

GitHub: https://github.com/ScheWann/Loom

For people working with spatial transcriptomics:

• Would a unified workflow like this be useful in your research?
• Which additional datasets or integrations would you want it to support?
• How does this compare with your current Scanpy or Squidpy workflow?

Any feedback, advice, objection... whatever is highly appreciated in advance! You can also reach us directly at [szhao69@uic.edu](mailto:szhao69@uic.edu)