Most developers treat Template Toolkit (TT) as a simple placeholder engine—swap variables, loop through lists, render HTML. But when dynamic calculations enter the workflow, that simplistic approach breaks down. Hard.

You don’t need another static template. You need templates that respond: pricing grids that recalculate on quantity, progress bars that update from ratios, or dashboards that summarize metrics in real time. That’s where Template Toolkit math becomes essential.

TT’s math capabilities aren’t just about adding two numbers. It’s about transforming raw data into meaningful, adaptive output—directly in the template layer—without bloating your backend logic. Used wisely, it reduces code complexity. Used poorly, it creates brittle, unreadable templates.

Let’s move beyond [% price * quantity %] and explore how math in Template Toolkit can be structured, optimized, and made maintainable.

Core Math Operations in Template Toolkit

Template Toolkit supports basic arithmetic out of the box through its expression parser. These operations work on scalar values—integers, floats, and strings that can be coerced into numbers.

The core operators are:

• + (addition)
• - (subtraction)
• * (multiplication)
• / (division)
• % (modulo)
• ** (exponentiation)

Example: perl [% discount = 0.15 %] [% original = 99.99 %] [% final = original * (1 - discount) %] Final price: $[% final %]

This outputs: Final price: $84.9915

Note the precision? That leads to a common mistake: floating-point accuracy. TT inherits Perl’s floating-point behavior, so you’ll often need rounding.

Controlling Precision: Rounding and Formatting

Raw math results can be messy. You don’t want 84.9915 on a price tag. Enter the format filter:

perl [% final = original * (1 - discount) %] Final price: [% final %] → [% final | format('%.2f') %]

Output: Final price: 84.9915 → 84.99

The %.2f format string rounds to two decimal places—ideal for currency.

But formatting isn't just cosmetic. It prevents user confusion and aligns with financial standards. Always format final displayed values, not intermediate calculations.

Alternative: Use the round plugin if available.

perl [% USE Math %] [% Math.round(84.9915, 2) %] # → 84.99

Plugins extend TT’s native math, but they require setup. More on that later.

Using Math in Conditional Logic

Math powers smarter decisions in templates. Consider a progress tracker:

perl [% done = 23 %] [% total = 50 %] [% percent = (done / total) * 100 %]

[% IF percent >= 90 %] Status: Excellent progress! [% ELSIF percent >= 50 %] Status: Halfway there. [% ELSE %] Status: Just getting started. [% END %]

This blends arithmetic with control flow—dynamic content based on data-driven thresholds.

But watch out: division by zero.

perl [% IF total > 0 %] [% percent = (done / total) * 100 %] [% ELSE %] [% percent = 0 %] [% END %]

Always guard division operations. It’s a small check that prevents runtime errors.

Working with Arrays and Aggregations

TT doesn’t have built-in sum() or avg() functions, but you can simulate them.

Example: Calculate total order value from a list of items.

perl [% items = [ { name = 'Laptop', price = 1200, qty = 1 }, { name = 'Mouse', price = 25, qty = 2 }, { name = 'Bag', price = 45, qty = 1 } ] %]

[% total = 0 %] [% FOREACH item IN items %] [% total = total + (item.price * item.qty) %] [% END %]

Grand Total: $[% total | format('%.2f') %]

Output: Grand Total: $1315.00

This pattern—initializing a variable and mutating it in a loop—is common in TT for aggregations.

However, it’s easy to mis-scope variables. Always initialize accumulators before the loop. Otherwise, you’ll get undefined behavior or parser errors.

Advanced Math with Plugins

For heavier math, load plugins. The Math plugin adds functions like round, floor, and ceil.

Enable it at the top of your template:

perl [% USE Math %] [% Math.round(4.7) %] # → 5 [% Math.floor(4.7) %] # → 4 [% Math.max(10, 20, 15) %] # → 20

Another useful plugin: Date, which allows date arithmetic.

perl [% USE Date %] [% now = Date.epoch %] [% one_day = 24 60 60 %] # seconds in a day [% tomorrow = Date.format(now + one_day, '%Y-%m-%d') %] Tomorrow: [% tomorrow %]

Plugins extend TT’s math reach but come with trade-offs: dependency management and runtime overhead. Use them when native operators fall short—not as a default.

Practical Use Case: Dynamic Pricing Table

Let’s build a realistic example: a tiered pricing table with volume discounts.

perl [% tiers = [ { min = 1, max = 9, price = 10.00 }, { min = 10, max = 49, price = 9.50 }, { min = 50, max = 99, price = 8.75 }, { min = 100, max = 9999, price = 7.99 } ] %]

<h2>Volume Pricing</h2> <table> <tr><th>Quantity</th><th>Unit Price</th><th>Total (100 units)</th></tr> [% FOREACH tier IN tiers %] [% volume_total = 100 * tier.price %] <tr> <td>[% tier.min %]–[% tier.max %]</td> <td>$[% tier.price | format('%.2f') %]</td> <td>$[% volume_total | format('%.2f') %]</td> </tr> [% END %] </table>

This generates a clean pricing table where math computes totals on the fly. No backend precalculation needed.

But what if the user selects 75 units? Then you need logic to detect the correct tier.

perl [% qty = 75 %] [% unit_price = 0 %] [% FOREACH tier IN tiers %] [% IF qty >= tier.min && qty <= tier.max %] [% unit_price = tier.price %] [% END %] [% END %]

Total for [% qty %] units: $[% (qty * unit_price) | format('%.2f') %]

Now the template adapts to user input—math combined with conditional logic.

Limitations and When to Avoid Template Math

Template Toolkit math is convenient, but not a substitute for application-level logic.

Avoid doing this in templates:

• Complex financial calculations (taxes, currency conversion)
• Statistical analysis
• Data validation
• Repeated logic across multiple templates

Why? Because templates should focus on presentation, not business rules.

If you find yourself writing [% FOREACH %] loops just to sum values used in five different views, move that logic to Perl (or your backend language). Precompute the total and pass it in.

Rule of thumb: If the math defines how data is presented, keep it in TT. If it defines what the data means, move it to code.

Real Workflow Tips for Maintainable Templates

1. Use named intermediate variables
2. Instead of [% (price qty (1 - disc)) | format('%.2f') %], break it down: perl [% subtotal = price qty %] [% final = subtotal (1 - disc) %] [% final | format('%.2f') %]

Clearer, easier to debug.

1. Define constants at the top
2. perl [% TAX_RATE = 0.08 %] [% DISCOUNT_ACTIVE = 1 %]

1. Use comments for non-obvious math
2. perl [%# Add 30 days in seconds: 30 24 60 * 60 %] [% renewal_date = Date.epoch + 2592000 %]

1. Test edge cases
2. Zero values, negative numbers, empty lists. TT won’t always warn you.

1. Avoid deep nesting
2. Math inside conditionals inside loops becomes unreadable fast. Extract where possible.

Final Thoughts: Math as a Design Tool

Template Toolkit math isn't just operational—it's a design lever. It lets you create templates that respond, adapt, and compute, turning static structures into dynamic experiences.

But power demands discipline. Use math to enhance clarity, not obscure logic. Let templates do what they’re good at: transforming data into output. Keep complexity where it belongs—in the application layer.

Start small. Use math to format prices, calculate percentages, and drive conditional content. Then expand as needed. The goal isn’t to turn templates into spreadsheets. It’s to make them smarter, not harder to maintain.

Deploy math with intent. Review templates regularly. And never assume the numbers “just work.”

How do I round numbers in Template Toolkit? Use the format('%.2f') filter for decimal precision, or load the Math plugin for functions like Math.round().

Can I use Template Toolkit math with dates? Yes—convert dates to epoch timestamps, perform arithmetic in seconds, then reformat using the Date plugin.

Why is my division returning 0? Check if both operands are integers. Perl may perform integer division. Force float conversion by multiplying by 1.0 if needed.

Is it safe to do math in templates? For presentation logic—yes. For business-critical calculations—no. Keep complex math in backend code.

How do I sum an array of values? Initialize a variable to 0, then iterate through the array, adding each value: [% total = total + item.value %].

Can I use parentheses to control operation order? Yes. Template Toolkit respects standard operator precedence and allows parentheses for grouping.

What math functions are available by default? Basic operators (+, -, , /, %, *). Advanced functions require plugins like Math or Date.