thehardwarestore.ai

CellTypist is a Python library and command-line tool for cell type classification in single-cell RNA-seq (scRNA-seq) data. It implements a complete annotation workflow: training logistic regression classifiers on labeled expression matrices (with optional SGD mini-batching and GPU-accelerated cuML backends), annotating query cells using either custom-trained or pre-trained models, and visualizing marker gene expression via dotplots. The package is architected as a conventional Python library with a click-based CLI (entry point: celltypist.command_line:main), a models submodule that manages remote pre-trained artifacts, and a samples module for loading bundled example data. The primary data flow starts with an AnnData object containing raw counts, which is normalized, scaled, and filtered through feature selection before being passed to the classifier. For annotation, the trained model (or a downloaded pre-trained model) is applied to query cells, producing cell type labels and confidence scores. Models are fetched on-demand from celltypist.cog.sanger.ac.uk and cached locally, with a force_update flag to bypass the cache. External dependencies include scanpy, anndata, scikit-learn, click, numpy, scipy, pandas, and matplotlib. The repository is hybrid in nature: while the core deliverable is a software library, it also ships pre-trained models, a cross-species gene mapping reference (Cynomolgus/Rhesus orthologs), and tutorial Jupyter notebooks that demonstrate the API. These data assets make it a valuable resource for bioinformatics researchers even beyond the code itself. The tutorial notebook (docs/notebook/celltypist_tutorial_ml.ipynb) is a usage guide rather than a research artifact, relying on 12 built-in pre-trained models and demo data fetched from the same remote server. The project is maintained but not rapidly evolving; the last significant release was January 2025, and the codebase shows signs of technical drift. The pickle-based model format could break across Python or scikit-learn versions, and the tutorial notebook may produce different outputs with newer versions of scanpy or CellTypist. The force_update mechanism and backup_url fallback in the data-loading code indicate awareness of external data unavailability, but these fallbacks could themselves become stale.

This repository is the NVIDIA BioNeMo Agent Toolkit — a collection of 31 skills that give coding/scientific agents (Claude Code, Codex, any SKILL.md-compatible harness) domain knowledge for life-science workflows: protein structure prediction, molecular docking, generative chemistry, and related tasks. Skills execute in the user's own environment (workstation, notebook, cluster) and wrap NVIDIA NIM (NVIDIA Inference Microservices) APIs — both hosted endpoints and local Docker deployments. The toolkit is not an installable Python package; it is a skill catalog with supporting tooling, dual-licensed (Apache-2.0 OR CC-BY-4.0).

Barrnap is a Perl-based command-line tool for annotating RNA features in microbial genomes (bacteria, archaea, fungi). It integrates multiple bioinformatics tools (Infernal, Aragorn, Prodigal, etc.) to detect rRNA, tRNA, tmRNA, ncRNA, mRNA, and associated features like RBS, CDS, and terminators. The tool takes FASTA input and outputs GFF3 annotations. It is structured as a single executable script with modular subroutines for each analysis type, using temporary files for intermediate results. The code shows good organization, clear separation of concerns, and reusable components like the GFF handling and FASTA processing utilities.

EGAPx is NCBI's publicly accessible Eukaryotic Genome Annotation Pipeline, implemented as a Nextflow DSL2 workflow with a Python CLI entry point. The pipeline takes a genome assembly plus RNA-seq and/or protein evidence, aligns evidence with tools like STAR, minimap2, and miniprot, runs Gnomon gene model prediction and filtering, and produces ASN.1 annotation data, summary files, and MultiQC reports. The main entry point is ui/egapx.py, which validates inputs, resolves taxonomy IDs, fetches protein/HMM files, and orchestrates the Nextflow run. The workflow is organized into reusable subworkflows under nf/subworkflows/ncbi/, with checkpointing and parameter-merging patterns for reproducibility and environment flexibility across AWS, Slurm, SGE, and container runtimes.

This is an R/Bioconductor package for making enriched heatmaps, primarily used in epigenomics to visualize enrichment of genomic signals (e.g., histone modifications, DNA methylation) around target regions (e.g., transcription start sites). The package provides a workflow: normalize signals to a matrix via `normalizeToMatrix()`, then draw a heatmap with `EnrichedHeatmap()`, which is a subclass of ComplexHeatmap. It includes specialized annotation (`anno_enriched()`), row ordering by enrichment scores, smoothing, and support for categorical signals. The architecture leverages S3 classes (normalizedMatrix) and integrates with GenomicRanges for genomic interval operations. It is well-documented with vignettes and a pkgdown site, and includes Rcpp for performance-critical distance calculations. While the package is actively maintained, there are some signs of technical drift such as deprecated arguments and an old CI configuration.

maftools is an R/Bioconductor package for the analysis and visualization of somatic mutations in cancer genomics, primarily using Mutation Annotation Format (MAF) files. It provides a comprehensive suite of functions for reading, summarizing, and plotting mutation landscapes (oncoplots, lollipop plots, rainfall plots), detecting driver genes, analyzing mutational signatures via NMF, assessing tumor heterogeneity (MATH score), comparing cohorts, and integrating copy number alterations from GISTIC or ASCAT. The package also includes tools for converting other formats (ANNOVAR, ICGC) to MAF, querying cancer hotspots directly from BAM files via a C backend, and detecting sample swaps. It is widely used by cancer researchers and relies on Bioconductor infrastructure, with extensive bundled reference data (COSMIC signatures, cancer hotspots, TCGA burden). While primarily a software library, its heavy use of precompiled research data and domain-specific pipelines gives it a hybrid character. The codebase is well-structured with S4 classes and data.table for performance, though some functions have long parameter lists and a few deprecated modules.

phylotree.js is a JavaScript library for phylogenetic tree visualization and analysis, designed for web-based applications. It provides robust parsing of multiple tree formats (Newick, PhyloXML, NEXUS, NEXML, BEAST), interactive SVG rendering via D3, and a suite of analytical utilities including metrics (Sackin's index, pairwise distances, root-to-tip regression), clustering algorithms (Cluster Picker, PhyloPart), and tree construction (neighbor joining). The library is modular, with separate modules for formats, rendering, metrics, and clustering, and includes CLI tools for common operations like rerooting, tagging, and validation. It is used in production at phylotree.hyphy.org and supports real-world phylogenetic workflows in molecular epidemiology and evolutionary biology. While the codebase demonstrates solid engineering with reusable patterns like an event emitter and a robust Newick parser, it shows signs of technical drift with legacy dependencies (underscore, lodash, moment) and some unused code.

SequenceServer is a Ruby/Sinatra web application that provides a graphical interface for running NCBI BLAST+ and DIAMOND sequence similarity searches against custom databases. It manages BLAST database formatting, job submission with background execution, result parsing, and interactive visualization of alignments using D3.js and Circos-style plots. The backend uses a thread pool for concurrent job processing, YAML-based job persistence, and a plugin system for extensibility. The frontend is built with React and includes components for database selection, query input, and result exploration with export to SVG/PNG. The application is designed for bioinformatics researchers who need a self-hosted BLAST server with a modern web UI, supporting multiple BLAST programs (blastn, blastp, blastx, tblastn, tblastx) and DIAMOND. It includes comprehensive test suites for multiple BLAST versions and CI/CD pipelines for Docker and AppImage deployment.

Pheweb is a full-stack web application for building interactive PheWAS (Phenome-Wide Association Study) websites from GWAS summary statistics. It provides a command-line pipeline to ingest association files, annotate variants with rsIDs and genes, compute Manhattan and QQ plots, and generate a searchable, browsable web interface with LocusZoom region views, phenotype correlations, and top hits tables. The architecture is a Flask monolith with a JavaScript frontend using D3.js, jQuery, and Bootstrap. While the codebase is well-organized for its domain and includes some reusable components (e.g., a simple flat-file indexer and a CFFI matrix builder), it suffers from significant technical drift: outdated dependencies (Flask 1.1, jQuery 1.12, Bootstrap 3.3.7, D3 v5), deprecated Python patterns, and a successor project (PheWeb2) explicitly recommended in the README. The project is functionally complete but in maintenance mode, with limited test coverage and several known bugs documented in the changelog.

bioSkills is a curated, archived collection of over 560 bioinformatics 'skills' designed to be consumed by AI coding agents (Claude Code, Codex CLI, etc.). Each skill consists of a SKILL.md containing expert guidance, a usage-guide.md, and one or more self-contained example scripts (Python, R, shell). The repository covers the full breadth of bioinformatics—from sequence manipulation, alignment, and variant calling to single-cell, spatial transcriptomics, and causal genomics. The examples are meticulously commented with version-pinned dependencies and explicit warnings against common pitfalls, reflecting a strong pedagogical focus. The repository is not a live application or library; it is a static knowledge base that has been archived with no further updates planned. Its primary value lies in the expert-compiled recipes and anti-pattern guidance that can steer AI-generated code toward correct methodology.

MetaXcan is a command-line and library framework for transcriptome-wide association studies (TWAS). It integrates GWAS summary statistics or individual-level genotype data with gene expression prediction models to compute gene-level association statistics. The core methods implemented are S-PrediXcan (summary-based), PrediXcan (individual-level), MultiXcan, and S-MultiXcan (multi-tissue meta-analysis). The architecture consists of Python scripts that orchestrate data processing steps (e.g., parsing GWAS, aligning alleles, computing z-scores) using a core library (`metax`) with modules for genotype reading, GWAS loading, prediction model management, and covariance matrix handling. The system is designed for bioinformatics researchers and requires external reference data (e.g., GTEx models, 1000 Genomes LD). While functional, the codebase exhibits significant technical debt: Python 2 compatibility remnants, deprecated modules, hardcoded URLs, and limited test coverage. The GUI component (Tkinter) is unmaintained. The repository is hybrid, containing both application scripts and data processing pipelines, but the dominant character is a software tool for running TWAS analyses.

Prokka is a Perl command-line tool for rapid annotation of prokaryotic genomes (bacteria, archaea, and viruses). It takes a FASTA genome assembly as input and produces GFF3, GenBank, and other standard annotation formats by running a pipeline of external tools: Prodigal for CDS prediction, Aragorn/Barrnap/RNAmmer for tRNA/rRNA, Infernal/Rfam for ncRNA, BLAST+ and HMMER3 for functional annotation against curated databases (Swiss-Prot, HAMAP, ISfinder, NCBI AMR). The architecture is a monolithic Perl script with helper scripts for database building and maintenance. While widely used and highly cited, the repository is explicitly unmaintained by the original author (who recommends migration to Bakta), dependencies are dated, and many internal scripts lack automated testing. Bundled components like the SwissKnife Perl modules for UniProt parsing are self-contained and potentially reusable in other bioinformatics pipelines.