LuaTeXWiki - User contributions [en]

User talk:Taco

2023-02-14T13:06:04Z

Taco: /* The Wiki has a lot of spam */

== The Wiki has a lot of spam ==
the Wiki has a lot of spam pages pealse clean it--[[User:Hubaishan|Hubaishan]] ([[User talk:Hubaishan|talk]]) 12:32, 14 February 2023 (CET)
* deleted lots of spam pages and users, thanks for pointing it out [[User:Taco|Taco]] ([[User talk:Taco|talk]]) 14:06, 14 February 2023 (CET)

Token filter

2011-06-30T11:03:13Z

Taco: with \XeTeXinterchartoks replacement example

= Syntax =

This [[Callbacks|callback]] is called whenever TeX needs a new token. No arguments are passed to the callback, and the return value should be either a Lua table representing a to|-|be|-|processed token, a table consisting of a list of such tokens, or
something else like \type{nil} or an empty table. Your lua function should therefore look like this:

<pre>
function()
return <table> token
end
</pre>

If your Lua function does not return a table representing a valid token, it will be immediately called again, until it eventually does return a useful token or tokenlist (or until you reset the callback value to nil). If your function returns a single usable token, then that token will be processed by luatex immediately. If the function returns a token list (a table consisting of a list of consecutive token tables), then that list will be pushed to the input stack at a completely new token list level.

The following examples aren't mutually exclusive; however, if one wanted to register them all in the same callback, special care would be needed, as explained [[Callbacks#Several_functions_in_a_callback|in the main page on callbacks]]. Here each call to <tt>callback.register()</tt> removes whatever there might have been in the callback beforehand.

= Examples =

== Faking \XeTeXinterchartoks ==

Lua code:

<pre>
% luatexinterchartoks.lua

charclasses = charclasses or {}

function setcharclass (a,b)
charclasses[a] = b
end

local i = 0
while i < 65536 do
charclasses[i] = 0
i = i + 1
end

interchartoks = interchartoks or {}

function setinterchartoks (a,b,c)
interchartoks[a] = interchartoks[a] or {}
interchartoks[a][b] = c
end

local nc, oc
oc = 255

function do_intertoks ()
local tok = token.get_next()
if tex.count['XeTeXinterchartokenstate'] == 1 then
if tok[1] == 11 or tok[1] == 12 then
nc = charclasses[tok[2]]
newchar = tok[2]
else
nc = 255
newchar = ''
end
local insert = ''
if interchartoks[oc] and interchartoks[oc][nc] then
insert = interchartoks[oc][nc]
local newtok = tok
if insert<100 then
local dec = math.floor(insert / 10) + 48;
local unit = math.floor(insert % 10) + 48;
newtok = {
-- \XeTeXinterchartokenstate=0 \the\toks<n> \XeTeXinterchartokenstate=1
token.create('XeTeXinterchartokenstate'),
token.create(string.byte('='),12),
token.create(string.byte('0'),12),
token.create(string.byte(' '),10),
token.create('the'),
token.create('toks'),
token.create(dec,12),
token.create(unit,12),
token.create(string.byte(' '),10),
token.create('XeTeXinterchartokenstate'),
token.create(string.byte('='),12),
token.create(string.byte('1'),12),
token.create(string.byte(' '),10),
{tok[1], tok[2], tok[3]}}
end
tok = newtok
end
oc = nc
end
return tok
end

callback.register ('token_filter', do_intertoks)
</pre>

LaTeX package file:

<pre>
% luatexinterchartoks.sty
\newcount\XeTeXinterchartokenstate

\newcount\charclasses
\def\newXeTeXintercharclass#1%
{\global\advance\charclasses1\relax
\newcount#1
\global#1=\the\charclasses
}

\newcount\cchone
\newcount\cchtwo

\def\dodoXeTeXcharclass
{\directlua{setcharclass(\the\cchone,\the\cchtwo)}}

\def\doXeTeXcharclass%
{\afterassignment\dodoXeTeXcharclass\cchtwo }

\def\XeTeXcharclass%
{\afterassignment\doXeTeXcharclass\cchone }

\protected\def\XeTeXdointerchartoks%
{\directlua{setinterchartoks(\the\cchone,\the\cchtwo,\the\allocationnumber)}}

\protected\def\dodoXeTeXinterchartoks%
{\newtoks\mytoks\afterassignment\XeTeXdointerchartoks\global\mytoks }

\protected\def\doXeTeXinterchartoks%
{\afterassignment\dodoXeTeXinterchartoks\cchtwo }

\def\XeTeXinterchartoks%
{\afterassignment\doXeTeXinterchartoks\cchone }

\luatexdirectlua{require('luatexinterchartoks.lua')}

\endinput
</pre>

Test document:

<pre>
\documentclass{article}

\usepackage{luatexinterchartoks}
\usepackage{color}

\begin{document}

\newXeTeXintercharclass \mycharclassa
\newXeTeXintercharclass \mycharclassA
\newXeTeXintercharclass \mycharclassB
\XeTeXcharclass `\a \mycharclassa
\XeTeXcharclass `\A \mycharclassA
\XeTeXcharclass `\B \mycharclassB
% between "a" and "A":
\XeTeXinterchartoks \mycharclassa \mycharclassA = {[\itshape}
\XeTeXinterchartoks \mycharclassA \mycharclassa = {\upshape]}
% between " " and "B":
\XeTeXinterchartoks 255 \mycharclassB = {\bgroup\color{blue}}
\XeTeXinterchartoks \mycharclassB 255 = {\egroup}
% between "B" and "B":
\XeTeXinterchartoks \mycharclassB \mycharclassB = {.}

\begingroup
\XeTeXinterchartokenstate = 1
aAa A a B aBa BB
\endgroup

\end{document}

</pre>

Writing Lua in TeX

2010-12-28T09:04:24Z

Taco: Reverted edits by 168.99.199.24 (talk) to last revision by Patrick

= Embedding Lua code in a TeX document =

Although it is simpler to put Lua code in Lua files, from time to time one may want or need to go Lua in the middle of a document. To this end, LuaTeX has two commands: <tt>\directlua</tt> and <tt>\latelua</tt>. They work the same, except <tt>\latelua</tt> is processed when the page where it appears is shipped out, whereas <tt>\directlua</tt> is processed at once; the distinction is immaterial here, and what is said of <tt>\directlua</tt> also applies to <tt>\latelua</tt>.

<tt>\directlua</tt> can be called in three ways:

<pre>
\directlua {<lua code>}
\directlua name {<name>} {<lua code>}
\directlua <number> {<lua code>}
</pre>

Those three ways are equivalent when it comes to process <tt><lua code></tt>, but in the second case processing will occur in a chunk named <tt><name></tt>, and in the third it will occur in a chunk whose name is the entry <tt><number></tt> in the table <tt>lua.name</tt>. The difference manifests itself only when errors occur, in which case the name of the chunk, if any, is reported.

Each call to <tt>\directlua</tt>, named or not, is processed in a separate chunk. That means that any <tt>local</tt> variable is defined for this call only and is lost afterward. Hence:

<pre>
\directlua{
one = 1
local two = 2
}
\directlua{
texio.write_nl(type(one))
texio.write_nl(type(two))
}
</pre>

will report <tt>number</tt> and <tt>nil</tt> (<tt>texio.write_nl</tt> writes to the log file). On the other hand, Lua code is completely insensitive to TeX's grouping mechanism. In other words, calling <tt>\directlua</tt> between <tt>\bgroup</tt> and <tt>\egroup</tt> doesn't affect the code to be processed.

= TeX catcodes in Lua =

By default, the code passed to <tt>\directlua</tt> is treated as normal TeX input and only then sent to the Lua interpreter. This may lead to unwanted results and must be acknowledged.

== Expansion ==

As with any other special, the code in <tt>\directlua</tt> (and the <tt><name></tt>, if specifed) is fully expanded. This means that macros can be safely passed to <tt>\directlua</tt> if one wants their values, but that they should also be properly escaped when needed. For instance:

<pre>
\def\macro{1}
\directlua{
myvar = \macro
}
</pre>

defines <tt>myvar</tt> as the number <tt>1</tt>. To store the control sequence <tt>\macro</tt> instead, another course of action is needed: see the [[#Backslash|section on backslash]] below.

== Line ends ==

When TeX reads a file, it normally turns line ends into spaces. That means that what looks like several lines is actually fed to the Lua interpreter as one big line. For instance:

<pre>
\directlua{
myvar = 1
anothervar = 2
onelastvar = 3
}
</pre>

amounts to the following, if it were written in a separate Lua file:

<pre>
myvar = 1 anothervar = 2 onelastvar = 3
</pre>

That is perfectly legitimate, but strange things might happen. First, TeX macros gobble spaces as usual. Hence:

<pre>
\def\macro{1}
\directlua{
myvar = \macro
anothervar = 2
}
</pre>

will be fed to the interpreter as

<pre>
myvar = 1anothervar = 2
</pre>

which is not legitimate at all. Second, the Lua comment <tt>--</tt> will affect everything to the end of the <tt>\directlua</tt> call. That is:

<pre>
\directlua{
myvar = 1
-- anothervar = 2
onelastvar = 3
}
</pre>

will be processed as

<pre>
myvar = 1 -- anothervar = 2 onelastvar = 3
</pre>

which works but only defines <tt>myvar</tt>. Third, when reporting error, the Lua interpreter will always mention the line number as 1, since it processes one big line only; that isn't extremely useful when the code is large.

The solution is to set <tt>\endlinechar=10</tt> or <tt>\catcode`\^^M=12</tt>. In both cases, line ends will be preserved and the code will be processed as it is input.

== Special characters ==

In TeX, some characters have a special behavior. That must be taken into account when writing Lua code: one must change their catcodes beforehand if one wants to handle them as Lua would, as has just been done for line ends. That means that <tt>\directlua</tt>, as such, is clearly insufficient to write any extended chunk of code. It is thus better to devise a special macro that sets the catcodes to the appropriate values, reads the Lua code, feeds it to <tt>\directlua</tt>, and restores the catcodes. The following code does the job:

<pre>
\def\luacode{%
\bgroup
\catcode`\{=12
\catcode`\}=12
\catcode`\^^M=12
\catcode`\#=12
\catcode`\~=12
\catcode`\%=12
\doluacode
}

\bgroup
\catcode`\^^M=12 %
\long\gdef\doluacode#1^^M#2\endluacode{\directlua{#2}\egroup}%
\egroup
</pre>

Note that not all special characters are set to normal (catcode 12) characters; that is explained for each below. Note also that <tt>\doluacode</tt>, internally called by <tt>\luacode</tt>, is defined to get rid of anything up to the line end, and then pass anything up to <tt>\endluacode</tt> to <tt>\directlua</tt>. Discarding what follows <tt>\luacode</tt> is important, otherwise a simple code as

<pre>
\luacode
myvar = 1
\endluacode
</pre>

would actually create two lines, the first being empty; it is annoying because errors are then reported with the wrong line number (i.e. any error in this one-line code would be reported to happen on line 2).

However, the rest of the line after <tt>\luacode</tt> could also be processed, instead of discarded, to manage special effects (e.g. specifying a chunk's name, storing the code in a control sequence, or even setting which catcodes should be changed or not).

=== Backslash ===

The backslash in TeX is used to form control sequences. In the definition of <tt>\luacode</tt> above, it isn't changed and thus behaves as usual. It allows commands to be passed and expanded to the Lua code. Anyway a backslash in Lua is also an escape character in strings. Hence, if one wants to store the name of a macro in Lua code, the following won't work:

<pre>
\luacode
myvar = "\noexpand\macro"
\endluacode
</pre>

because to the Lua interpreter the string is made of <tt>\m</tt> followed by <tt>acro</tt>; since <tt>\m</tt> is not defined in Lua, the string is read as <tt>macro</tt>, but in other circumstances strange things might happen: for instance, <tt>\n</tt> is a newline. The proper way to pass a macro verbatim is:

<pre>
\luacode
myvar = "\noexpand\\macro"
\endluacode
</pre>

which Lua will correctly read as

<pre>
myvar = "\\macro"
</pre>

with the backslash escaped to represent itself. Another solution is:

<pre>
myvar = [[\noexpand\macro]]
</pre>

because the double brackets signals a string in Lua where no escape sequence occurs (and the string can also run on several lines). Note however that in the second case <tt>myvar</tt> will be defined with a trailing space, i.e. as <tt>"\macro "</tt>, because of TeX's habit to append a trailing space to unexpanded (or unexpandable) control sequences.

=== Braces ===

One may want to define a string in Lua which contains unbalanced braces, i.e.:

<pre>
\luacode
myvar = "{"
\endluacode
</pre>

If the braces' catcodes hadn't been changed beforehand, that would be impossible. Note, however, that this means that one can't feed arguments to commands in the usual way. I.e. the following will produce nothing good:

<pre>
\luacode
myvar = "\dosomething{\macro}"
\endluacode
</pre>

<tt>\dosomething</tt> will be expanded with the left brace (devoid of its usual delimiter-ness) as its argument, and the rest of the line might produce chaos. Thus, one may also choose not to change the catcodes of braces, depending on how <tt>\luacode</tt> is most likely to be used. Note that strings with unbalanced braces can still be defined, even if braces have their usual catcodes, thanks to the following trick:

<pre>
\luacode
myvar = "{" -- }
\endluacode
</pre>

When the code is passed to <tt>\directlua</tt>, braces are balanced because the Lua comment means nothing to TeX; when passed to the Lua interpreter, on the other hand, the right brace is ignored.

=== Hash and comment ===

The hash sign <tt>#</tt> in Lua is the length operator: prefixed to a string or table variable, it returns its length. If its catcode weren't taken care of, LuaTeX would pass to <tt>\directlua</tt> a double hash for each hash, i.e. each <tt>#</tt> would be turned into <tt>##</tt>. That is normal TeX behavior, but unwanted here.

As for the commen sign <tt>%</tt>, it is useful in Lua when manipulating strings. If it weren't escaped it would discard parts of the code when TeX reads it, and a mutilated version of the input would be passed to the Lua interpreter. In turn, discarding a line by commenting it in <tt>\luacode</tt> should be done with the Lua comment <tt>--</tt>.

=== Active characters ===

The <tt>~</tt> character is generally active and used as a no-break space in TeX. It it were passed as is to <tt>\directlua</tt>, it would expand to uninterpretable control sequences, whereas in Lua it is used to form the unequal operator <tt>~=</tt>.

Other possible active characters should be taken care of, but which characters are active is unpredictable; punctuation marks might be so to accommodate special spacing, as with LaTeX's ''babel'' package, but such tricks are unlikely to survive in LuaTeX (cleaner methods exist that add a space before punctuation marks when necessary).

=== Other characters ===

When processing verbatim text in TeX, one generally also changes the catcodes of <tt>$</tt>, <tt>&</tt>, <tt>^</tt>, <tt>_</tt> and the space character, because they too are special. When passed to the Lua interpreter, though, their usual catcodes won't do any harm, that is why they are left unmodified here.

== \luaescapestring ==

Although it can't do all of what's been explained, the <tt>\luaescapestring</tt> command might be useful in some cases: it expands its argument (which must be enclosed in ''real'' braces) fully, then modify it so that dangerous characters are escaped: backslashes, hashes, quotes and line ends. For instance:

<pre>
\def\macro{"\noexpand\foo"}
\luacode
myvar = "\luaescapestring{\macro}"
\endluacode
</pre>

will be passed to Lua as

<pre>
myvar = "\"\\foo \""
</pre>

so that <tt>myvar</tt> is defined as <tt>"\foo "</tt>, with the quotes as parts of it. Note that the trailing space after <tt>\foo</tt> still happens.

= From Lua to TeX =

Inside Lua code, one can pass strings to be processed by TeX with the functions <tt>tex.print()</tt>, <tt>tex.sprint()</tt> and <tt>tex.tprint()</tt>. All such calls are processed at the end of a <tt>\directlua</tt> call, even though they might happen in the middle of the code. This behavior is worth noting because it might be surprising in some cases, although it is generally harmless.

== tex.print() ==

This function receives as its argument(s) either one or more strings or an array of strings. Each string is processed as an input line: an end-of-line character is appended (except to the last string), and TeX is in state <tt>newline</tt> when processing it (i.e. leading spaces are skipped). Hence the two equivalent calls:

<pre>
tex.print("a", "b")
tex.print({"a", "b"})
</pre>

are both interpreted by TeX as would the following two lines:

<pre>
a
b
</pre>

Thus `a b' is produced, since line ends normally produce a space.

The function can also take an optional number as its first argument; it is interpreted as referring to a catcode table (as defined by <tt>\initcatcodetable</tt> and <tt>\savecatcodetable</tt>), and each line is processed by TeX with that catcode regime. For instance (note that with such a minimal catcode table, braces don't even have their usual values):

<pre>
\bgroup
\initcatcodetable1
\catcode`\_=0
\savecatcodetable1
\egroup

\directlua{tex.print(1, "_TeX")}
</pre>

The string will be read with <tt>_</tt> as an escape character, and thus interpreted as the command commonly known as <tt>\TeX</tt>. The catcode regime holds only for the strings passed to <tt>tex.print()</tt> and the rest of the document isn't affected.

If the optional number is <tt>-1</tt>, or points to an invalid (i.e. undefined) catcode table, then the strings are processed with the current catcodes, as if there was no optional argument. If it is <tt>-2</tt>, then the strings are read as if the result of <tt>\detokenize</tt>: all characters have catcode 12 (i.e. `other', characters that have no function beside representing themselves), except space, which has catcode 10 (as usual).

== tex.sprint() ==

Like <tt>tex.print()</tt>, this function can receive either one or more strings or an array of strings, with an optional number as its first argument pointing to a catcode table. Unlike <tt>tex.print()</tt>, however, each string is processed as if TeX were in the middle of a line and not at the beginning of a new one: spaces aren't skipped, no end-of-line character is added and trailing spaces aren't ignored. Thus:

<pre>
tex.sprint("a", "b")
</pre>

is interpreted by TeX as

<pre>
ab
</pre>

without any space inbetween.

== tex.tprint() ==

This function takes an unlimited number of tables as its arguments; each table must be an array of strings, with the first entry optionally being a number pointing to a catcode table. Then each table is processed as if passed to <tt>tex.sprint()</tt>. Thus:

<pre>
tex.tprint({1, "a", "b"}, {"c", "d"})
</pre>

is equivalent to

<pre>
tex.sprint(1, "a", "b")
tex.sprint("c", "d")
</pre>

= The expansion of \directlua =

A call to <tt>\directlua</tt> is fully expandable; i.e. it can be used in contexts where full expansion is required, as in:

<pre>
\csname\directlua{tex.print("TeX")}\endcsname
</pre>

which is a somewhat convoluted way of saying <tt>\TeX</tt>. Besides, since Lua code is processed at once, things that were previously unthinkable can now be done easily. For instance, it is impossible to perform an assignment in an <tt>\edef</tt> by TeX's traditional means. I.e. the following:

<pre>
\edef\macro{\count1=5}
</pre>

defines <tt>\macro</tt> as <tt>\count1=5</tt> but doesn't perform the assignment (the <tt>\edef</tt> does nothing more than a simple <tt>\def</tt>). After the definition, the value of <tt>\count1</tt> hasn't changed. The same is not true, though, if such an assigment is made with Lua code. The following:

<pre>
\edef\macro{\directlua{tex.count[1] = 5}}
</pre>

defines <tt>\macro</tt> emptily (since nothing remains after <tt>\directlua</tt> has been processed) ''and'' sets count 1 to 5. Since such a behavior is totally unexpected in normal TeX, one should be wary when using <tt>\directlua</tt> in such contexts.

Traversing TeX nodes

2010-12-28T08:12:31Z

Taco: Reverted edits by 193.212.103.173 (talk) to last revision by Patrick

== Traversing TeX nodes ==

Put this code at the beginning of any TeX file:

<pre>
\directlua{
local glyph = node.id('glyph')
local hlist = node.id('hlist')
local vlist = node.id('vlist')

function gothru(h,prof)
for t in node.traverse(h) do
texio.write_nl(string.rep("...",prof) .. 'NODE type=' .. node.type(t.id) .. ' subtype=' .. t.subtype )
if t.id == hlist or t.id == vlist then
texio.write(' w=' .. t.width .. ' h=' .. t.height .. ' d=' .. t.depth .. ' s=' .. t.shift )
gothru(t.list,prof+1)
end
if t.id == glyph then
texio.write(' font=' .. t.font .. ' char=' .. t.char .. ' width=' .. font.fonts[t.font].characters[t.char]['width'])
end
end
end

callback.register('pre_linebreak_filter',
function(h)
gothru(h,0)
return true
end
)
}
</pre>

It will display a list of all nodes on the terminal and in the log file. For example, for the document

<pre>
\font\x=omlgc
\x bl? bla bla bla
</pre>

which contains a Greek letter (in UTF-8), you will get:

<pre>
This is luaTeX, Version 3.141592-snapshot-2007062922 (Web2C 7.5.6)
(
NODE type=whatsit subtype=6
NODE type=hlist subtype=0
NODE type=glyph subtype=0 font=51 char=98
NODE type=glyph subtype=0 font=51 char=108
NODE type=glyph subtype=0 font=51 char=941
NODE type=glue subtype=0
NODE type=glyph subtype=0 font=51 char=98
NODE type=glyph subtype=0 font=51 char=108
NODE type=glyph subtype=0 font=51 char=97
NODE type=glue subtype=0
NODE type=glyph subtype=0 font=51 char=98
NODE type=glyph subtype=0 font=51 char=108
NODE type=glyph subtype=0 font=51 char=97
NODE type=glue subtype=0
NODE type=glyph subtype=0 font=51 char=98
NODE type=glyph subtype=0 font=51 char=108
NODE type=glyph subtype=0 font=51 char=97
NODE type=glue subtype=0
Underfull \hbox (badness 10000) in paragraph at lines 14--15

[1] )
</pre>

Be aware of the fact that the nodes will be created only if the glyph requested indeed exists in the font.

[[User:Yannis.Haralambous|Yannis.Haralambous]] 02:52, 4 July 2007 (EDT)

Main Page

2010-12-28T00:04:18Z

Taco: Reverted edits by 62.90.255.28 (talk) to last revision by Patrick

== Welcome to the LuaTeX wiki ==

This is a wiki for [http://www.luatex.org LuaTeX], a typesetting engine derived from
[http://en.wikipedia.org/wiki/TeX TeX] that includes [http://www.lua.org Lua] as an embedded scripting language.

We are [[Special:Recentchanges|currently editing]] [[Special:Allpages|{{NUMBEROFARTICLES}}]] articles.

* [http://www.mediawiki.org/wiki/Help:Formatting How to edit wiki pages]
* [[Bug tracking|Bug tracking]]: Mantis [http://tracker.luatex.org bug tracker]

== Getting help ==

* There are two mailing lists related to LuaTeX, [http://tug.org/mailman/listinfo/luatex one for general discussions and questions about LuaTeX ("luatex users")] and [http://www.ntg.nl/mailman/listinfo/dev-luatex one more related to the development of LuaTeX ("dev-luatex")]
* There is also [http://www.tug.org/mailman/listinfo/lualatex-dev a LuaLaTeX (LaTeX with LuaTeX) mailing list].
* [http://tex.stackexchange.com/ tex.stackexchange.com] is a q&a site for questions related to TeX, and you can ask (and answer) LuaTeX related questions there.
* The [http://www.luatex.org/svn/trunk/manual/luatexref-t.pdf online reference manual (pdf)] describes every aspect of LuaTeX, but is rather technical and concise.

== Some topics from the old wiki at bluwiki.com ==

(Thanks to [http://omega.enstb.org/yannis/ Yannis Haralambous])

* An example of code [[traversing TeX nodes]] before an horizontal list goes through the line breaking engine;
* An example of code [[traversing tokens]] just before execution or expansion;
* you want to [[explore the table obtained from a TrueType font]], loaded by <tt>font.read_ttf</tt>;
* you want to [[explore the internal font table]] of a pre-loaded font or of a font you have loaded by <tt>\font</tt> and then used for at least one glyph;
* how to [[use a TrueType font]] without going through a TFM or a OFM file;
* how to do <i>kinsoku</i> ([[Japanese and more generally CJK typesetting]]);
* you want a newline in your log file or on the terminal? add <tt>\string\n</tt> to your string;
* you want to [[sort a token list]];
* you want to [[split a comma-separated list]];
* you want to [[encrypt your document using ROT13]];
* you want to [[typeset non-TeX files by converting them using Lua code]];
* example code to [[mirror characters with Bidi_Mirrored property]];
* using mplib to write [[metapost with LuaTeX]]

Main Page

2010-12-05T12:35:16Z

Taco:

Main Page

2010-12-05T12:25:33Z

Taco:

This is a wiki for [http://www.luatex.org LuaTeX], a typesetting engine derived from
[http://en.wikipedia.org/wiki/TeX TeX] that includes [http://www.lua.org Lua] as an embedded scripting language.

Main Page

2010-12-05T12:21:08Z

Taco: /* Welcome */

This wiki is for [http://www.luatex.org LuaTeX], a typesetting engine derived from [http://www.tug.org TeX] that is using [http://www.lua.org Lua] as an embedded scripting language.

Main Page

2010-12-05T12:20:57Z

Taco: /* Welcome */

= Welcome =

This wiki is for [http://www.luatex.org LuaTeX], a typesetting engine derived from [http://www.tug.org TeX] that is using [http://www.lua.org Lua] as an embedded scripting language.