Developer Help: Development Links

This is a collection of links to information, programs, assets, tools, and other resources useful for creating Ukagaka/SSP-related content.

To avoid redundancy, we have not listed them here again, but when publishing your content and promoting it afterward, you can help it reach users by making use of the sites in the other link collection. That way, everyone wins.

Specifications and references

SHIORI

This section covers a few SHIORI implementations, based on our own judgment and preferences (with some consideration given to factors such as whether they were still being developed and how widely they were used as of 2014).
There are many others, especially SHIORIs based on general-purpose programming languages, so look around if you're interested.

Satori

Satori is currently the most widely used SHIORI.
Its dictionary notation uses full-width symbols and is designed to make writing talks easy. Its thoughtful design also takes care of complicated processing behind the scenes. These qualities have made it popular with people who have never programmed before, especially those who want to create ghosts centered on random talk.
There is also a wealth of documentation written by volunteers, as well as useful ghost-creation tools and template ghosts, making Satori a SHIORI with a well-supported development environment.

On the other hand, because processing happens automatically behind the scenes, it can be opaque, making it harder to understand the original functions and roles of SHIORI and SSP. This can make more advanced development a stumbling block for beginners.
In addition, Satori is not well suited to fast, complex processing, and it has various specific weaknesses—for example, the “function argument separator problem,” caused by its inability to distinguish syntax symbols from ordinary text. Overall, it has limitations when it comes to “difficult or complicated” tasks.

Satori is the first SHIORI we recommend to beginners with no programming experience. However, depending on what you want your ghost to do—for example, if you want to create a ghost with a mini-game—it is worth considering other SHIORI implementations such as YAYA or Kawari, even if they have a somewhat steeper learning curve at the start.

Aya/YAYA

Aya (あや) is a SHIORI with C-like syntax.
After development of Aya ended, YAYA (やや) continued its development unofficially while inheriting Aya's basic syntax and features.

It has basic control structures for branching and loops, and compared with Satori, it can be said to be a SHIORI that is intuitive for people with programming experience to use.
It also provides built-in functions for text and file operations, basic mathematical calculations, and string processing with regular expressions, making it suitable for ghosts that need to implement somewhat complex features.

However, its arrays are one-dimensional (although there are ways to emulate other kinds), and associative arrays are not implemented.
It also has no features such as classes, so you cannot write object-oriented code, and it is not as powerful or flexible as SHIORI implementations based on general-purpose languages.
In addition, despite its C-like syntax, it has various quirks of its own, so some parts may take time to get used to.

One characteristic is that Aya and YAYA themselves are designed simply as general-purpose language DLLs.
All support for communication protocols such as SHIORI, as well as the provision of basic ghost features, is left to the dictionary (included with the template ghost).
As a result, by replacing the system dictionary, Aya and YAYA can serve not only as SHIORI, but also as other Ukagaka subsystems centered around DLLs, such as SAORI and PLUGIN.

Kawari

Kawari (かわり) is a SHIORI characterized by dictionaries that can have a hierarchical structure and easy-to-write, multi-level entry calls, which make it possible to create Dokoitsu-style random talk easily and powerfully.
It also has ample features for writing and debugging programs, and can handle complex tasks reliably.
It can also be used as SAORI, so it may be able to make up for shortcomings in Satori and other systems.

However, because it is highly versatile, you can—and must—write processing from the very foundations of the system, so it is usually used through "middleware" that handles this for you.

It has also been ported to many environments, and ghosts generally run without problems even outside Windows.
It can be said to be a SHIORI that supports the Ukagaka community.

Akari

Akari is a SHIORI with a highly distinctive set of built-in functions.
Specifically, it comes with features such as FTP communications, sending and receiving email, serial communications, database operations using SQLite, and multithreaded processing.
Its dictionary syntax is even closer to C than YAYA, which aims for C-like statements.
It also supports associative arrays (dictionary types) and multidimensional arrays, making it capable of handling somewhat complex processing and implementing advanced features.

You can also write talks using Satori-like syntax by using the system dictionary implemented in the sample ghost.
However, its support is not as extensive as that of the original Satori or the various middleware packages for YAYA and Kawari. If you want to extend it yourself, you will need to tackle its C-like syntax directly, which may be somewhat difficult if you have no prior programming experience.
Because of this specialized design, only a limited number of ghosts may be able to realize its full potential, but it is a SHIORI with a unique character unlike any other.

You can also use it as a SAORI if you prepare a dictionary for constructing headers.
It also has a mechanism for being called as an extension DLL by the general-purpose-language SHIORI “tkytk,” described below, allowing you to use Akari’s unique features from tkytk.

MiyoJS

Miyo (美代, pronounced Miyo) is a SHIORI built around the concept of “a SHIORI that is easy for programmers to use.” MiyoJS is its JavaScript implementation.
By adopting the existing JavaScript language and other general-purpose technologies, separating “processing” from “data,” and providing minimal SHIORI functionality that can be extended with plugins, it supports the creation of easy-to-maintain ghosts.
It is primarily dictionary- and data-oriented, so you can easily create ghosts with simple behavior using only dictionary entries.
You can also extend it clearly and easily when you want to do something more complex.
As it is a relatively new SHIORI, some (extension) features are missing, but it is expected to improve gradually.

tkytk

tkytk (Tsukiyotake) is a general-purpose-language SHIORI implemented in the Lua scripting language.
In general, you need to write not only the dictionary but also some of the SHIORI protocol handling in Lua (which also means you can design it freely).
You will also need to refer to the Lua documentation available online.
However, examples of the basic features needed for a ghost are available in the sample ghost published by the original developer and in “Steam Nishiki,” a ghost actually made with tkytk, so you can use them as a reference.

As with any general-purpose-language SHIORI, not just tkytk, it may be difficult for people with no prior experience to get started.
However, those with relevant experience should find many aspects of it easier to work with.
Alternatively, you could try it as an opportunity to learn a programming language (Lua, in the case of tkytk).

Misaka

Misaka was designed by the creator of the original Ukagaka (MATERIA).
It has a design philosophy similar to Satori’s: ghosts can quickly provide the features they generally need without requiring you to write the system yourself.
It does not do as much as Satori, but its well-balanced selection of features makes it a relatively easy-to-understand SHIORI.

Although development has ended, which is a drawback compared with Satori and similar SHIORI for anyone starting ghost development now, there are no major issues with its operation.

Sources for materials, programs, and tools

Other