Sailfish v0.7.2

Changes: v0.7.2 adds the ability to select the Variational Bayesian EM algorithm for optimization in place of the "regular" EM algorithm. This mode is selected by passing --useVBOpt to sailfish's quant command.

Note: v0.7.1 introduces no new features over v0.7.0 but fixes some build issues on OSX.

This release brings some long-standing bug-fixes and some substantial improvements to Sailfish. The code is also being cleaned up and trimmed down. There is no longer a dependency on Shark, so building should be easier than before. A number of header-only external dependencies have been included in the source tree to further ease build issues. Sailfish now adopts Salmons library format strings, reducing the need for difficult escape sequences when placing these strings in shell scripts. This new version of Sailfish also adopts the quasi-mapping approach from RapMap to provide transcripts and position hits for reads, leading to a substantial reduction in runtime and an improvement in accuracy under a number of scenarios.

NOTE: Since v0.7.0 the format of the output (the quant.sf file) written by Sailfish has changed. The RPKM, KPKM and EstNumKmers columns are no longer present. The output format is now equivalent to that of Salmon, and reports, for each record, (1) Transcript Name, (2) Transcript Length, (3) TPM, (4) Estimated Number of Reads. Please be aware of this to make the appropriate changes for tools that perform downstream processing with Sailfish's output.

Sailfish v0.7.1

This release brings some long-standing bug-fixes and some substantial improvements to Sailfish. The code is also being cleaned up and trimmed down. There is no longer a dependency on Shark, so building should be easier than before. A number of header-only external dependencies have been included in the source tree to further ease build issues. Sailfish now adopts Salmons library format strings, reducing the need for difficult escape sequences when placing these strings in shell scripts. This new version of Sailfish also adopts the quasi-mapping approach from RapMap to provide transcripts and position hits for reads, leading to a substantial reduction in runtime and an improvement in accuracy under a number of scenarios.

Note: v0.7.1 introduces no new features over v0.7.0 but fixes some build issues on OSX.

NOTE: Since v0.7.0 the format of the output (the quant.sf file) written by Sailfish has changed. The RPKM, KPKM and EstNumKmers columns are no longer present. The output format is now equivalent to that of Salmon, and reports, for each record, (1) Transcript Name, (2) Transcript Length, (3) TPM, (4) Estimated Number of Reads. Please be aware of this to make the appropriate changes for tools that perform downstream processing with Sailfish's output.

Sailfish v0.7.0

This release brings some long-standing bug-fixes and some substantial improvements to Sailfish. The code is also being cleaned up and trimmed down. There is no longer a dependency on Shark, so building should be easier than before. A number of header-only external dependencies have been included in the source tree to further ease build issues. Sailfish now adopts Salmons library format strings, reducing the need for difficult escape sequences when placing these strings in shell scripts. This new version of Sailfish also adopts the quasi-mapping approach from RapMap to provide transcripts and position hits for reads, leading to a substantial reduction in runtime and an improvement in accuracy under a number of scenarios.

NOTE: Since v0.7.0 the format of the output (the quant.sf file) written by Sailfish has changed. The RPKM, KPKM and EstNumKmers columns are no longer present. The output format is now equivalent to that of Salmon, and reports, for each record, (1) Transcript Name, (2) Transcript Length, (3) TPM, (4) Estimated Number of Reads. Please be aware of this to make the appropriate changes for tools that perform downstream processing with Sailfish's output.

Salmon Beta v0.3.0

What is Salmon?

It's a type of fish! But, in the context of RNA-seq, it's the
successor to Sailfish (a rapid "alignment-free" method for transcript
quantification from RNA-seq reads).

Why use Salmon?

Well, Salmon is designed with a lot of what we learned from Sailfish
in mind. We're still adding to and improving Salmon, but it already
has a number of benefits over Sailfish; for example:

• Salmon can make better use of paired-end information than Sailfish. The
  algorithm used in Salmon considers both ends of a paired-end read
  simultaneously, rather than independently as does Sailfish. Therefore it is
  able to make use of any increased specificity that results from this
  information.
• Salmon has a smaller memory footprint that Sailfish. While the
  quantification phase of Sailfish already has a fairly compact memory
  footprint, Salmon's is even smaller. Additionally, building the Salmon index
  (which is only required if you don't use the alignment-based mode) requires
  substantially less memory, and can be faster, than building the Sailfish
  index.
• Salmon can use (but doesn't require) pre-computed alignments. If you want,
  you can use Salmon much like Sailfish, by building an index and feeding it
  raw reads. However, if you already have reads from your favorite, super-fast
  aligner (cough cough maybe STAR), you can use them with Salmon to quantify
  the transcript abundances.
• Salmon is fast --- in all of our testing so far, it's actually faster than
  Sailfish (though the same relationship doesn't hold between the actual fish).

Further details are contained in the online documentation.

What's New

Version 0.3.0

fixes a number of small but important bugs that popped up in previous versions. Specifically, sometimes a small number of reads would be ignored when using the sampling option in alignment-based salmon, resulting in not all of the reads having their alignments sampled in the output. Also, a bug in one of the concurrent queue implementations used by salmon was causing a segfault, when using the mapping cache, on certain data sets, under heavy contention. While a full solution to this bug is underway, it can be avoided by disabling thread-local storage in the queue (which has been done in this release and eliminates the bug).

Also, version 0.3.0 adds a new and substantially improved alignment model. It incorporates spatially-varying features of alignments, but also allows for alignments of unrestricted length or number of gaps. While this model is still officially experimental (it must be enabled with --useErrorModel), it has been fairly well-tested and can improve accuracy measurably in certain cases (but doesn't hurt accuracy in any case we've encountered).

Finally, this release replaces Shark's implementation of PCA with a simple custom implementation built using the header-only library eigen (now included with the source). This finally eliminates the dependency on the shark library, and thus, allows salmon to be compiled with versions of Boost newer that 1.55.

Version 0.2.7

adds an in-memory cache for alignment-based salmon just like the cache for read-based salmon that was added in v0.2.5. This significantly speed up inference for bam files where the number of mapping reads is less than the in-memory alignment cache size (which can be set with --mappingCacheMemoryLimit). This version also fixed a bug where for small files, the fragment length distribution might not have been taken into account when computing alignment likelihoods.

Version 0.2.6

fixes a significant bug in 0.2.5 which prevented the proper parsing of single-end read libraries.

Version 0.2.5

significantly speeds up read-based salmon on small datasets by keeping the mapping cache in memory. It also fixes a concurrency-related bug in alignment-based salmon that could result in some input alignments being skipped (again, this issue was most prevalent on relatively small datasets). There are also further, general stability, speed, and error-reporting improvements.

Version 0.2.3

fixes a very rare but potentially frustrating bug in v0.2.2, where read-based salmon could encounter a race condition when using the mapping cache and dealing with very small data sets.

Salmon Beta v0.2.7

What is Salmon?

It's a type of fish! But, in the context of RNA-seq, it's the
successor to Sailfish (a rapid "alignment-free" method for transcript
quantification from RNA-seq reads).

Why use Salmon?

Well, Salmon is designed with a lot of what we learned from Sailfish
in mind. We're still adding to and improving Salmon, but it already
has a number of benefits over Sailfish; for example:

• Salmon can make better use of paired-end information than Sailfish. The
  algorithm used in Salmon considers both ends of a paired-end read
  simultaneously, rather than independently as does Sailfish. Therefore it is
  able to make use of any increased specificity that results from this
  information.
• Salmon has a smaller memory footprint that Sailfish. While the
  quantification phase of Sailfish already has a fairly compact memory
  footprint, Salmon's is even smaller. Additionally, building the Salmon index
  (which is only required if you don't use the alignment-based mode) requires
  substantially less memory, and can be faster, than building the Sailfish
  index.
• Salmon can use (but doesn't require) pre-computed alignments. If you want,
  you can use Salmon much like Sailfish, by building an index and feeding it
  raw reads. However, if you already have reads from your favorite, super-fast
  aligner (cough cough maybe STAR), you can use them with Salmon to quantify
  the transcript abundances.
• Salmon is fast --- in all of our testing so far, it's actually faster than
  Sailfish (though the same relationship doesn't hold between the actual fish).

Further details are contained in the online documentation.

What's New

Version 0.2.7 adds an in-memory cache for alignment-based salmon just like the cache for read-based salmon that was added in v0.2.5. This significantly speed up inference for bam files where the number of mapping reads is less than the in-memory alignment cache size (which can be set with --mappingCacheMemoryLimit). This version also fixed a bug where for small files, the fragment length distribution might not have been taken into account when computing alignment likelihoods.

Version 0.2.6 fixes a significant bug in 0.2.5 which prevented the proper parsing of single-end read libraries.

Version 0.2.5 significantly speeds up read-based salmon on small datasets by keeping the mapping cache in memory. It also fixes a concurrency-related bug in alignment-based salmon that could result in some input alignments being skipped (again, this issue was most prevalent on relatively small datasets). There are also further, general stability, speed, and error-reporting improvements.

Version 0.2.3 fixes a very rare but potentially frustrating bug in v0.2.2, where read-based salmon could encounter a race condition when using the mapping cache and dealing with very small data sets.

Salmon Beta v0.2.6

What is Salmon?

It's a type of fish! But, in the context of RNA-seq, it's the
successor to Sailfish (a rapid "alignment-free" method for transcript
quantification from RNA-seq reads).

Why use Salmon?

Well, Salmon is designed with a lot of what we learned from Sailfish
in mind. We're still adding to and improving Salmon, but it already
has a number of benefits over Sailfish; for example:

• Salmon can make better use of paired-end information than Sailfish. The
  algorithm used in Salmon considers both ends of a paired-end read
  simultaneously, rather than independently as does Sailfish. Therefore it is
  able to make use of any increased specificity that results from this
  information.
• Salmon has a smaller memory footprint that Sailfish. While the
  quantification phase of Sailfish already has a fairly compact memory
  footprint, Salmon's is even smaller. Additionally, building the Salmon index
  (which is only required if you don't use the alignment-based mode) requires
  substantially less memory, and can be faster, than building the Sailfish
  index.
• Salmon can use (but doesn't require) pre-computed alignments. If you want,
  you can use Salmon much like Sailfish, by building an index and feeding it
  raw reads. However, if you already have reads from your favorite, super-fast
  aligner (cough cough maybe STAR), you can use them with Salmon to quantify
  the transcript abundances.
• Salmon is fast --- in all of our testing so far, it's actually faster than
  Sailfish (though the same relationship doesn't hold between the actual fish).

Further details are contained in the online documentation.

What's New

Version 0.2.6 fixes a significant bug in 0.2.5 which prevented the proper parsing of single-end read libraries.

Version 0.2.5 significantly speeds up read-based salmon on small datasets by keeping the mapping cache in memory. It also fixes a concurrency-related bug in alignment-based salmon that could result in some input alignments being skipped (again, this issue was most prevalent on relatively small datasets). There are also further, general stability, speed, and error-reporting improvements.

Version 0.2.3 fixes a very rare but potentially frustrating bug in v0.2.2, where read-based salmon could encounter a race condition when using the mapping cache and dealing with very small data sets.

Salmon Beta v0.2.5

What is Salmon?

It's a type of fish! But, in the context of RNA-seq, it's the
successor to Sailfish (a rapid "alignment-free" method for transcript
quantification from RNA-seq reads).

Why use Salmon?

Well, Salmon is designed with a lot of what we learned from Sailfish
in mind. We're still adding to and improving Salmon, but it already
has a number of benefits over Sailfish; for example:

• Salmon can make better use of paired-end information than Sailfish. The
  algorithm used in Salmon considers both ends of a paired-end read
  simultaneously, rather than independently as does Sailfish. Therefore it is
  able to make use of any increased specificity that results from this
  information.
• Salmon has a smaller memory footprint that Sailfish. While the
  quantification phase of Sailfish already has a fairly compact memory
  footprint, Salmon's is even smaller. Additionally, building the Salmon index
  (which is only required if you don't use the alignment-based mode) requires
  substantially less memory, and can be faster, than building the Sailfish
  index.
• Salmon can use (but doesn't require) pre-computed alignments. If you want,
  you can use Salmon much like Sailfish, by building an index and feeding it
  raw reads. However, if you already have reads from your favorite, super-fast
  aligner (cough cough maybe STAR), you can use them with Salmon to quantify
  the transcript abundances.
• Salmon is fast --- in all of our testing so far, it's actually faster than
  Sailfish (though the same relationship doesn't hold between the actual fish).

Further details are contained in the online documentation.

What's New

Version 0.2.5 significantly speeds up read-based salmon on small datasets by keeping the mapping cache in memory. It also fixes a concurrency-related bug in alignment-based salmon that could result in some input alignments being skipped (again, this issue was most prevalent on relatively small datasets). There are also further, general stability, speed, and error-reporting improvements.

Version 0.2.3 fixes a very rare but potentially frustrating bug in v0.2.2, where read-based salmon could encounter a race condition when using the mapping cache and dealing with very small data sets.

Salmon Beta v0.2.3

What is Salmon?

It's a type of fish! But, in the context of RNA-seq, it's the
successor to Sailfish (a rapid "alignment-free" method for transcript
quantification from RNA-seq reads).

Why use Salmon?

Well, Salmon is designed with a lot of what we learned from Sailfish
in mind. We're still adding to and improving Salmon, but it already
has a number of benefits over Sailfish; for example:

• Salmon can make better use of paired-end information than Sailfish. The
  algorithm used in Salmon considers both ends of a paired-end read
  simultaneously, rather than independently as does Sailfish. Therefore it is
  able to make use of any increased specificity that results from this
  information.
• Salmon has a smaller memory footprint that Sailfish. While the
  quantification phase of Sailfish already has a fairly compact memory
  footprint, Salmon's is even smaller. Additionally, building the Salmon index
  (which is only required if you don't use the alignment-based mode) requires
  substantially less memory, and can be faster, than building the Sailfish
  index.
• Salmon can use (but doesn't require) pre-computed alignments. If you want,
  you can use Salmon much like Sailfish, by building an index and feeding it
  raw reads. However, if you already have reads from your favorite, super-fast
  aligner (cough cough maybe STAR), you can use them with Salmon to quantify
  the transcript abundances.
• Salmon is fast --- in all of our testing so far, it's actually faster than
  Sailfish (though the same relationship doesn't hold between the actual fish).

Further details are contained in the online documentation.

What's New

Version 0.2.3 fixes a very rare but potentially frustrating bug in v0.2.2, where read-based salmon could encounter a race condition when using the mapping cache and dealing with very small data sets.

Latest successful Salmon build from Travis-CI

TravisCI Tag

TravisCI Tag

Salmon Beta v0.2.2

What is Salmon?

It's a type of fish! But, in the context of RNA-seq, it's the
successor to Sailfish (a rapid "alignment-free" method for transcript
quantification from RNA-seq reads).

Why use Salmon?

Well, Salmon is designed with a lot of what we learned from Sailfish
in mind. We're still adding to and improving Salmon, but it already
has a number of benefits over Sailfish; for example:

• Salmon can make better use of paired-end information than Sailfish. The
  algorithm used in Salmon considers both ends of a paired-end read
  simultaneously, rather than independently as does Sailfish. Therefore it is
  able to make use of any increased specificity that results from this
  information.
• Salmon has a smaller memory footprint that Sailfish. While the
  quantification phase of Sailfish already has a fairly compact memory
  footprint, Salmon's is even smaller. Additionally, building the Salmon index
  (which is only required if you don't use the alignment-based mode) requires
  substantially less memory, and can be faster, than building the Sailfish
  index.
• Salmon can use (but doesn't require) pre-computed alignments. If you want,
  you can use Salmon much like Sailfish, by building an index and feeding it
  raw reads. However, if you already have reads from your favorite, super-fast
  aligner (cough cough maybe STAR), you can use them with Salmon to quantify
  the transcript abundances.
• Salmon is fast --- in all of our testing so far, it's actually faster than
  Sailfish (though the same relationship doesn't hold between the actual fish).

Further details are contained in the online documentation.

What's New

Version 0.2.2 includes a number of improvements and bug fixes, including a new logger and fewer dependencies. The other big addition is the implementation of a "mapping cache" in read-based quantification mode (this is described in the documentation). This should substantially speed up salmon for smaller experiments.