Get Smarty



Smarty Icon

You may use the Smarty logo according to the trademark notice.

Smarty Template Engine Smarty Template Engine

For sponsorship, advertising, news or other inquiries, contact us at:

Sites Using Smarty


Smarty 3 Overview

Rewritten for PHP 5

The Smarty 3 code base is a 100% rewrite, and contains many language features that do not exist in PHP 4. This means Smarty 3 will NOT work with PHP 4. If you need PHP 4 support, you will have to stick with Smarty 2 until you can upgrade PHP.

Design Goal

Smarty's fundamental design goal remains the same: To separate application code from the presentation. This implies that PHP is separated from the presentation. A detailed explanation of why this is important can be found here.

New Lexer/Parser

Smarty has a new template parser, a real syntax lexer. This gives Smarty much finer control over its template syntax. Things like in-template math, line-precision error messages and recursive template functions are now possible.

Template Objects

You can now make template objects and execute them independently. Example:


$tpl = $smarty->createTemplate('my.tpl');
$smarty->display($tpl); // or $tpl->display();

Data Objects

The variables assigned to a template can now be managed independently as a Smarty_Data object. Example:


$data = new Smarty_Data;
$tpl = $smarty->createTemplate('my.tpl',$data);

PHP Streams

You can now use PHP Streams as data sources for components of Smarty. If you call:



or in a template call:


{include file="foo:bar.tpl"}

Smarty will first look for a registered template resource named foo. If nothing is found, it will check if a PHP stream is available. If foo://bar is available, Smarty will use it to fetch the template. You can also use streams to call variables. {$foo:bar} will use the foo://bar stream to get the template variable.

Template Inheritance

Templates can now inherit from each other. You mark blocks of a template with {block name=foo}{/block} tags, a template can inherit with the {extend file="my.tpl"} tag, and then you can replace, change or append the blocked contents from the inheriting template(s). Example:

parent .tpl

  	<title>{block name=title}default title{/block}<title>
	{block name=body}default body{/block}

child .tpl

{extends file="parent.tpl"}
{block name=title}My Child Title{/block}
{block name=body}My Child Body{/block}

output of $smarty->display('child.tpl');

  	<title>My Child Title<title>
	My Child Body

See more here.

"{" and "}" (Javascript) Auto-Escapement

In Smarty 2, you had to escape occurances of {} characters by surrounding them with {literal}{/literal} blocks or replacing them with {ldelim}{rdelim} tags. With Smarty 3, the braces will be ignored so long as they are surrounded by white space.


   // the following braces are ignored by Smarty
   // since they are surrounded by whitespace
   function foobar {
   // this one will need literal escapement
	function bazzy {alert('foobar!');}

Variable Filters

The default template modifier feature of Smarty 2 has been replaced with variable filters. A variable filter can be applied to the output of template variables globally. We have pre, post, and output filters, now we have a fourth choice: 'variable'. When you apply the filter such as:



then all output from variables is HTML escaped. You can also selectively disable this in-line with {$foo nofilter}.

In-Template Function Definitions

You can create functions within a template and call them just like a plugin function. When you have a plugin that generates presentational content, keeping it in the template is often a more manageable choice. It also simplifies data traversal, such as deeply nested menus. Example:


{* define the function *}
{function name=menu level=0}
  <ul class="level{$level}">
  {foreach $data as $entry}
    {if is_array($entry)}
      {menu data=$entry level=$level+1}

{* create an array to demonstrate *}
{$menu = ['item1','item2','item3' => ['item3-1','item3-2','item3-3' =>

{* run the array through the function *}
{menu data=$menu}


* item1
* item2
* item3
      o item3-1
      o item3-2
      o item3-3
            + item3-3-1
            + item3-3-2
* item4

Precision Caching

You can now specify items to be non-cached inline such as {$foo nocache} or {include file="foo.tpl" nocache}

Backward-Compatibility with Smarty 2

Much of Smarty 3 is backward compatible with Smarty 2, except for the items noted in the SMARTY2_BC_NOTES file included with the Smarty 3 distribution. Please see that file for a detail breakdown of BC differences.


Sponsors [info]