ukarpanghooth
overview
the first writing system i'm going to talk about is ukarpanghooth (meaning 'angular cut', IPA: /ɤ.kaɾ.pan.ɡʱə.uːtʰ/). it was actually my first attempt to create a writing system. it's main purpose was just to be unreadable by others (steganography? security by obscurity?).
description
this is a simple alphabetic script based on latin alphabet. some letter shapes are also influenced by runic scripts. the first version (proto-ukarpangooth) was actually very similar to the latin alphabet, so later it was modified, as an attempt to make it more unique and more obscure. words are separated by a special symbol, so that sentences are written together as one piece.
there is one interesting aspect about it is the order and direction in which it is written. initially it was done the usual way (well... for some), right-to-left, top-to-bottom. then i came up with something creative, writing it in groups of four letters in a square (top-right, bottom-right, bottom-left, top-left). if the number of letters in a sentence isn't divisible by four, letters are stretched to fit into square shape. there also instances of it written snake-shaped, turning by 90 degrees after each word.
the name of the script suggests that one can cut it on something (wood, stone, etc.), as only straight line segments are used.
usage
as mentioned before, script's main purpose was to hide some information (i once used it to cheat on a test in a physics class :D). mainly i wrote english text. some time later i used it to write my unfinished conlang named aihnth (IPA: /a.ji.ən.tʰə/).
the script has some ornamental potential, as its glyphs are pretty simple and use only straight lines.
font
actually, at first, i didn't think that it would be possible to replicate this script's peculiar writing order in a computer font. however, after reading some specs, decompiling some fonts and experiments i've found a way to do it.
open-type features allow two things: substitution (GSUB) and position (GSUB) of glyphs. basically, we need to have three versions of each letter: full size, half size and quarter size. then we substitute runs of four letters with four quarter sized ones, three letters with two quarters and one half, and, finally, two letters with two halves. the only thing left is to use contextual postitioning to move each component where it needs to be.
@full = [a b c]; # full-size letters
@half = [a.half b.half c.half]; # half-size letters
@qrtr = [a.qrtr b.qrtr c.qrtr]; # quarter-size letters
# helper lookups
lookup full2qrtr {
sub @full by @qrtr;
} full2qrtr;
lookup full2half {
sub @full by @half;
};
# main substitution lookup
lookup charBlock {
sub @full' lookup full2qrtr @full' lookup full2qrtr @full' lookup full2qrtr @full' lookup full2qrtr;
sub @full' lookup full2qrtr @full' lookup full2qrtr @full lookup full2half;
sub @full' lookup full2half @full' lookup full2half;
} charBlock;