By MW in mediawiki — 01 Jun 2025

Mastering MediaWiki Templates for Dynamic Content Creation

Why Templates Matter in MediaWiki

When you first dive into a MediaWiki installation it’s easy to think that every page has to be typed out from scratch. In practice that quickly turns into a nightmare of copy‑paste, broken links, and inconsistent styling. Templates are the answer – reusable snippets that sit in a single place, get transcluded everywhere, and keep your wiki tidy. The real power shows up when you start mixing parameters, parser functions, and even Lua modules. That’s where “dynamic” content lives.

Getting the Basics Right

At the heart of a template is a page in the Template: namespace. The file name is the template’s identifier – for example {{Template:Infobox book}}. To use it you simply write {{Infobox book|title=The Wind‑up Bird Chronicle|author=Haruki Murakami}} on any other page.

Simple Parameters

Parameters are accessed with {{{1}}} for the first unnamed argument, {{{2}}} for the second, and so on. Named parameters are a bit clearer:

{{Infobox book
|title = The Wind‑up Bird Chronicle
|author = Haruki Murakami
|year = 1995
}}

Inside the template you’d pull those values like this:

<table class="infobox">
! Title: {{{title}}}
| Author: {{{author}}}
| Year: {{{year}}}
</table>

Notice the double curly braces – they’re the “magic” that tells MediaWiki to replace the placeholder with the actual value when the page is rendered.

Default Values and Fallbacks

If a contributor forgets a parameter you can supply a default using the pipe syntax:

{{{year|Unknown}}}

Now {{Infobox book|title=Foo|author=Bar}} will still display “Unknown” for the year instead of leaving a blank cell.

Conditional Logic with Parser Functions

Templates become truly dynamic when they start making decisions. MediaWiki ships with a handful of built‑in parser functions – #if, #ifeq, #switch, #expr, etc. They’re terse, but they can be stacked to craft surprisingly complex output.

Example: Showing a “New” badge for recent articles

{{#if:
 {{#expr: {{#time:Y}} - {{{year|0}}} <= 1 }}
 |New!
}}

What’s happening?

#time:Y returns the current year.
#expr calculates the difference between the current year and the supplied year parameter.
If the result is ten or less (in the example we used “1”), the inner HTML – a tiny badge – appears.

That tiny block can be dropped into any infobox, turning a static table into a little living thing.

Advanced Conditioning with `#switch`

When you have more than two possibilities, #switch shines. Suppose you want a template that renders different icons depending on a page’s status:

{{#switch:{{{status|draft}}}
|draft =  Draft
|review =  Under review
|published =  Published
|{{{status}}}}}

The last line (the “default” case) simply echoes whatever was passed, ensuring you don’t end up with an empty string if you mistype a status.

Beyond Wikitext: Lua Modules

For anything that feels “clunky” in pure wikitext, the #invoke parser function can hand the job off to a Lua module. Lua runs on the server side, so you can do arithmetic, loops, table look‑ups, and even fetch data from other pages via mw.title.makeTitle. The result is returned as plain wikitext, ready for insertion.

Simple Lua Example: Formatting a List of Authors

First, create Module:PersonList:

local p = {}

function p.format(frame)
    local authors = mw.text.split(frame.args[1] or "", ",")
    local out = {}
    for i, name in ipairs(authors) do
        table.insert(out, string.format("[[User:%s|%s]]", name:match("^%s*(.-)%s*$"), name))
    end
    return table.concat(out, ", ")
end

return p

Now use it in a template:

{{#invoke:PersonList|format|{{{authors}}}}}

If you call {{MyTemplate|authors=Alice,Bob,Carol}} the output will be a tidy list of linked usernames. No more manual brackets or comma‑placement errors.

Dynamic Dates, Times, and Periodic Content

MediaWiki’s #time function can format the current date in dozens of ways. Combine it with #if to hide or show sections based on the day of the week, a month, or even a specific hour.

{{#if:
 {{#ifeq:{{#time:D}}|Monday}}
 |Monday notice: Remember the staff meeting at 10 am.
}}

This snippet will only appear on Mondays, turning a generic page into a subtle reminder system.

Semantic‑Ready Templates

Many wikis pair MediaWiki with the Semantic MediaWiki (SMW) extension. Templates become a bridge between human‑readable content and machine‑readable data. By embedding [[Property::Value]] triples inside a template you ensure that every page that uses the template automatically contributes structured data.

Consider a “Location” template for a travel guide:

{{#if:{{{city|}}}
|'''City:''' {{{city}}}
|'''Country:''' {{{country}}}
}}
[[Has latitude::{{{lat|}}}]]
[[Has longitude::{{{lon|}}}]]

Every article that calls {{Location|city=Kyoto|country=Japan|lat=35.0116|lon=135.7681}} now feeds SMW a set of facts that can be queried, sorted, or displayed on a map.

Best Practices for Maintainable Templates

Keep logic in modules, presentation in wikitext. Lua is easier to debug for calculations, while HTML stays readable in the template file.
Name parameters clearly. Instead of {{{1}}}, use {{{title}}} – it reads like natural language.
Document defaults. A small comment at the top of the template (e.g., >) helps new editors understand what’s optional.
Avoid deep nesting. If a template calls another template that calls a third, you can quickly run into performance issues.
Test with edge cases. Try empty strings, special characters, and extreme numbers to see how the template behaves.

Performance Tips: Caching and Parser Cache

Every time a page is rendered MediaWiki may re‑evaluate the template unless the parser cache can be reused. Adding __NOEDITSECTION__ or __STATICREDIRECT__ isn’t directly related, but using {{#vardefine}} to store intermediate results can cut down redundant calculations.

{{#vardefine:diff|{{#expr: {{#time:Y}} - {{{year|0}}} }}}}
{{#if:{{#expr:{{#var:diff}} <= 1}}|New!}}

By defining diff once, we keep the expression from being evaluated twice, which helps the parser cache keep a cleaner fingerprint.

Real‑World Use Cases

Biographical cards. A template that pulls a name, birth date, and a short description from a central “People” page, then formats it with a portrait thumbnail.
Course listings. Academic wikis often use a CourseInfo template that automatically calculates the semester based on the current month.
Event calendars. Combine #time with Lua date arithmetic to highlight upcoming events and hide past ones without manual editing.

Common Pitfalls and How to Avoid Them

Even seasoned editors stumble over a few classic traps:

Forgetting to escape pipe characters. If a parameter value contains “|”, wrap the whole value in <nowiki> or use a named parameter that avoids the conflict.
Infinite recursion. A template that includes itself (directly or indirectly) will crash the parser. MediaWiki throws an error after a few levels, but it’s better to design with a clear hierarchy.
Hard‑coding URLs. Use {{fullurl:…}} or {{canonicalurl:…}} so links stay valid if the domain changes.

Putting It All Together: A Mini‑Framework

Below is a compact “dynamic box” template that demonstrates most of the concepts discussed. Feel free to copy the idea and adapt it to your own wiki.


{{#vardefine:now|{{#time:Y-m-d}}}}
{{#vardefine:age|{{#expr: {{#time:Y}} - {{{year|0}}} }}}
{| class="dynamic-box"
|-
! Title !! {{{title|Untitled}}}
|-
! Created !! {{#var:now}}
|-
! Age !! {{#if:{{#var:age}}|{{#var:age}} years|N/A}}
|-
! Status !! {{#switch:{{{status|draft}}}
|draft = Draft
|review = Under review
|published = Published
|{{{status}}}}}
|-
{{#if:
 {{#expr: {{#var:age}} <= 1 }}
 |New!
}}
|}

When you invoke it like:

{{DynamicBox|title=My Project|year=2024|status=review}}

the table will automatically display today’s date, calculate the age, pick the correct status label, and add a “New!” badge if the project is less than a year old. All of that without a single manual update after the initial call.

Conclusion

Mastering MediaWiki templates is less about memorising every parser function and more about developing a mindset that treats each piece of content as a reusable, data‑driven component. By combining simple parameters, conditional logic, and Lua modules you can turn a static wiki into a living knowledge base that updates itself, serves structured data to extensions, and stays maintainable for years to come. The examples above scratch the surface; the real depth appears as you start layering these techniques, testing edge cases, and watching your wiki gradually become more efficient, less error‑prone, and—dare we say—pretty slick.