Introduction

First, this section introduces a KiTTy itself and shows a comparison to alternative softwares, and introduces a value of KiTTy and use case of KiTTy. And also, it shows supported features.

What is KiTTy

KiTTy means Kinx Tiny Typesetting, which is a simple typesetting system implemented by Kinx. It also provides a translator from Markdown, then you can typeset a Markdown document and can get a beautiful document. This document itself is also the example typeset by this system.

The objective is similar to \LaTeX, it is an objective to typeset beautifully for a document managed as a text file. To be concretely, it is never going to be alternative, but the objective is being more useful in the use case like your personal situation by followings.

• Keeping a small system.
• Pretty beautiful output.
• Directly output as PDF file.

KiTTy is small but it has a simple feature to typeset it beautifully, and it is a typesetting system to output PDF directly from Markdown document.

Versus \LaTeX

\LaTeX is a huge system. It is extendable, it is supported by many people, and it is a typesetting system which can make a beautiful document. KiTTy is also a typesetting system which has a same objective as \LaTeX, but it is provided as a small system with limited features.

Being huge of \LaTeX system causes a complexibility of an installation. Besides, there are multiple distributions to provide many functionality of \TeX and \LaTeX. That is the reason why people have to think first what distribution should be used. Everybody can use KiTTy with Kinx soon, because KiTTy has been already distributed as a Kinx package named as Kinx Tiny Typesetting.

Only one cons point is that limited features¹ are provided. And also the compilation speed is slow. It takes about 4 minutes to compile this document. The performance is one of problems, but this system is focusing what is used as a small and a personal use.

Versus Word

The Word is a famous WYSIWYG² Word Processor, but it is based on a different concept. The word processor can edit a document as it shows, but it usually saves a document as a binary style. Therefore, in general, you need an own software, which is ''Word'' in this case, to show its content. With KiTTy, same as \LaTeX, you can see its content directly because it is a text style, and can edit it with your familier editor.

Saving as a text, it can be processed easily by another software, and also showing diff in a version control like Git is very easy. This is quite important and a mandatory requirement, especially for the management of source code. Besides, about the structure of a document, it is difficult from its looking to distinguish if it is structured or not. For example, you can not find its chapter number is correctly assigned, and you can not find if it would corrected when you change a layout or a location of sentences. In particular, there is a case sometimes you have met unlucky cases as someone has not set it up correctly.

The structure is clearly written in text style in KiTTy, it can correctly realize to make a cross-reference, numbering a chapter number, a figure number, a table number, and a page number. Instead, it is a cons point not to show the document as it shows, like WYSIWYG. You have to compile first to show the actual document to be typeset.

Versus Vivliostyle

CSS Typesetting is based on the Web Technology, and CSS Typesetting now has a most great future. Therefore CSS Typesetting is recommended if you want to do typeset in earnest. Especially Vivliostyle³ is a very hopeful project.

As for KiTTy, it is important to be a small system and easy to use. Although time will solve, CSS Typesetting is still making it standard in progress. Therefore some of the specification has not been clarified yet, and it is possible to assume it will be changed in future. As this is a big project and making it standardized, it will be a system to use in a real commercial use, but the system itself will be getting huge.

Said again, a main point of view in KiTTy is a small and easy to use.

Conclusion

If you want to use a typesetting system right now in a real earnest, you should use \LaTeX. If you want to study a typesetting system in the future and use it, you had better use a CSS Typesetting like Vivliostyle. Moreover, in sumerize, KiTTy will be useful in following situations.

• Wants to use a small system, instead of the huge system like \TeX.
• Wants to manage a diff by a version control system like Git.
• Wants to control the structure of a document and make a cross-reference correctly.

This system is provided to the person⁴ who think the \TeX system is very huge as a system for creating a small document, and who wants to manage the document as a text file. In particular, if you want to manage a document and a diff by the system like Git, it is quite difficult to manage it by Word which is realized by the style of WYSIWYG. It is a main target of use cases not to manage by a word processor and not to use a huge system.

Supported Features

Typesetting Features

KiTTy supports following features. See ''\nameref{Features Overview}'' for a concrete content of features. By the way, kerning is not supported so far.

• Hyphenation, justification, and line-breaking algorithm
• Widows and Orphans
• Multiple columns
• Itemization
• Math formula and equations
• Image
• Chart
• Table
• Font
• Color
• Ligature
• Programming Code Block
• Title, Cover Page, and Contents
• Chapter and Section
• Cross-Reference
• Quotation
• Footnote

Typesetting Features in Japanese

KiTTy also supports following features for the own requirement in Japanese. If you want to add any other languages, I can not lead you because I am sorry I do not have any knowkedge for other languages. As it has been difficult to care about the extension point for other languages, it might need to add a lot of features or many points of fixes. But it will be possible to extend features because this is an open source.

• Japanese hyphenation
• Japanese Ruby like \ruby[how to read]{Difficult Kanji}

PDF Features

Although this is not available when it is printed on a paper, the following features are supported.

• External Link by URL
• Link by Cross-Reference
• Bookmark

Getting Started

This chapter introduces about preparing to start using KiTTy in practice and how to use through simple examples. By the way, there are differences about how to prepare between Windows and Linux, but you can get a same result as long as you use prepared fonts in KiTTy. Therefore you can use both without problems.

Installation

KiTTy has been distributed as a Kinx package named as Kinx Tiny Typesetting. Therefore, there are 2 steps to install it.

1. Install Kinx
2. Install KiTTy package

Install Kinx

At first, you need to install Kinx.

Windows

You can use Scoop to install Kinx on Windows.

$ scoop bucket add kinx https://github.com/Kray-G/kinx # only needed the first time
$ scoop install kinx
$ kinx --install-path

Register the bucket URL at first. This registration is needed at the first time only. If the bucket were registered, you could install Kinx by the command of scoop install Kinx. After installing Kinx by Scoop, execute the command of kinx --install-path to use a package command.

Linux

On Linux(Ubuntu), download a .deb file⁵ from Relases page first. After that, move to the directory where you downloaded the file, and install it as below.

$ sudo apt install ./kinx_1.1.0-0_amd64.deb

Install Kinx Tiny Typwsetting Package

Windows

To install a Kinx package, use the kip command. By executing it as below on a command prompt, you can install the latest package automatically.

$ kip install typesetting

Linux

It is almost same as Windows, but you need an administrator privilege on Linux. Use the sudo command if necessary.

$ sudo kip install typesetting

hello, world

Create the following text and save it as the name of helloworld.md.

% Hello Kinx Tiny Typesetting
% Your name
% October 7, 2020

# Greeting
hello, world

Execute kxkitty command as below, and helloworld.pdf will be generated.

$ kxkitty helloworld.md

Features Overview

This chapter will explain the feature\apos{}s overview. As this document itself has been generated by this system, you can realize all what this document realize. Let\apos{}s try various things first.

Typesetting Features

Hyphenation, Justification, and Line-Breaking Algorithm

This system supports a Hyphenation based on Franklin M. Liang algorithm. And also this supports a justification with that hyphenation algorithm.

Line-breaking is based on Knuth-Plass Line Breaking algorithm. This algorithm is what is controlled by Box, Glue, and Penalty, and it is same as the algorithm implemented in \TeX. These hyphenation and line-breaking argorithm are the well-known as the best practice in the typesetting so far. Note that it is not all same as the output by \TeX, because this is implemented by Kinx.

Widows and Orphans

In some case, this system provides a part of a penalty control for Widows and Orphans. Note that this is not perfect for all cases. It is available for following cases.

• Deterrent to put a section name to the bottom of page.
  • In this case, a section name is moved to a next page.
• Deterrent to put only a top line in a paragraph to the bottom of page.
  • In this case, all lines in a paragraph is moved to a next page.
  • When only a section name is put to the bottom of page as a result, a section name is also moved to the next page.
• Deterrent to put only a last line in a paragraph to the top of a next page.
  • In this case, last 2 lines are moved to a next page.

Those above mechanisms are automatically done. You do not have to do anything in your document. But those are not perfect for all cases, therefore use <pagebreak /> command when you feel it is not good layout, and you can insert a page break there.

*   Level 1
    *   Level 2
        *   Level 3
            *   Level 4

1.  Level 1
    1.  Level 2
        1.  Level 3
            1.  Level 4
            1.  Level 4

*   Level 1
    1.  Level 2
        *   Level 3
            1.  Level 4

```math:label=Math1
\begin{aligned}
    \int_{-\infty}^{\infty} f(x) dx &= \sqrt{\pi}
\end{aligned}
```

\begin{aligned}
    \int_{-\infty}^{\infty} f(x) dx &= \sqrt{\pi}
\end{aligned}

```math:label=Math2(0.2)/Math3(0.6)
\begin{aligned}
    E &= mc^2 \\
    m &= \frac{m_0}{\sqrt{1-\frac{v^2}{c^2}}} \\
\end{aligned}
```

\begin{aligned}
    E &= mc^2 \\
    m &= \frac{m_0}{\sqrt{1-\frac{v^2}{c^2}}} \\
\end{aligned}

![scale=0.6](kinxlogo.png)

The file icon is changed to ![scale=0.08,offsetY=-5.0](zip256.png).

{
    width: 800,
    height: 400,
    fontSize: 16,
    scale: 1.0,
    label: "Fig:RadarExample",
    caption: "Radar Chart Example",
    options: {
        type: "radar",
        data: {
            labels: [["Eating", "Dinner"], ["Drinking", "Water"],
                "Sleeping", ["Designing", "Graphics"],
                "Coding", "Cycling", "Running"],
            datasets: [{
                label: "My First dataset",
                backgroundColor: "rgba(255, 0, 0, 0.2)",
                borderColor: "red",
                pointBackgroundColor: "red",
                data: [ 10.1, 80.0, 72.2, 73.3, 55.0, 68.5, 92.0 ]
            }, {
                label: "My Second dataset",
                backgroundColor: "rgba(0, 0, 255, 0.2)",
                borderColor: "blue",
                pointBackgroundColor: "blue",
                data: [ 30.9, 77.1, 49.9, 50.0, 67.8, 71.0, 22.8 ]
            }]
        },
        options: {
            legend: {
                position: "top",
            },
            scale: {
                ticks: {
                    beginAtZero: true
                }
            }
        }
    }
}

{
    float: { right: true },
    width: 480,
    height: 300,
    scale: 0.4,
    caption: "Line Chart Example",
    options: {
        type: "line",
        data: {
            labels: ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul"],
            datasets:[{
                lineTension: 0,
                label: "Line A",
                data: [ 10.9, 32.8, 44.1, 56.9, 78.3, 64.2, 91.2],
                backgroundColor: "rgba(0, 0, 255, 0.2)",
                borderColor: "rgb(0, 0, 255)",
                borderWidth: 1
            }]
        },
        options: {
            legend: {
                labels: {
                    fontColor: "#0000ff"
                }
            }
        }
    }
}

```chart
{
    float: { right: true },
    width: 480, height: 300, scale: 0.4, caption: "Line Chart Example",
    options: {
        type: "line",
        ...(omitted)
    }
}
```

<context label="Table:ImageOptions"/>
<context caption="Image Options"/>
| Option  |      Value      |                  Meaning                  |
| ------- | --------------- | ----------------------------------------- |
| `float` | `left`, `right` | A location of a floating image.           |
| `scale` | 0.0 ～ 1.0      | A scale against the area between margins. |

<context label="Table:TableExample"/>
<context caption="Example of Table"/>
<context vline-left="single"/>
<context vline-right="single"/>
<context vline-inside="single"/>
<context hline-header="double"/>
<context hline-inside="single"/>
<context cell-2-1="$\displaystyle\int_{-\infty}^{\infty} f(x) dx = \sqrt{\pi}$"/>
| Left |         Center         |         Right         |
| :--- | :--------------------: | --------------------: |
| A1   | Aligned to the center. | Aligned to the right. |
| A2   |      Cell $(1,1)$      |      Cell $(1,2)$     |
| A3   |           -            |      Cell $(2,2)$     |

<font-load info="Name,type,shape,FileName.ttf" />

<font-load info="Parisienne,serif,regular,Parisienne-Regular.ttf" />
- Changing the font is available only with a scope like
''\\font\[name=Parisienne\]{This is a pen.},''
and the font will be restored here.

''After this, the font size will be \\font\[size=7pt\]{shrink to 7pt}.
And after this, the font size will be \\font\[size=15pt\]{extend to 15pt}.''
will be shown.
And also, for example, `\font[size=1.2em]{1.2 times larger size}` shows
\\font\[size=1.2em\]{1.2 times larger size} will be shown.

This is an example of `\bigger`.
\\bigger{This is, \\bigger{this is, \\bigger{this is} a sentence,} a sentence}.
For `\smaller`,
\\smaller{This is, \\smaller{this is, \\smaller{this is} a sentence,} a sentence}.

*   \\color\[red\]{\\bold{Red}.
    This line should be colored by the name of `red`.}
*   \\color\[green\]{\\bold{Green}.
    This line should be colored by the name of `green`.}
*   \\color\[blue\]{\\bold{Blue}.
    This line should be colored by the name of `blue`.}
*   \\color\[cyan1\]{\\bold{Cyan}.
    This line should be colored by the name of `cyan1`.}
*   \\color\[magenta1\]{\\bold{Magenta}.
    This line should be colored by the name of `magenta1`.}
*   \\color\[yellow\]{\\bold{Yellow}.
    This line should be colored by the name of `yellow`.}
*   \\color\[R=0,G=64,B=255\]{\\bold{RGB}.
    This line should be colored by RGB value of `RGB=0,64,255`.}
*   \\color\[C=0.5,M=0.8,Y=0.2,K=0.0\]{\\bold{CMYK}.
    This line should be colored by CMYK value of `CMYK=0.5,0.8,0.2,0.0`.}

This is an ''example'' of double-quote.

```
class Test {
    public test() {
        # Test Method.
    }
}
```

class Test {
    public test() {
        # Test Method.
    }
}

```:lineNumber=false,box=BOX_NORMAL
class Test {
    public test() {
        # Test Method.
    }
}
```

class Test {
    public test() {
        # Test Method.
    }
}

<code-style lang="ruby" name="box" value="shadow" />
<code-style lang="ruby" name="background-color" value="lightcyan1" />

// This is a kinx block.
function fib(n) {
    if (n < 3) return n;
    return fib(n-2) + fib(n-1);
}
System.println(fib(34));

# This is a python block.
def fib(n):
    if n < 3:
        return n
    else:
        return fib(n-1) + fib(n-2)
print fib(34)

# This is a ruby block.
def fib(n)
  return n if n < 3
  fib(n-1) + fib(n-2)
end
p fib(34)

% KiTTy
% Kray-G, Mr.Diamond Global Blue Publisher
% September 18, 2020

Small and Easy, but Beautiful Design For You

<param style="JBookA4"/>
<param titleSize="78.8"/>
<param subtitleSize="14.4"/>
<param backgroundImage="back.jpg"/>

<toc with="lof,lot"/>

<style-info name="chapter.style" value="BigChapter3" />

> **KiTTy** means **Ki**nx **T**iny **Ty**pesetting,
> which is a simple typesetting system implemented by Kinx.
> > \\noindent It also provides a translator from Markdown,
> > then you can typeset a Markdown document and can get a beautiful document.
> > This document itself is also the example typeset by this system.
> 
> The objective is similar to \\LaTeX, it is an objective to typeset beautifully for
> a document managed as a text file.

This is a footnote[^f1] in this paragraph.

[^f1]: This is a footnote text.

> \\noindent ある日の事でございます。\\ruby\[おしゃかさま\]{御釈迦様}は
> 極楽の\\ruby\[はすいけ\]{蓮池}のふちを、
> 独りでぶらぶら御歩きになっていらっしゃいました。

> \\noindent ある日の事でございます。\\ruby\[お|しゃ|か|さま\]{御釈迦様}は
> 極楽の\\ruby\[はす|いけ\]{蓮池}のふちを、
> 独りでぶらぶら御歩きになっていらっしゃいました。

$INSTALL/lib/std/typesetting/style/additional/*.kx

$INSTALL/lib/std/typesetting/style/basic/*.kx

$INSTALL/lib/std/typesetting/style/Styles.kx

using typesetting.style.basic.ArticleA4;

namespace Typesetting {
namespace Style {

    class ArticleA4_2Cols : Typesetting.Style.ArticleA4 {
        @style.columns = 2;
    }

} # namespace Style
} # namespace Typesetting

$INSTALL/lib/std/typesetting/style/title/*.kx

<style-info name="title.style" value="yourstylename" />

namespace Typesetting {
namespace Style {

    Typesetting.Style.Title[__FILE__.stem()]
        = function(info, context, core, title, opts) {
            # drawing a Title Design
        };

} # namespace Style
} # namespace Typesetting

$INSTALL/lib/std/typesetting/style/chapter/*.kx

<style-info name="chapter.style" value="yourstylename" />

namespace Typesetting {
namespace Style {

    Typesetting.Style.Chapter[__FILE__.stem()]
        = function(info, context, core, text, opts) {
            # drawing a Chapter Design
        };

} # namespace Style
} # namespace Typesetting

$INSTALL/lib/std/typesetting/lang/*.kx

<style-info name="hyphenationRule" value="yourprocname" />

Typesetting.insertGlue[__FILE__.stem()] = _function(info, Linebreak, wordlist, nodes) {
    # Hyphenation Rules

    wordlist.each { &(node, i):
        # ...
        nodes.push(Linebreak.Glue(0, Linebreak.Infinity, 0));
        nodes.push(Linebreak.Penalty(0, -Linebreak.Infinity, 0));
        nodes.push(node);
        # ...
    };
};

nodes.push(Linebreak.Penalty(0, Linebreak.Infinity, 0));
nodes.push(node);   # Target Node

nodes.push(node);   # Target Node
nodes.push(Linebreak.Penalty(0, Linebreak.Infinity, 0));

nodes.push(Linebreak.Glue(0, Linebreak.Infinity, 0));
nodes.push(Linebreak.Penalty(0, Linebreak.Infinity, 0));
nodes.push(node);   # Target Node

nodes.push(Linebreak.Glue(width, stretch, shrink));
    # width ..... Width of Glue
    # stretch ... Maximum additional width limitation.
    # shrink .... Minimum shrinked width limitation.
nodes.push(node);   # Target Node

$INSTALL/lib/fonts

<font-load info="Times,serif,regular,times.ttf" />

* This is a Regular Style of a default font.
* \\font\[name=Times\]{Times New Roman of Regular Style}

$INSTALL/lib/std/typesetting/command/inline/*.kx
$INSTALL/lib/std/typesetting/command/paragraph/*.kx

namespace Typesetting {
namespace Command {

    class Command(info_, context_) {
        public exec(params) {
            var ws = new Typesetting.WordSet(info_);
            # ...
            return ws;
        }
    }

} # namespace Command
} # namespace Typesetting

namespace Typesetting {
namespace ParagraphCommand {

    class Command(info_, context_) {
        public start() {
            # Procedure when started by `{`
        }
        public end() {
            # Procedure when ended by `}`
        }
        public translate(value) {
            # A paragraph between `{` and `}` is received as value.
            # value is an array of WordSet or something because this is called after
            # processing a paragraph.  If you want to translat from value to another
            # word set, do process it here.
            # This method is called before calling end().
        }
    }

} # namespace Command
} # namespace Typesetting