salmon-rna-quantification
Ultra-fast RNA-seq transcript/gene quantification via quasi-mapping (no BAM). Builds a k-mer index from transcriptome FASTA, quantifies in minutes. Outputs TPM/count tables (quant.sf) with optional GC- and sequence-bias correction. Integrates with tximeta/tximport for DESeq2/edgeR.
Install / Use
npx skills add jaechang-hits/SciAgent-Skills --skill salmon-rna-quantificationInstalls into whichever agent you are using.
SKILL.md
Installable skill definition
Quality Score
Category
MarketingSupported Platforms
Tags
Our assessment of salmon-rna-quantification
salmon-rna-quantification scores 91/100 on our quality scale, 233rd of 649 Marketing skills we index (top 36%).
Its SKILL.md is 16 KB long, well organised into 49 sections with 12 code examples: a thorough specification that gives an agent plenty to work with.
It has 367 GitHub stars, a meaningful sign that others use it.
Maintenance, license and trust
- The repository was last updated about 3 months ago, so salmon-rna-quantification is actively maintained.
- Our last check on 2026-11-20 found the source still online.
- No license is declared. By default that means all rights are reserved: you can read it, but reusing or redistributing it is not clearly permitted. Ask the author before building on it commercially.
- Its trust signals score 88/100, with 1 caution from licensing, adoption, age or documentation. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.
Safety scan
No issues foundOur scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.
AI review by kimi-k2.7-code on 2026-10-05. Automated pattern scan on 2026-10-05. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.
salmon-rna-quantification compared with similar skills
All 4 of these similar skills score higher than salmon-rna-quantification; compare them before choosing.
| Skill | Score | Stars | Updated | Format |
|---|---|---|---|---|
| salmon-rna-quantification (this skill)by jaechang-hits | 91 | 367 | 3mo ago | SKILL.md |
| algorithmic-artby anthropics | 100 | 177.9k | 58d ago | SKILL.md |
| pptxby anthropics | 100 | 177.9k | 58d ago | SKILL.md |
| prospectingby coreyhaines31 | 100 | 60.1k | 8d ago | SKILL.md |
| ad-creativeby coreyhaines31 | 100 | 60.1k | 8d ago | SKILL.md |
Frequently asked questions
- How do I install salmon-rna-quantification?
- Run
npx skills add jaechang-hits/SciAgent-Skills --skill salmon-rna-quantification. The install tabs above show the steps for each supported agent. - Which AI agents does salmon-rna-quantification work with?
- It is written for Universal, as a SKILL.md file. Other agents that read the same format can often use it too.
- Is salmon-rna-quantification safe to use?
- Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It declares no license and scores 88/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
- Is salmon-rna-quantification still maintained?
- The repository was last updated about 3 months ago, so salmon-rna-quantification is actively maintained.
Skill content
View source on GitHubname: "salmon-rna-quantification" description: "Ultra-fast RNA-seq transcript/gene quantification via quasi-mapping (no BAM). Builds a k-mer index from transcriptome FASTA, quantifies in minutes. Outputs TPM/count tables (quant.sf) with optional GC- and sequence-bias correction. Integrates with tximeta/tximport for DESeq2/edgeR. Use STAR when a genome-aligned BAM is needed." license: "GPL-3.0"
Salmon — Fast RNA-seq Quantification
Overview
Salmon quantifies transcript abundance from RNA-seq reads using quasi-mapping — matching reads to a k-mer index of the transcriptome without full genome alignment. This makes Salmon 20–50× faster than alignment-based tools while producing accurate TPM and estimated count values. Salmon corrects for sequence-specific bias (--seqBias), GC-content bias (--gcBias), and fragment length distribution automatically. Output quant.sf files integrate directly with tximeta (R) or pydeseq2 (Python) for differential expression analysis. For improved accuracy, decoy-aware indexing uses the full genome to identify spurious quasi-mappings.
When to Use
- Performing fast RNA-seq quantification when you do not need a genome-aligned BAM file
- Running large-scale RNA-seq studies where alignment speed is a bottleneck (Salmon is 20-50× faster than STAR + featureCounts)
- Computing TPM and estimated counts from bulk RNA-seq for differential expression with DESeq2 or edgeR
- Correcting for GC bias, fragment length, and sequence context bias with
--gcBias --seqBias - Estimating transcript-level uncertainty via bootstrap resampling with
--numBootstraps - Use STAR instead when you need a genome-aligned BAM for downstream tools (variant calling, deeptools, IGV visualization)
- Use Kallisto as an alternative for similar speed; Salmon provides better bias correction and decoy-aware indexing
Prerequisites
- Software: Salmon ≥ 1.10 (conda or pre-compiled binary)
- Reference: transcriptome FASTA (cDNA sequences, e.g., GENCODE or Ensembl) + genome FASTA for decoy-aware indexing
- Python packages:
pandasfor parsing output;pydeseq2for differential expression
Check before installing: The tool may already be available in the current environment (e.g., inside a
pixi/condaenv). Runcommand -v salmonfirst and skip the install commands below if it returns a path. When running inside a pixi project, invoke the tool viapixi run salmonrather than baresalmon.
# Install with conda (recommended)
conda install -c bioconda salmon
# Verify
salmon --version
# salmon 1.10.3
# Or download pre-compiled binary
wget https://github.com/COMBINE-lab/salmon/releases/download/v1.10.0/salmon-1.10.0_linux_x86_64.tar.gz
tar xzvf salmon-1.10.0_linux_x86_64.tar.gz
export PATH="$PWD/salmon-latest_linux_x86_64/bin:$PATH"
Pre-flight Interview
Settle these with the user before writing any analysis code.
decisions:
- id: D1
param: reference
kind: required
source: user
ask: "Which reference bundle should be used: species, genome assembly, and annotation release?"
default: null
- id: D2
param: decoyAwareIndex
kind: derived
source: upstream
depends_on: [D1]
ask: "Does the selected reference bundle include a matching genome FASTA for building a decoy-aware index?"
default: true
- id: D3
param: libType
kind: required
source: data
ask: "Salmon inferred this library type from representative reads. Does it agree with the library preparation?"
default: "A; inspect and confirm the inferred type in aux_info/meta_info.json"
- id: D4
param: biasCorrection
kind: optional
source: literature
ask: "Should sequence- and GC-composition bias correction be enabled for cross-sample quantification?"
default:
seqBias: true
gcBias: true
- id: D5
param: numBootstraps
kind: optional_conditional
source: upstream
ask: "Will downstream analysis use inferential replicates (e.g., Swish/fishpond or sleuth)?"
default: 0
- id: D6
param: selectiveAlignment
kind: optional
source: literature
ask: "Should selective alignment with range-factorized equivalence classes be used for this quantification?"
default:
validateMappings: true
rangeFactorizationBins: 4
- id: D7
param: threads
kind: never_ask
source: data
reason: "Uses available CPU cores to affect runtime only, not quantification."
default: "min(8, available_cores)"
D2 depends on D1 because the transcriptome and decoy genome must be from the same reference release. D3 is a required confirmation after inspecting Salmon's inferred library type; an ambiguous or unexpected inference is a QC failure.
Quick Start
# 1. Build transcriptome index (~5 min)
salmon index -t transcriptome.fa -i salmon_index/ -p 8
# 2. Quantify paired-end reads (~2-5 min per sample)
salmon quant \
-i salmon_index/ \
-l A \
-1 sample_R1.fastq.gz \
-2 sample_R2.fastq.gz \
-p 8 \
--gcBias --validateMappings \
-o results/sample1/
# Output: results/sample1/quant.sf
head results/sample1/quant.sf
Workflow
Step 1: Download Transcriptome Reference
Fetch a transcript FASTA from GENCODE or Ensembl (cDNA sequences only — not genome).
# Human transcriptome from GENCODE (recommended)
wget https://ftp.ebi.ac.uk/pub/databases/gencode/Gencode_human/release_47/gencode.v47.transcripts.fa.gz
gunzip gencode.v47.transcripts.fa.gz
# Count transcripts
grep -c "^>" gencode.v47.transcripts.fa
# ~252,000 transcripts
echo "Reference ready."
ls -lh gencode.v47.transcripts.fa
Step 2: Build Salmon Index
Index the transcriptome for quasi-mapping. Add genome decoys for improved accuracy.
# Standard index (fast, sufficient for most analyses)
salmon index \
-t gencode.v47.transcripts.fa \
-i salmon_index/ \
-p 8
echo "Standard index complete."
# Decoy-aware index (recommended for accuracy — uses full genome as decoy)
# Step 1: create decoy list from genome chromosome names
grep "^>" GRCh38.primary_assembly.genome.fa | cut -d " " -f 1 | sed 's/>//' > decoys.txt
# Step 2: concatenate transcriptome + genome
cat gencode.v47.transcripts.fa GRCh38.primary_assembly.genome.fa > gentrome.fa
# Step 3: build decoy-aware index
salmon index \
-t gentrome.fa \
-d decoys.txt \
-i salmon_decoy_index/ \
-p 8
echo "Decoy-aware index complete."
Step 3: Quantify Single-End Reads
Run Salmon on single-end FASTQ files.
# Single-end quantification
salmon quant \
-i salmon_index/ \
-l A \
-r sample1.fastq.gz \
-p 8 \
--seqBias \
--validateMappings \
-o results/sample1/
echo "Mapping rate: $(grep 'Mapping rate' results/sample1/logs/salmon_quant.log | tail -1)"
echo "Output: results/sample1/quant.sf"
Step 4: Quantify Paired-End Reads with Bias Correction
Run Salmon on paired-end FASTQ files with recommended bias correction flags.
# Paired-end with GC bias + sequence bias correction
salmon quant \
-i salmon_decoy_index/ \
-l A \
-1 sample1_R1.fastq.gz \
-2 sample1_R2.fastq.gz \
-p 8 \
--gcBias \
--seqBias \
--validateMappings \
--numBootstraps 100 \
-o results/sample1/
# quant.sf columns: Name, Length, EffectiveLength, TPM, NumReads
head results/sample1/quant.sf
Step 5: Load and Summarize Quantification Output
Parse quant.sf to build a gene-level count matrix for differential expression.
import pandas as pd
from pathlib import Path
# Load single-sample output
quant = pd.read_csv("results/sample1/quant.sf", sep="\t")
print(f"Transcripts quantified: {len(quant)}")
print(f"Total estimated reads: {quant['NumReads'].sum():.0f}")
print(f"Transcripts with TPM > 1: {(quant['TPM'] > 1).sum()}")
print(quant.sort_values("TPM", ascending=False).head())
# Build a multi-sample TPM matrix
samples = ["ctrl_1", "ctrl_2", "treat_1", "treat_2"]
tpm_matrix = pd.DataFrame({
s: pd.read_csv(f"results/{s}/quant.sf", sep="\t").set_index("Name")["TPM"]
for s in samples
})
print(f"\nTPM matrix: {tpm_matrix.shape}")
tpm_matrix.to_csv("tpm_matrix.tsv", sep="\t")
Step 6: Aggregate to Gene Level and Run DESeq2
Summarize transcript-level estimates to gene level and perform differential expression.
import pandas as pd
import re
from pathlib import Path
from pydeseq2.dds import DeseqDataSet
from pydeseq2.default_inference import DefaultInference
from pydeseq2.ds import DeseqStats
# Aggregate transcript counts to gene level using Ensembl gene IDs
# quant.sf Name format: "ENST00000456328.2|ENSG00000223972.6|..."
def extract_gene_id(transcript_id):
parts = transcript_id.split("|")
return parts[1].split(".")[0] if len(parts) > 1 else transcript_id
samples = ["ctrl_1", "ctrl_2", "treat_1", "treat_2"]
count_frames = []
for s in samples:
df = pd.read_csv(f"results/{s}/quant.sf", sep="\t")
df["gene_id"] = df["Name"].apply(extract_gene_id)
gene_counts = df.groupby("gene_id")["NumReads"].sum().round().astype(int)
count_frames.append(gene_counts.rename(s))
count_matrix = pd.DataFrame(count_frames).fillna(0).astype(int)
metadata = pd.DataFrame({
"condition": ["control", "control", "treated", "treated"]
}, index=samples)
# Run DESeq2
dds = DeseqDataSet(counts=count_matrix, metadata=metadata,
design_factors="condition",
inference=DefaultInference(n_cpus=4))
dds.deseq2()
stat_res = DeseqStats(dds, contrast=["condition", "treated", "control"],
inference=DefaultInference())
stat_res.summary()
results = stat_res.results_df
print(f"DE genes (padj < 0.05): {(results['padj'] < 0.05).sum()}")
print(results[results['padj'] < 0.05].sort_values('log2FoldChange').head())
Key Parameters
| Parameter | Default | Range/Options | Effect |
|-----------|---------|---------------|--------|
| -l / --libType | required | A (auto), SF, SR, IU, IS, MS, MR | Library strandedness; A auto-detects from first reads |
| -p / --threads | 1 | 1–64 | CPU threads; 8–16 is typical |
| --gcBias | off | flag | Correct for GC-content bias in fragment selection; recommended for most samples |
| --seqBias | off | flag | Correct for sequence-specific bias at read starts; recommended |
| --validateMappings | off | flag | Use selective alignment for improved accuracy; slight speed cost |
| --numBootstraps | 0 | 0–200 | Bootstrap replicates for uncertainty estimation; enables Sleuth/Swish |
| --dumpCsvCounts | off | flag | Dump raw counts to CSV alongside quant.sf |
| -d / --decoys | — | file | Decoy sequence list for decoy-aware indexing |
| --rangeFactorizationBins | 4 | 1–8 | Bins for range-factorization model; increases accuracy at small speed cost |
| --skipQuant | off | flag | Build index and exit; useful for cluster pipelines |
Common Recipes
Recipe 1: Batch Quantify All Samples
#!/bin/bash
# Quantify all paired-end samples with recommended settings
INDEX="salmon_decoy_index"
DATA="data"
OUT="results"
THREADS=12
SAMPLES=(ctrl_1 ctrl_2 treat_1 treat_2)
mkdir -p "$OUT"
for sample in "${SAMPLES[@]}"; do
echo "Quantifying: $sample"
salmon quant \
-i "$INDEX" \
-l A \
-1 "$DATA/${sample}_R1.fastq.gz" \
-2 "$DATA/${sample}_R2.fastq.gz" \
-p "$THREADS" \
--gcBias --seqBias --validateMappings \
-o "$OUT/$sample/"
echo "Done: $sample — mapping $(grep 'Mapping rate' $OUT/$sample/logs/salmon_quant.log | tail -1)"
done
echo "All samples quantified."
Recipe 2: Add Salmon to a Snakemake Pipeline
# Snakefile — Salmon quantification rule
configfile: "config.yaml"
SAMPLES = config["samples"]
rule all:
input:
expand("results/{sample}/quant.sf", sample=SAMPLES)
rule salmon_index:
input:
transcriptome = config["transcriptome_fa"]
Truncated for display — read the full file on GitHub.
Related Skills
algorithmic-art
177.9kCreating algorithmic art using p5.js with seeded randomness and interactive parameter exploration. Use this when users request creating art using code, generative art, algorithmic art, flow fields, or particle systems.
pptx
177.9kUse this skill any time a .pptx or .potx file is involved in any way — as input, output, or both. This includes: creating slide decks, pitch decks, or presentations; reading, parsing, or extracting text from any .pptx or .potx file (even if the extracted content will be used elsewhere, like in an em…
prospecting
60.1kWhen the user wants to find and qualify prospects for outbound, or asks who to target first, which signal to prioritize, or where to spot buyers with the problem: buying signals, enrichment, verification, account research.
ad-creative
60.1kWhen the user wants to write or judge ad creative, or asks which ad, hook, or angle to run or kill: headlines, primary text, and variations for Google, Meta, LinkedIn, and TikTok, fresh angles when creative fatigues. Test hypotheses name the metric, comparison, and expected direction.
Languages
Trust signals
From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.
