Smarty is one of the oldest template engines for the PHP development language. If you are programming in PHP, likely you have worked with it. A third version of this template was released in 2010. Smarty 3 was written from scratch with the active use of PHP5. At the same time Smarty got an updated syntax and modern features including inheritance, sandbox (computer security) and etc.
Twig is a modern template engine from developers of the Symfony. The authors have positioned it as the fast and functional template. It looks like Smarty 3 a lot in terms of features. Twig features a slightly different syntax, as well as the stated performance. Let us verify it!

Testing

We purposely is going to use quite complex templates during testing that the processing time would be noticeable. Actually, we will evaluate this time, so we will prepare the relevant scripts.

Code for Smarty turned out very simple:

$data = json_decode(file_get_contents('data.json'), true);
require('smarty/Smarty.class.php');
$smarty = new Smarty();
$smarty->compile_check = false;
$start = microtime(true);
$smarty->assign($data);
$smarty->fetch('demo.tpl');
echo microtime(true)-$start;

Code for Twig was a bit more complicated:

$data = json_decode(file_get_contents('data.json'), true);
require('twig/Autoloader.php');
Twig_Autoloader::register();
$loader = new Twig_Loader_Filesystem('templates');
$twig = new Twig_Environment($loader, array(
'cache' => 'templates_c',
'autoescape' => false,
'auto_reload' => false,
));
$start = microtime(true);
$template = $twig->loadTemplate('demo.tpl');
$template->render($data);
echo microtime(true)-$start;
Both templates were adapted in a similar way: the automatic screening was enabled and automatic recompilation of templates was disabled during changes.

Getting the values of variables

Getting the values of the variables is the most used operation. It can be used several hundred times in the complex templates. At first it may seem that the speed of this operation should not depend on a template, but it is not. There should be used some structure to store the template’s variables. The more it is simpler the faster works receipt of values of variables. We will generate a template to evaluate the performance of this operation that will produce the value of 10000 variables and nothing more.

Smarty:

{$var0} {$var1} {$var2} {$var3} {$var4} ...
Twig:

{{ var0 }} {{ var1 }} {{ var2 }} {{ var3 }} {{ var4 }} ...
Result:

	Compiling	Execution
Smarty 3.1.1	16.320 seconds	0.058 seconds
Twig 1.2.0	9.757 seconds	0.083 seconds

The following table shows the average values of several consecutive tests. As we can see ten thousand syntax structures were compiled by both parties of test for a long time. Smarty is far behind Twig in this respect. However, the compilation is done only once and the compiled version of the template works further, so the running time of the last one is more important. Here Smarty is certainly faster by ≈ 30% than an opponent.

Bypass the arrays and produce values of the fields

Any serious template cannot do without foreach. Let us write a test template, which produces in 10 fields from 1000 array’s elements.

Smarty:

{foreach $array as $item}
{$item.id} {$item.title} {$item.var1} {$item.var2} {$item.var3} {$item.var4} {$item.var5} {$item.var6} {$item.var5} {$item.var6}
{/foreach}
Twig:

{% for item in array %}
{{ item.id }} {{ item.title }} {{ item.var1 }} {{ item.var2 }} {{ item.var3 }} {{ item.var4 }} {{ item.var5 }} {{ item.var6 }} {{ item.var5 }} {{ item.var6 }}
{% endfor %}
Result: .

	Compiling	Execution
Smarty 3.1.1	0.065 seconds	0.009 seconds
Twig 1.2.0	0.131 seconds	0.082 seconds

Here is something incredible: a compiled template Smarty runs almost in 10 times faster than version Twig! Moreover, even the compilation + execution works faster in Smarty than execution of compiled template in Twig. We can conclude that the compiler of Smarty templates is initialized faster than in Twig, but it works slower judging by the previous test that for small templates is almost unnoticeable.

Inheritance

Inheritance of templates is a very convenient mechanism. Only because of this can be liked the tested template engines :) Let us find out what burdens occur when we will use inheritance in Smarty and Twig. Let us create a parent template with 500 blocks and 500 of small templates that each of them will inherit from each other, and it is filling the static data in one of the 500 blocks of the parent template, and let the template engine to deal with the last in the chain.

Result:

	Compiling	Execution
Smarty 3.1.1	1.329 seconds	0.002 seconds
Twig 1.2.0	2.641 seconds	0.121 seconds

Smarty has worked in 60 times faster. If we look at the compiled code, it is easy to understand that this is not the limit. Smarty has united the entire chain of inherited templates into one big file, as though originally there was no inheritance. Namely, there is not performance loss as a result of the inheritance use! Twig carefully created the class and file for each template and during each generation of page uploads all that.

Altogether

The conclusion is clear: Smarty is faster than Twig. A compilation of big templates takes longer, but as a result we get the better performance.
We used a laptop Pentium Dual-Core T4200 (2 GHz), 3GB RAM for testing and the version of PHP 5.3. In case, if you would like to evaluate the performance of Smarty and Twig independently on your computer, you can download the source codes for all tests in one archive.