It represents the subjective view of its authors and contributors
as to one possible approach to address the problem,
and does not claim to be the only possible solution.
It is submitted to present a non-Japanese speaking audience
with this particular approach,
and to encourage discussion of this topic.
Ruby is the name given to the small annotations
in Japanese content that are rendered alongside base text,
usually to provide a pronunciation guide,
but sometimes to provide other information.
(See the article “What is ruby”
by the internationalization Working Group
for more information.)
The Difficulties of Ruby Processingルビ処理のむつかしさ
When performing ruby layout in Japanese,
the following factors need to be considered
in order to decide on the position:
ルビの組版処理は，次のような事項を考慮して，その配置位置を決める必要がある．
How to handle the correspondence between the base characters and the ruby
親文字とルビの対応をどう処理すればよいのか
What to do when the string of base characters is longer than the ruby string
親文字の文字列の全長に比べ，ルビ文字の文字列の全長が短い場合，どう処理すればよいのか
What to do when the string of base characters is shorter than the ruby string
When the ruby string protrudes from the base character string,
whether it can be allowed to be laid over the characters preceding or following,
and whether this affects the position of the base characters
When the ruby string protrudes from the base character string,
and the base character string is at the start or the end of the line,
whether the base character string or the ruby string should be aligned with the line edge
When there are multiple base characters,
whether there can be line wrap opportunity between them
親文字が複数の場合，2 行にわたる分割をしてよいのか
In movable type typography,
such matters were resolved based generic principles,
and could always be corrected during the proofreading phase.
Essentially, each case was adjusted individually in a flexible manner.
In computer-based typesetting,
the layout needs to be more or less determined based on predetermined rules,
but it remained necessary to adjust the results in certain cases,
for example by changing the association between base characters
and the ruby string,
or by switching to a different placement policy.
When thinking about computing placement for web content,
it is not practical to decide on the positioning
case by case as was done in movable type typography.
It is therefore necessary to decide upon comprehensive rules
that provide solutions to all the problems listed above,
so that placement may be determined fully automatically.
Considering all the possibilities that existed in movable type typesetting,
the system to be designed needs to be very complex.
Web での配置処理を考えた場合，活字組版のように個別箇所で配置位置を工夫する処理は避けるのが望ましい．となると，上記の問題をすべて解決できる配置処理方針を決め，処理系に実装していく必要がある．活字組版で理想とされていた処理方法をカバーするとなると，かなり複雑な処理方針を考える必要がある．
However, when considering the ideal positioning of ruby,
it seems inevitable that exceptions will occur, causing issues.
In such cases, rather than ideal positioning,
we must at least make sure that the positioning causes no misunderstanding;
there are also practical limits to how complex the system can be
in order to be practically implementable.
The following is a proposal for a simple processing system. The target audience is implementers and specification writers.
Note that the terminology is based on that defined in
JLReq [[JLREQ]]. It is expected that a full system may be more complex that what is described here, both due to the interaction with other features or other writing systems, and because those designing such system may wish to provide alternative options.
以下は，こうした簡便な配置処理方法の一案である．なお，用語は JLReq（⽇本語組版処理の要件，Requirements for Japanese Text Layout）による． [[JLREQ]]
Matters considered by the simple placement rules簡便な配置ルールで考慮した事項
Matters considered by the placement rules配置ルールで考慮した事項
Here are the fundamental assumptions underlying the simple placement rules.
簡便な配置ルールを考えるにあたっては，次のような事項を考慮し，また前提とした．
Ruby is used to display the reading or the meaning of the base characters.
Therefore, the number one priority here is to avoid misreadings.
ルビは，親文字の読み方又は意味を示すものである．そこで，誤読されないことを第一とした．
The method detailed in this document that attempts to reduce exceptions as much as possible.
Therefore, there is no requirement for complex processing.
できるだけ例外のでない配置処理を考えた．したがって，配置処理でも複雑な処理は要求していない．
The method is agnostic to horizontal vs vertical writing,
and will use the same logic in either case.
縦組と横組とで配置処理法を変えることなく，共通の処理ができる方法とした．
The method places the ruby string relative to the base character string
the same way when they occur in the middle, start, or end of the line.
Moreover, this method does not change the relative position
of the ruby string to the base character string
depending on preceding or subsequent characters.
In other words, this method calculates a position
for the ruby relative to the base string
that does not change depending on context.
Generally speaking, the processing method is based on JIS X 4051 [[JIS4051]]
(Formatting rules for Japanese documents).
However, in some cases, optional steps are used.
処理法は，原則として JIS X 4051（日本語文書の組版方法）で規定している方法によった．[[JIS4051]] ただし，処理系定義として採用できる処理方法（オプション）を採用した場合がある．
The ruby font size is set to half of the base character’s size as a default.
However, the method supports using different sizes than 1/2.
While there are cases of ruby on both sides of the base string exist,
the method defined here only handles ruby on one side.
Handling both sides is left as a future exercise.
Ruby in Japanese may be divided into the following 3 different types,
based on the relationship between the ruby and the base characters
(see JLReq “3.3.1 Usage of Ruby” [[JLREQ]]).
Which one to use depends on the relationship
between the ruby and the base characters.
Mono-ruby is used to connect ruby to a single base character,
Jukugo-ruby is used when multiple base characters each have a corresponding ruby
and at the same time the whole group needs to be processed together,
and group-ruby is used when ruby is attached to a group of base characters together (see ).
Each is used when specified.
Rules for Simple Placement of Japanese Rubyルビの簡便な配置ルール
Ruby character size and character placementルビの文字サイズと配置位置
The size of the ruby characters
and their placement in the inline direction relative to the base characters is as follows:
ルビの文字サイズと親文字に対する行送り方向の配置位置は，次による．
The size of the ruby is by default set to
half of the size of the base characters.
ルビの文字サイズは，親文字の文字サイズの 1/2 を初期値（デフォルト値）とする．
In vertical text, ruby is placed to the right of the base characters,
and the character frame of the ruby is placed flush
against the character frame of the base characters.
縦組のルビは，親文字の右側とし，親文字の文字の外枠とルビ文字の外枠を接して配置する．
Example of vertical ruby縦組のルビの例
In horizontal text, ruby is placed to the top of the base characters,
and the character frame of the ruby is placed flush
against the character frame of the base characters.
横組のルビは，親文字の上側とし，親文字の文字の外枠とルビ文字の外枠を接して配置する．
Example of horizontal ruby横組のルビの例
The following sections describe in detail the placement of
mono-ruby,
jukugo-ruby,
and group-ruby.
However, since jukugo-ruby is more complex,
it is explained last.
When the ruby is made of two or more characters,
each character in the ruby string is placed
immediately next to its neighboring character,
without any inter-letter spacing.
Furthermore, when the ruby is composed of characters such as
Grouped numerals (cl-24),
Unit symbols (cl-25),
Western word space (cl-26),
or Western characters (cl-27) [[JLREQ]]
which have their own individual width,
they are placed based on each character’s metrics.
Example mono-ruby with western characters欧字のモノルビの例
The center of the ruby string and of the base character string
are aligned in the inline direction.
(see ).
ルビ文字の文字列と親文字の字詰め方向の中心をそろえて配置する（[[[#mono-ex-1]]]）．
Since the base character and its associated ruby form a single unit
there is no line wrapping opportunity inside a mono-ruby.
モノルビの場合，親⽂字とそれに付くルビ⽂字の⽂字列は，⼀体として扱い，2 ⾏に分割してはならない．
When the ruby string is longer than the base character string,
the part of the ruby string that extends beyond the base characters
must not hang over the characters preceding or following,
if they are
ideographic characters (cl-19),
Hiragana (cl-15),
Katakana (cl-16),
etc [[JLREQ]].
Space is introduced accordingly
between these preceding or following characters and the base characters.
However, in the following cases,
the ruby characters do hang over the preceding or following characters
(see ).
ただし，次の場合に限り，ルビを掛ける（[[[#mono-ex-2]]]）．
If the character preceding the base character is one of:
Closing brackets (cl-02),
Full stops (cl-06),
Commas (cl-07),
Full-width ideographic space (cl-14),
or Middle dots (cl-05) [[JLREQ]],
then the ruby must hang over
the blank portion at the end the character.
(This blank portion is usually half the character’s width,
except in the case of Middle dots (cl-05) [[JLREQ]]
where it is a fourth of the character width).
However, if this blank part has been compressed
due to justification or similar processing of the line,
then the ruby may only hang over the resulting
compressed blank space
(e.g. if it was reduced from half to a quarter em,
hang at most a quarter em).
If the character following the base character is one of:
Opening brackets (cl-01) or
Full-width ideographic space (cl-14),
Middle dots (cl-05) [[JLREQ]],
then the ruby must hang over
the blank portion at the start the character.
(This blank portion is usually
half the character’s width for Opening brackets (cl-01),
or a quarter of the character’s width for Middle dots (cl-05) [[JLREQ]])
However, if this blank part has been compressed
due to justification or similar processing of the line,
then the ruby may only hang over the resulting
compressed blank space
(e.g. if it was reduced from half to a quarter em,
hang at most a quarter em).
When the ruby string is longer than the base character string,
and the ruby falls at the start of the line,
then the start of the ruby string is aligned with the line’s start edge
(see ),
while if the ruby falls at the end of the line,
then the end of the ruby string is aligned with the line’s end edge
(see ).
When their respective lengths would be the same,
both are laid out without inter-letter spacing
and placed such that their respective centers in the inline direction are aligned
(see ).
When the ruby string is shorter than the base character string,
space is inserted between every character in the ruby string
as well as at the start and the end of the ruby string
so that it becomes the same length as the base character string,
then their centers in the inline direction are aligned.
The size of the space inserted between each of the ruby characters
is twice the size of the space inserted at the end and at the start
(see ).
However, the size space inserted at the start and end must
be capped at no more than half the size of one base character,
and the space inserted between each ruby character is enlarged to compensate
(see ).
When the ruby string is longer than the base character string,
space is inserted between every character in the base character string
as well as at the start and the end of the base character string
so that it becomes the same length as the ruby string,
then their centers in the inline direction are aligned.
The size of the space inserted between each of the base characters
is twice the size of the space inserted at the end and at the start
(see ).
When their respective lengths would be the same,
both are laid out without inter-letter spacing
and placed such that their respective centers in the inline direction are aligned.
When the ruby string is shorter than the base character string,
space is inserted between every character in the ruby string
as well as at the start and the end of the ruby string
so that it becomes the same length as the base character string,
then their centers in the inline direction are aligned.
The size of the space inserted between each of the ruby characters
is twice the size of the space inserted at the end and at the start.
When the ruby string is longer than the base character string,
both are laid out without inter-letter spacing
and placed such that their respective centers in the inline direction are aligned.
In this case, the ruby string protrudes from the base character string.
When their respective lengths would be the same,
both are laid out without inter-letter spacing
and placed such that their respective centers in the inline direction are aligned.
When the ruby string is shorter than the base character string,
both are laid out without inter-letter spacing
and placed such that their respective centers in the inline direction are aligned.
When the ruby string is longer than the base character string,
space is inserted between every character in the base character string
as well as at the start and the end of the base character string
so that it becomes the same length as the ruby string,
then their centers in the inline direction are aligned.
The size of the space inserted between each of the base characters
is twice the size of the space inserted at the end and at the start.
When the ruby string is longer than the base character string and protrudes,
whether and how it hangs over characters preceding or following
the base character string
is handled in the same way as with mono-ruby
(see ).
Also, when the ruby string is longer than the base character string,
protrudes, and is located at the start or end of the line,
the resulting layout is also identical to that of mono-ruby.
In the case of group ruby,
the base character string and its associated ruby string
are treated as a unit,
so there is no line wrapping opportunity inside either string.
With jukugo-ruby, each base character is associated with its own ruby string.
When the length of each of these ruby string laid out without inter-letter spacing
is shorter than the length of all their corresponding base characters,
placement is determined as follows:
When the ruby string associated with an individual base character is 1 character long,
the ruby character and the base character
are placed such that their respective centers in the inline direction are aligned
(see ).
When the ruby string associated with an individual base character is 2 characters long or more,
the ruby string is laid out without inter-letter spacing,
and placed such that its center and the center of its base character are aligned in the inline direction
(see ).
For simple ruby implementations, the resulting layout would look identical to group-ruby
when laid out without inter-letter spacing,
the processing is identical to group-ruby
(see and ).
Example 2 of jukugo-ruby熟語ルビの例2Example 3 of jukugo-ruby熟語ルビの例3
With jukugo-ruby, individual base characters and their associated ruby string are treated as a unit,
and line wrap opportunities are allowed between two base characters.
When such a line wrap occurs,
if a single base character that is part of the jukugo is placed alone at the end or at the start of a line,
it is laid out identically to mono-ruby;
conversely when several base characters that are part of the jukugo
are placed together at the end or start of a line,
they are laid out together as has been described in this section about jukugo-ruby
(see ).
When the ruby string is longer than the base character string and protrudes,
whether and how it hangs over characters preceding or following
the base character string
is handled in the same way as with mono-ruby.
Also, when the ruby string is longer than the base character string,
protrudes, and is located at the start or end of the line,
the resulting layout is also identical to that of mono-ruby.
