# IQ-TREE vs RAxML-NG vs FastTree

> On clean data IQ-TREE, RAxML-NG and FastTree return nearly the same tree, so the choice comes down to run time and to what the support numbers mean. We simulated alignments on known trees to measure both, and show where FastTree's speed costs branches and which of its warnings you can trust.

## Which is better, IQ-TREE, RAxML-NG or FastTree?

On a clean alignment, none of the three builds a clearly better tree; they differ in run time and in what their support numbers mean. We simulated five alignments of 100 DNA sequences and 1,000 columns each on random trees we kept, and ran [IQ-TREE](/app/iq-tree), [RAxML-NG](/app/raxml-ng) and [FastTree](/app/fasttree) on one core with the substitution model that generated the data.

Of the 97 internal branches of each true tree, IQ-TREE and RAxML-NG got 4.2 wrong on average and FastTree 4.6. The run times did not look alike: 5 seconds for FastTree, 83 for IQ-TREE and 6 minutes for RAxML-NG.

The catch is in the scores. IQ-TREE and RAxML-NG reached the same log-likelihood to within 0.1 in every replicate. FastTree matched them in three and fell 29 and 53 units short in the other two, and in the worse one nine of its 97 branches were wrong, against four for IQ-TREE and three for RAxML-NG.

A higher likelihood still does not mean a truer tree. IQ-TREE and RAxML-NG scored higher than the true tree in all five replicates, so a better likelihood is evidence of a better search, not of a better tree. What separates the programs is the cost of that search, how the cost grows with the number of sequences, and what the numbers on the branches mean.

## RAxML 8 and RAxML-NG

Searches for "RAxML" cover two programs. Stamatakis's RAxML 8 is the classic one. RAxML-NG is the from-scratch rewrite by Kozlov, Stamatakis and colleagues, and its tutorial says it replaces standard RAxML as well as the cluster version ExaML. Every RAxML result below, and the program hosted on ProteinIQ, is RAxML-NG.

Version 2.0 added adaptive search heuristics and automatic model selection. We ran release 2.0.2, the same binary the hosted tool uses, and gave it a model on the command line so the comparison is about the search. Older tutorials describe a fixed 20 starting trees; that text predates 2.0.

## How each program searches for a tree

IQ-TREE combines hill climbing with a stochastic perturbation of the best tree found so far, and stops when new rounds stop improving it. Unless you pass a model, it first runs ModelFinder, which compares substitution models and rate-heterogeneity models before the search starts. We ran version 3.1.1.

RAxML-NG 2.0.2 predicts how hard the alignment is and sets the number of starting trees from that prediction. The logs of our runs show between 3 starting trees for a 50-sequence alignment and 11 for the hardest 100-sequence one, each followed by a greedy tree search. That is why its default is thorough and slow, and why a single start tree (`--search1`) is a very different run.

FastTree takes a different route. It builds a neighbor-joining tree with heuristics, improves it with minimum-evolution moves and then a limited maximum-likelihood search, and models rate variation with a per-site rate (the CAT approximation) instead of a full gamma mixture. Its `-gamma` option rescales branch lengths and computes a gamma likelihood so that scores are more comparable across runs. We compiled the 2.2.0 source.

Each design shows its limit in the literature. Price and colleagues found FastTree slightly more accurate than PhyML 3 with default settings but not as accurate as methods with more intensive topology searches, and noted that most of the splits it misses are poorly supported.

Zhou and colleagues tested four programs on 19 empirical phylogenomic datasets with up to 200 taxa. In the concatenated analyses IQ-TREE reached the best likelihood on every dataset, RAxML and ExaML came close, and FastTree was fastest but produced lower likelihoods and more dissimilar topologies.

The RAxML-NG authors report the opposite ordering on taxon-rich datasets, where RAxML-NG typically finds higher-scoring trees than IQ-TREE although IQ-TREE is more stable. The two reports use different datasets and older versions. Our replicates do not arbitrate between them, because the two programs tied in every one.

## How long each one takes

The cost of a search is the easiest thing to measure and the hardest to guess. We simulated one alignment of 1,000 DNA columns at each of 50, 100, 200 and 400 sequences and timed each program on one core (Figure 1). Several single-core jobs shared the machine, so the times compare programs with each other and are not benchmarks of the hardware.

![Line chart on a logarithmic axis of wall-clock seconds against 50, 100, 200 and 400 sequences for FastTree, IQ-TREE with a fixed model, RAxML-NG with its default search and RAxML-NG with one start tree](/images/charts/iqtree-raxml-fasttree-runtime-by-sequences.webp "**Figure 1. Run time by number of sequences on one core.** One simulated alignment per size, 1,000 DNA columns, GTR+G4 for IQ-TREE and RAxML-NG and GTR with gamma for FastTree. The RAxML-NG default run at 400 sequences did not finish and is left out.")

FastTree took 2.2 seconds at 50 sequences and 15.3 at 400. IQ-TREE went from 29 to 316 seconds, and running ModelFinder first added 46 seconds at 100 sequences and 391 at 400. RAxML-NG's default search was the quicker of the two full searches at 50 sequences (17 against 29 seconds) but needed 1,166 seconds at 200, nine times IQ-TREE's 131. With one start tree it took 127 seconds at 200 and 458 at 400.

The order changes with the alignment type. On three protein alignments of 100 sequences and 400 amino acids under LG+G4, IQ-TREE took 11 to 13 minutes, RAxML-NG 5 to 6 minutes and FastTree about 9 seconds. The three programs scored within 0.01 log-likelihood units of each other, and FastTree's tree had exactly the same number of wrong branches as IQ-TREE's in all three.

All of this is on one core. IQ-TREE and RAxML-NG both spread a search across cores, while FastTreeMP parallelizes only the neighbor-joining stage, about 1.5 to 1.7 times faster on three CPUs. The [scripts, commands and results for every run](/data/guides/iqtree-vs-raxml-vs-fasttree/README.txt) are available to download. Time matters less once you know what it buys, which is the next question.

## How close each tree is to the truth

A real alignment has no answer key, so we simulated one. IQ-TREE's alignment simulator generated five alignments of 100 sequences and 1,000 columns on random Yule-Harding trees, under GTR with gamma-distributed rates (α = 0.7). Each program got the matching model, and we scored every tree's log-likelihood with IQ-TREE under the same GTR+G4 so that the scores are comparable.

This is the friendliest test there is. The model is right, nothing is missing and the alignment is perfect, so only the search can differ. Real data separates programs more, which is why the empirical benchmark above matters.

  <caption><strong>Table 1. Five simulated alignments of 100 DNA sequences, 1,000 columns, one core.</strong> Wrong branches are the internal branches of the estimated tree that are absent from the true tree, out of 97, averaged over five replicates. The last column is the largest log-likelihood gap to the best tree found in any replicate. Differences of under one branch are within noise at five replicates.</caption>
  <thead>
    <tr>
      <th scope="col">Program and setting</th>
      <th scope="col">Mean run time</th>
      <th scope="col">Mean wrong branches</th>
      <th scope="col">Largest log-likelihood gap</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>FastTree, GTR with gamma</td>
      <td>5 s</td>
      <td>4.6</td>
      <td>53.2</td>
    </tr>
    <tr>
      <td>IQ-TREE, GTR+G4</td>
      <td>83 s</td>
      <td>4.2</td>
      <td>0.00</td>
    </tr>
    <tr>
      <td>IQ-TREE, ModelFinder first</td>
      <td>154 s</td>
      <td>4.0</td>
      <td>0.04</td>
    </tr>
    <tr>
      <td>RAxML-NG, default search</td>
      <td>360 s</td>
      <td>4.2</td>
      <td>0.00</td>
    </tr>
    <tr>
      <td>RAxML-NG, one start tree</td>
      <td>36 s</td>
      <td>3.8</td>
      <td>0.10</td>
    </tr>
  </tbody>

RAxML-NG's full search took ten times as long as a single start tree and found trees of the same quality, and IQ-TREE's extra ModelFinder minute changed nothing either. The exception is FastTree's score, and scores need care.

A likelihood is the quantity these programs maximize, not the quantity you care about. IQ-TREE and RAxML-NG finished above the true tree in all five replicates, by 0.3 to 5.7 units, because 1,000 columns of noise let a wrong tree fit slightly better than the right one.

FastTree's two low scores were not noise. In replicate 23 its tree sat 53 units below the others, and nine of its 97 branches were wrong, against four for IQ-TREE and three for RAxML-NG. Comparing the FastTree and IQ-TREE trees would have shown it: they differed by six branches. In replicate 24 the gap was 29 units and the branch counts were equal.

FastTree also told us where it was unsure. Every one of its nine wrong branches in replicate 23 carried local support of 0.93 or less, and three scored below 0.01. The price of that warning is that 16 of its 88 correct branches fell below 0.95 as well. Used as a first pass, FastTree plus a second program on the weakly supported part is cheaper than running the second program on everything.

## What the numbers on the branches mean

The three programs print three different quantities, and none of them is the probability that a branch is true. IQ-TREE's ultrafast bootstrap approximates the standard bootstrap far faster, and its developers report that its values are less conservative than the standard bootstrap's, with 95 corresponding roughly to a 95% chance that the clade is real in their simulations. They also say not to compare the two scales directly.

RAxML-NG reports a standard [bootstrap value](/guides/phylogenetic-tree#bootstrap-values-how-much-to-trust-each-branch), the percentage of resampled alignments whose tree contains the branch. FastTree reports SH-like local support from 1,000 resamples of the site likelihoods without re-optimizing branch lengths, written as a fraction between 0 and 1. A FastTree 0.95 is neither a bootstrap of 95 nor an ultrafast bootstrap of 95.

To see what each scale delivers, we simulated eight more alignments of 100 sequences with only 300 columns and branch lengths halved, so that some branches are genuinely uncertain. Each program built its tree with its own support, and we checked every internal branch, about 776 per program, against the true tree. Between 88% and 90% of each program's branches were correct, so the question is which cutoff separates them best.

![Horizontal grouped bars for five support cutoffs showing the share of branches kept and the share of kept branches that are correct: ultrafast bootstrap 95 or more keeps 75.9% and is 97.5% correct, bootstrap 70 or more keeps 80.3% and is 97.3% correct, bootstrap 95 or more keeps 56.8% and is 99.8% correct, FastTree 0.90 or more keeps 60.5% and is 99.8% correct, and FastTree 0.95 or more keeps 48.9% and is 100% correct](/images/charts/iqtree-raxml-fasttree-support-thresholds.webp "**Figure 2. What each common support cutoff keeps and gets right.** Eight simulated alignments of 100 DNA sequences and 300 columns. UFBoot is IQ-TREE's ultrafast bootstrap with 1,000 replicates, bootstrap is RAxML-NG's Felsenstein bootstrap with 100 replicates, and FastTree is its SH-like local support. Each program's branches were checked against the true tree.")

The ultrafast bootstrap cutoff of 95 kept 76% of branches, and 97.5% of those were right, so 15 wrong branches got through. The classic bootstrap cutoff of 70 behaved almost the same, keeping 80% at 97.3%. A RAxML-NG bootstrap of 95 left 57% of branches with one wrong in 441. FastTree's local support of 0.95 kept 49% and none of its 379 branches was wrong, and at 0.90 it kept 61% with one wrong.

The scales differ most in the middle. Ultrafast bootstrap branches at 70 to 89 were right 65% of the time and at 90 to 94 only 82%, which is why the developers advise relying on a branch only from 95. The standard bootstrap at 70 to 89 was right 89% of the time, and FastTree's local support at 0.70 to 0.89 86%. The most confident wrong branch scored 99, 97 and 0.91 on the three scales.

The catch is that this test is easy. Every program had the right model and a clean alignment, and the developers of the ultrafast bootstrap say its second version reduces the risk of overestimating support under severe model violations. Treat a cutoff as the cheapest rule that worked here, not as a guarantee, and read the support alongside the model you chose.

## One alignment through all three programs

The nine primate mitochondrial genomes from the phylogenetic tree explainer, 17,309 columns long, show the same pattern on real data. We ran the three tools on ProteinIQ with the settings shown (Figures 3 to 5).

![IQ-TREE page on ProteinIQ with the alignment pasted in and ultrafast bootstrap and SH-aLRT both set to 1,000, beside the maximum likelihood tree of nine primate mitochondrial genomes with 100/100 support at every internal node and a summary line giving the model TVM+F+I+G4, a log-likelihood of -64507.59 and a runtime of 18.44 s](/images/guides/phylogenetic-tree-software/iq-tree.webp "**Figure 3. IQ-TREE on nine primate mitochondrial genomes.** Each label gives SH-aLRT and ultrafast bootstrap support from 1,000 replicates each, as percentages.")

![RAxML-NG page on ProteinIQ with the analysis mode set to maximum likelihood search plus bootstrapping, beside the same tree with bootstrap support of 100 at every internal node and a summary line giving the model TPM2+FU+G4m, a log-likelihood of -64471.73 and a runtime of 14.22 s](/images/guides/phylogenetic-tree-software/raxml-ng.webp "**Figure 4. RAxML-NG on the same alignment.** Bootstrapping stopped on its own after 50 replicates, and every node scored 100.")

![FastTree page on ProteinIQ with nucleotide sequence type, GTR with gamma and 1,000 support resamples, beside the same tree with local support values of 1 at every internal node and a summary line giving the model GTR+GAMMA and a runtime of 4.77 s](/images/guides/phylogenetic-tree-software/fasttree.webp "**Figure 5. FastTree on the same alignment.** Local support values come from 1,000 resamples and are fractions, so 1 means every resample agreed.")

All three returned the same unrooted tree, with the top score on every branch, and printed three different summaries. The models differ, so do the likelihoods (−64,507.59 against −64,471.73), and the support scales run to 100, to 100 and to 1. Nothing here distinguishes the programs on quality. It distinguishes them on cost: the example used 78 credits on IQ-TREE, 697 on RAxML-NG and 9 on FastTree.

Perfect support is what a long, clean alignment always gives. On data like this, choose by cost; on short or fast-evolving alignments, the support scales above are what separate the programs.

## Which program to start with

Table 2 turns the runs above and the published benchmarks into a first choice and the check that should follow it.

  <caption><strong>Table 2. Which program to start with.</strong> Based on the simulations above and the cited benchmarks, not on a rule of any program's authors.</caption>
  <thead>
    <tr>
      <th scope="col">Your situation</th>
      <th scope="col">Start with</th>
      <th scope="col">Then check</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>An ordinary alignment of up to a few hundred sequences</td>
      <td>IQ-TREE with the default model selection and ultrafast bootstrap</td>
      <td>Whether branches below 95 matter for your claim</td>
    </tr>
    <tr>
      <td>A tree that will carry a paper</td>
      <td>IQ-TREE, plus RAxML-NG as an independent search</td>
      <td>The branches where the two trees differ</td>
    </tr>
    <tr>
      <td>Thousands of sequences</td>
      <td>FastTree</td>
      <td>Branches below 0.95 with a second program on a subset</td>
    </tr>
    <tr>
      <td>A protein alignment of about 100 sequences</td>
      <td>FastTree for a look, then RAxML-NG or IQ-TREE</td>
      <td>That the trees agree, since they scored the same here</td>
    </tr>
    <tr>
      <td>You want posterior probabilities or dates</td>
      <td>A [Bayesian program](/guides/phylogenetic-tree-software)</td>
      <td>Convergence, which no likelihood program needs</td>
    </tr>
  </tbody>

Run more than one program whenever the tree matters, and treat disagreement as the result. Report the support type with the number, because "95" means different things from different programs. When you collapse weak branches, collapse them on the scale of the program that produced them.

## Phylogenetic tree tools on ProteinIQ

A [phylogenetic analysis](/use-cases/phylogenetic-analysis) runs in three steps: align, build the tree, then cross-check it with a second program on the same alignment. [MAFFT](/app/mafft), [MUSCLE5](/app/muscle5) and [Clustal Omega](/app/clustal-omega) produce the [multiple sequence alignment](/use-cases/sequence-alignment), and the three [maximum likelihood](/use-cases/maximum-likelihood-phylogenetics) programs do the rest.

- [IQ-TREE](/app/iq-tree): maximum likelihood trees with model selection and ultrafast bootstrap
- [RAxML-NG](/app/raxml-ng): an independent maximum likelihood search and bootstrap
- [FastTree](/app/fasttree): fast approximate trees for large alignments

## Frequently asked questions

### Is RAxML-NG better than IQ-TREE?

Neither was better in our simulations: both reached the same likelihood in all five replicates and had 4.2 wrong branches of 97 on average. The RAxML-NG authors report higher-scoring trees on taxon-rich datasets, while an independent benchmark of 19 empirical datasets found IQ-TREE reached the best likelihood on every one.

### Is IQ-TREE faster than RAxML-NG?

On DNA alignments of 100 and 200 sequences, yes, by about 2.7 and 9 times against RAxML-NG's default search. With a single start tree RAxML-NG was faster at 100 and 200 sequences and slower at 400, and on 100-sequence protein alignments RAxML-NG was about twice as fast as IQ-TREE. These are one-core times from our runs.

### Is FastTree accurate enough to publish?

Its authors say it is not as accurate as more intensive likelihood searches, and an independent benchmark found lower likelihoods and more dissimilar topologies than IQ-TREE or RAxML. In our replicates it had 4.6 wrong branches of 97 against 4.2, with one replicate far worse. Check weakly supported branches with a second program before relying on them.

### What is the difference between RAxML and RAxML-NG?

RAxML is the classic program, version 8 from 2014. RAxML-NG is a from-scratch rewrite that its tutorial says replaces RAxML and ExaML, and it is the one under active development.

### Are ultrafast bootstrap, bootstrap and FastTree support values comparable?

No. IQ-TREE's developers advise not comparing ultrafast bootstrap with the standard bootstrap, and recommend relying on a branch at 95 or above. FastTree's local support is a fraction from 0 to 1 and RAxML-NG's bootstrap is a percentage of resampled trees.
