Permanently protected module
Module documentation
Not to be confused with Module:Template translation.
warning Warning:This page is shared between multiple wikis.
All changes to this page will be automatically copied to all wikis listed in the left side bar.
Please help translate this page.

Module Quality

Test Status
Module:TNT success: 7, error: 0, skipped: 0
Module:TNT/sandbox success: 7, error: 0, skipped: 0


This module allows templates and modules to be easily translated as part of the multilingual templates and modules project. Instead of storing English text in a module or a template, TNT module allows modules to be designed language-neutral, and store multilingual text in the tabular data pages on Commons. This way your module or template will use those translated strings (messages), or if the message has not yet been translated, will fall back to English. When someone updates the translation table, your page will automatically update (might take some time, or you can purge it), but no change in the template or module is needed on any of the wikis. This process is very similar to MediaWiki's localisation, and supports all standard localization conventions such as {{PLURAL|...}} and other parameters.

This module can be used from templates using #invoke, and from other modules. For a simple example, see Data:I18n/ – a table with two messages, each message having a single parameter. By convention, all translation tables should have '''Data:I18n/...''' prefix to separate them from other types of data.

Using from Templates

Description Wiki Markup
In a template, this command translates source_table message using Commons' Data:I18n/ translation table.
{{#invoke:TNT | msg
| I18n/
| source_table
If your message contains parameters, you can specify them after the message ID.
{{#invoke:TNT | msg
| I18n/Template:My
| message-with-two-params
| param1
| param2
Use lang=xx to set language. For example, use with {{int:lang}} to use the interface language.
{{#invoke:TNT | msg
| I18n/Template:My
| message-with-two-params
| param1
| param2
| lang={{int:lang}}

Translating Template Parameters

Template parameters are usually stored as a JSON templatedata block inside the template's /doc subpage. This makes it convenient to translate, but when a new parameter is added to a global template, all /doc pages need to be updated in every language. TNT helps with this by automatically generating the templatedata block from a table stored on Commons. Placing this line into every /doc sub-page will use Data:Templatedata/ table to generate all the needed templatedata information in every language. Even if the local community has not translated the full template documentation, they will be able to see all template parameters, centrally updated.
{{#invoke:TNT | doc | Graph:Lines }}

Using from Modules

Just like templates, modules should also use this module for localization:

local TNT = require('Module:TNT')

-- format <messageId> string with two parameters using a translation table.
local text = TNT.format('I18n/My_module_messages', 'messageId', 'param1', 'param2', ...)

-- Same, but translate to a specific language.
local text = TNT.formatInLanguage('fr', 'I18n/My_module_messages', 'messageId', 'param1', 'param2', ...)

--    This module allows any template or module to be copy/pasted between
--    wikis without any translation changes. All translation text is stored
--    in the global  Data:*.tab  pages on Commons, and used everywhere.
-- SEE:
--    Please do NOT rename this module - it has to be identical on all wikis.
--    This code is maintained at
--    Please do not modify it anywhere else, as it may get copied and override your changes.
--    Suggestions can be made at
--    The "msg" function uses a Commons dataset to translate a message
--    with a given key (e.g. source-table), plus optional arguments
--    to the wiki markup in the current content language.
--    Use lang=xx to set language.  Example:
--    {{#invoke:TNT | msg
--     | I18n/  <!-- -->
--     | source-table              <!-- uses a translation message with id = "source-table" -->
--     | param1 }}                 <!-- optional parameter -->
--    The "doc" function will generate the <templatedata> parameter documentation for templates.
--    This way all template parameters can be stored and localized in a single Commons dataset.
--    NOTE: "doc" assumes that all documentation is located in Data:Templatedata/* on Commons.
--    {{#invoke:TNT | doc | Graph:Lines }}
--        uses
--        if the current page is Template:Graph:Lines/doc

local p = {}
local i18nDataset = 'I18n/'

-- Forward declaration of the local functions
local sanitizeDataset, loadData, link, formatMessage

function p.msg(frame)
	local dataset, id
	local params = {}
	local lang = nil
	for k, v in pairs(frame.args) do
		if k == 1 then
			dataset = mw.text.trim(v)
		elseif k == 2 then
			id = mw.text.trim(v)
		elseif type(k) == 'number' then
			params[k - 2] = mw.text.trim(v)
		elseif k == 'lang' and v ~= '_' then
			lang = mw.text.trim(v)
	return formatMessage(dataset, id, params, lang)

-- Identical to p.msg() above, but used from other lua modules
-- Parameters:  name of dataset, message key, optional arguments
-- Example with 2 params:  format('I18n/Module:TNT', 'error_bad_msgkey', 'my-key', 'my-dataset')
function p.format(dataset, key, ...)
	local checkType = require('libraryUtil').checkType
	checkType('format', 1, dataset, 'string')
	checkType('format', 2, key, 'string')
	return formatMessage(dataset, key, {...})

-- Identical to p.msg() above, but used from other lua modules with the language param
-- Parameters:  language code, name of dataset, message key, optional arguments
-- Example with 2 params:  formatInLanguage('es', I18n/Module:TNT', 'error_bad_msgkey', 'my-key', 'my-dataset')
function p.formatInLanguage(lang, dataset, key, ...)
	local checkType = require('libraryUtil').checkType
	checkType('formatInLanguage', 1, lang, 'string')
	checkType('formatInLanguage', 2, dataset, 'string')
	checkType('formatInLanguage', 3, key, 'string')
	return formatMessage(dataset, key, {...}, lang)

-- Obsolete function that adds a 'c:' prefix to the first param.
-- "Sandbox/" -> 'c:Data:Sandbox/'
	return link(frame.args[1])

function p.doc(frame)
	local dataset = 'Templatedata/' .. sanitizeDataset(frame.args[1])
	return frame:extensionTag('templatedata', p.getTemplateData(dataset)) ..
		   formatMessage(i18nDataset, 'edit_doc', {link(dataset)})

function p.getTemplateData(dataset)
	-- TODO: add '_' parameter once lua starts reindexing properly for "all" languages
	local data = loadData(dataset)
	local names = {}
	for _, field in ipairs(data.schema.fields) do

	local numOnly = true
	local params = {}
	local paramOrder = {}
	for _, row in ipairs( do
		local newVal = {}
		local name = nil
		for pos, columnName in ipairs(names) do
			if columnName == 'name' then
				name = row[pos]
				newVal[columnName] = row[pos]
		if name then
			if (
				(type(name) ~= "number")
				and (
					(type(name) ~= "string")
					or not string.match(name, "^%d+$")
			) then
				numOnly = false
			params[name] = newVal
			table.insert(paramOrder, name)

	-- Work around json encoding treating {"1":{...}} as an [{...}]
	if numOnly then

	local json = mw.text.jsonEncode({

	if numOnly then
		json = string.gsub(json,'"zzz123":"",?', "")

	return json

-- Local functions

sanitizeDataset = function(dataset)
	if not dataset then
		return nil
	dataset = mw.text.trim(dataset)
	if dataset == '' then
		return nil
	elseif string.sub(dataset,-4) ~= '.tab' then
		return dataset .. '.tab'
		return dataset

loadData = function(dataset, lang)
	dataset = sanitizeDataset(dataset)
	if not dataset then
		error(formatMessage(i18nDataset, 'error_no_dataset', {}))

	-- Give helpful error to thirdparties who try and copy this module.
	if not mw.ext or not or not then
		error(string.format([['''Missing JsonConfig extension, or not properly configured;
Cannot load
See''']], dataset))

	local data =, lang)

	if data == false then
		if dataset == i18nDataset then
			-- Prevent cyclical calls
			error('Missing Commons dataset ' .. i18nDataset)
			error(formatMessage(i18nDataset, 'error_bad_dataset', {link(dataset)}))
	return data

-- Given a dataset name, convert it to a title with the 'commons:data:' prefix
link = function(dataset)
	return 'c:Data:' .. mw.text.trim(dataset or '')

formatMessage = function(dataset, key, params, lang)
	for _, row in pairs(loadData(dataset, lang).data) do
		local id, msg = unpack(row)
		if id == key then
			local result = mw.message.newRawMessage(msg, unpack(params or {}))
			return result:plain()
	if dataset == i18nDataset then
		-- Prevent cyclical calls
		error('Invalid message key "' .. key .. '"')
		error(formatMessage(i18nDataset, 'error_bad_msgkey', {key, link(dataset)}))

return p