Features
=======

Some of Smarty's features:
-   It is extremely fast.
-   It is efficient since the PHP parser does the dirty work.
-   No template parsing overhead, only compiles once.
-   It is smart about [recompiling](#variable.compile.check) only the
    template files that have changed.
-   You can easily create your own custom
    [functions](#language.custom.functions) and [variable
    modifiers](#language.modifiers), so the template language is
    extremely extensible.
-   Configurable template [{delimiter}](#variable.left.delimiter) tag
    syntax, so you can use `{$foo}`, `{{$foo}}`, `<!--{$foo}-->`, etc.
-   The [`{if}..{elseif}..{else}..{/if}`](#language.function.if)
    constructs are passed to the PHP parser, so the `{if...}` expression
    syntax can be as simple or as complex an evaluation as you like.
-   Allows unlimited nesting of
    [`sections`](#language.function.section), `if's` etc.
-   Built-in [caching](#caching) support
-   Arbitrary [template](#resources) sources
-   [Template Inheritance](#advanced.features.template.inheritance) for
    easy management of template content.
-   [Plugin](#plugins) architecture

## Separation of presentation from application code
-   This means templates can certainly contain logic under the condition
    that it is for presentation only. Things such as
    [including](./designers/language-builtin-functions/language-function-include.md) other templates,
    [alternating](./designers/language-custom-functions/language-function-cycle.md) table row colors,
    [upper-casing](./designers/language-modifiers/language-modifier-upper.md) a variable,
    [looping](./designers/language-builtin-functions/language-function-foreach.md) over an array of data and
    rendering it are examples of presentation logic.
-   This does not mean however that Smarty forces a separation of
    business and presentation logic. Smarty has no knowledge of which is
    which, so placing business logic in the template is your own doing.
-   Also, if you desire *no* logic in your templates you certainly can
    do so by boiling the content down to text and variables only.

## How does it work?

Under the hood, Smarty "compiles" (basically copies and converts) the
templates into PHP scripts. This happens once when each template is
first invoked, and then the compiled versions are used from that point
forward. Smarty takes care of this for you, so the template designer
just edits the Smarty templates and never has to manage the compiled
versions. This approach keeps the templates easy to maintain, and yet
keeps execution times extremely fast since the compiled code is just
PHP. And of course, all PHP scripts take advantage of PHP op-code caches
such as APC.

## Template Inheritance

Template inheritance was introduced in Smarty 3. Before template
inheritance, we managed our templates in
pieces such as header and footer templates. This organization lends
itself to many problems that require some hoop-jumping, such as managing
content within the header/footer on a per-page basis. With template
inheritance, instead of including other templates we maintain our
templates as single pages. We can then manipulate blocks of content
within by inheriting them. This makes templates intuitive, efficient and
easy to manage. See
[Template Inheritance](./programmers/advanced-features/advanced-features-template-inheritance.md)
for more info.

## Why not use XML/XSLT syntax?
There are a couple of good reasons. First, Smarty can be used for more
than just XML/HTML based templates, such as generating emails,
javascript, CSV, and PDF documents. Second, XML/XSLT syntax is even more
verbose and fragile than PHP code! It is perfect for computers, but
horrible for humans. Smarty is about being easy to read, understand and
maintain.

## Template Security
Although Smarty insulates you from PHP, you still have the option to use
it in certain ways if you wish. Template security forces the restriction
of PHP (and select Smarty functions.) This is useful if you have third
parties editing templates, and you don't want to unleash the full power
of PHP or Smarty to them.

## Integration
Sometimes Smarty gets compared to Model-View-Controller (MVC)
frameworks. Smarty is not an MVC, it is just the presentation layer,
much like the View (V) part of an MVC. As a matter of fact, Smarty can
easily be integrated as the view layer of an MVC. Many of the more
popular ones have integration instructions for Smarty, or you may find
some help here in the forums and documentation.

## Other Template Engines
Smarty is not the only engine following the *"Separate Programming Code
from Presentation"* philosophy. For instance, Python has template
engines built around the same principles such as Django Templates and
CheetahTemplate. *Note: Languages such as Python do not mix with HTML
natively, which give them the advantage of proper programming code
separation from the outset. There are libraries available to mix Python
with HTML, but they are typically avoided.*

## What Smarty is Not

Smarty is not an application development framework. Smarty is not an
MVC. Smarty is not an alternative to Laravel, Symfony, CodeIgniter,
or any of the other application development frameworks for PHP.

Smarty is a template engine, and works as the (V)iew component of your
application. Smarty can easily be coupled to any of the engines listed
above as the view component. No different than any other software,
Smarty has a learning curve. Smarty does not guarantee good application
design or proper separation of presentation, this still needs to be
addressed by a competent developer and web designer.

## Is Smarty Right for Me?

Smarty is not meant to be a tool for every job. The important thing is
to identify if Smarty fits your needs. There are some important
questions to ask yourself:

### Template Syntax
Are you content with PHP tags mixed with HTML? Are your
web designers comfortable with PHP? Would your web designers prefer a
tag-based syntax designed for presentation? Some experience working with
both Smarty and PHP helps answer these questions.

### The Business Case
Is there a requirement to insulate the templates from
PHP? Do you have untrusted parties editing templates that you do not
wish to unleash the power of PHP to? Do you need to programmatically
control what is and is not available within the templates? Smarty
supplies these capabilities by design.

## Feature set
Does Smarty's features such as caching, template
inheritance and plugin architecture save development cycles writing code
that would be needed otherwise? Does the codebase or framework you plan
on using have the features you need for the presentation component?

## Sites using Smarty
Many well-known PHP projects make use of Smarty such as XOOPS CMS, CMS Made Simple, Tiki
CMS/Groupware and X-Cart to name a few.

## Summary
Whether you are using Smarty for a small website or massive enterprise
solution, it can accommodate your needs. There are numerous features
that make Smarty a great choice:

-   separation of PHP from HTML/CSS just makes sense
-   readability for organization and management
-   security for 3rd party template access
-   feature completeness, and easily extendable to your own needs
-   massive user base, Smarty is here to stay
-   LGPL license for commercial use
-   100% free to use, open source project