And another little advertisement for the conworkshop, an amazing little community of conlangers including social tools like forums for games and discussions and (brand-new) awards/achievements — but also many useful tools such as a searchable dictionary, a sound change applier (PhoMo), a syntax tree drawer, vocabulary sets for expanding your language (LexiBuild), grammar tables that can auto-decline words from your dictionary, easy-to-make articles to document your language’s grammar, and more.
Also: a Lexember clan has just started up on the forums that will be posting themes if you need prompts for your Lexember entries, as well as hosting small contests throughout December just for the fun of it.
Hey, conlang fans! PolyGlot 0.8 is here! This release has a number of new toys and features for you to play with! This release doesn’t have as many upgrades on the surface as some others, but there’s a lot going on under the hood. Some of these changes are going to help a lot moving forward with things like logographic support, a much more powerful translation window, and any number of other things!
Download Here!
- Added the thesaurus window, the biggest new feature in this release - Archived saving (leading eventually with additional media support for languages with logographic features) - Embedding fonts directly in the PGT files saved (allowing anyone with PolyGlot to view your conlang easily) - Added the ability to scroll in the declensions/conjugation window for languages that have a lot of combinations - Added brand new loading splash screen and revamped About window - Bugs. Always smashing bugs.
Next up is autogeneration of conjugations/declensions! Bone up on your regular expressions, because the next release will use them heavily!
For anyone unfamiliar, PolyGlot is a ConLanging toolset that helps to build conlang lexicons, has a translation tool to help you translate text from your native language to your conlang, and a number of statistical analysis tools to help with balancing your language.
This is mostly an iterative release, but fixes a LOT of bugs that were present in the past version. New features include:
- totally rewritten declensions system (still loads files without problem)
- export to excel feature
- auto checks for updates
As always, I love to hear feedback, whether positive or negative. Please let me know whether the program is helpful, and what additional features would make your conlanging easier!
DL Link: https://dl.dropboxusercontent.com/u/2750499/PolyGlot/PolyGlot%200.7.5.zip
Link to GitHub site: https://github.com/DraqueT/PolyGlot
Special thanks to http://anxiousartisan.tumblr.com/, who helped me track down a nasty bug!
The Haedus Toolbox SCA was designed to address one specific and pernicous problem with other sound-change applier programs in common use withing the conlang community, namely that single sounds often need to be represented by two or mor characters, whether that is ‘ts’, ‘tʰ’, or ‘qʷʰ’. This relieves the user from having to artificially re-order rules because ‘p > b’ happens to also affect ‘pʰ’ even when the intent of the user is for these to be distinct and segments. The SCA can infer the what sequences should be treated as unitary by attaching diacritics and modifier letters to a preceding base character. The user can also manually specify sequences that should be treated as atomic.
Running The SCA
To use the SCA, the user must provide a lexicon and rules file. In stand-alone operation, it can be run using the command
java -jar sca.jar LEXICON RULES OUTPUT
with the user providing paths for the worlist, rules, and output file. This can, of course, be placed into a batch or shell script for your convenience. However, running SCA through a terminal is recommended, so that any errors can be printed to the terminal. Later versions will permit the user to provide only the script, in which the input and output paths are specified
Scripts
Operation of the SCA is controlled through a script file while primarily contains rule definitions, but which also allows the user to define variables, reserve character sequences, and control segmentaton and normalization. Lists of things, like sources and targets in rules, the contents of sets inside conditions, variable definitions, and commands to reserve character sequences are all delimited by whitespace (the space character, or tab) and is quantity-insensitive, so you can use extra spaces, or tabs to make columns align, as you will see throughout the examples.
While whitespace is used to separate items in lists, padding around operators and delimiters is optional. As elsewhere the quantity is not important.
The following characters have special meanings in the SCA script language and cannot be used elsewhere: >, /, _, #, $, %, *, ?, +, !, (, ), {, }, ., =
Script files may contain comments, starting with %, either at the beginning of a line, or in-line.
Command
Apart from rules and variables, there are additional commands used to control segmenation and normalziation and reserve sequences to be treated as atomic. This is controlled by the following command, plus one of the listed flags
NORMALIZATION:
NFD Canonical decomposition (default)
NFC Canonical decomposition, followed by canonical composition
NFKD Compatibility decomposition
NFKC Compatibility decomposition followed by compatibility composition
NONE No normalization; input is not modified
SEGMENTATION:
TRUE By default, automatic segmentation is used
FALSE Treats each input character as atomic, except where characters are reserved by the use
Variables
The SCA allows for the definition of variables (and re-definition) on-the-fly, anywhere in the script. Variables definitions consist of a label, the assignment operator = and a space-separated list of values. For example:
TH = pʰ tʰ kʰ T = p t k D = b d g W = w y ɰ N = m n C = TH T D W N r s
The values may contain other variable labels. There are no restrictions on variable naming - it is up to the user to avoid conflicts. However, when SCA parses a rule or variable definition, it searches for variables by finding the longest matching lable. If you have T, H, and TH defined as variables, a rule containing TH will always be understood to represent the variable TH, and not T followed by H.
If you wish to define longer variable names, you can use a non-reseved prefix like & or @, or wrap the name in square brackets.
The Rule Format
The syntax for rules is desinged to be similar to that used to describe sound changes in linguistics generally, and to support pattern matching using regular expressions.
This SCA uses > as the transformation operator, and separates the transformation and condition using /. The condition is not required and rules lacking a condition do not require the the / symbol. When the / symbol is present, the precondition-postcondition separator _ must appear exactly once.
Some basic rules are:
pʰ tʰ kʰ > f θ x p t k > b d g / N_ p t k > pʰ tʰ kʰ / _V [Aspirata] > [Anaspirata]
The first part of the rule (before /) is the transform which may contain literals and variables, as well as sequences of both.
Note that if mutliple sounds converge (or are deleted), such as a merger of e and o with a, then the following are equivalent:
e o > a a e o > a
Deletion
Segments can be deleted by transforming them to 0 (the character zero). This can be written as follows:
x h > 0
Just as with other transformations, if all segments are to be deleted, then the rule can be written as shown above. However, one can also write a zero along with other sounds as follows:
w s h > 0 h 0 / #_
Indices and Backreferences
The SCA permits the transform of rules to contain backreferences which can be very useful in writing rules for metathesis or total assimilation. For example
C = p t k N = n m CN > $2$1
allows us to easily represent metathesis, swapping N and C wherever N is found following C.
When SCA parses a rule, it keeps track of each variable in the source part of the transform and knows in the above example, that C is at index 1 and N is at index 2. The target part of the transform lets us refer back to this using the $ symbol and the index of the variable we wish to refer to.
We can actually go slightly further, however and use the indices on a different variable. In a slighly variation on the previous example, we can write
C = p t k G = b d g N = n m CN > $2$G1
which does the same as the above, but also replaces any element of C with the corresponding element of G. So, if a word is atna, the rule will change it to anda.
This can also be used for some kinds of assimilation and dissimilation, such as simplifying clusters of plosives by changing the second to be the same as the first:
C = p t k CC > $1$1
This will change a word like akpa to akka; in this case, it is actually equivalent to write CC > C$1
Condition Format
Most of the power of the Toolbox condition format lies in it’s ability to use ad-hoc sets, and regular expressions. The underscore character _ separates the precondition from the postcondition, so that the rule will be applied only when both sides of the condition match.
The / part of the rule can be left out if there is no condition: a > b is equivalent to a > b / _ and both are valid. A rule can have / and _ or neither, but a > b _ and a > b / are both invalid.
Regular Expression metacharacters
+ matches the previous expression one or more times
* matches the previous expression zero or more times
? matches the previous expression zero or one times
{} matches any of the list of expressions inside it
() used to group expressions
!matches anything that is NOT the following expression (NB: not implemented)
.matches any character (NB: not implemented)
Sets, delimited by curly braces {}, contain a list of space-separated subexpressions. These can be single characters, variables, or other regular expressions - anything allowed elsewhere in the condition. It’s not clear that this capability is of any real use, but it remains avaible if you happen to find a use for it. Some examples
{ a b c } { a b+ } { C a } { C(a)? x } { C{a b} x }
Take some care when writing rules that use ? or *. Because these allow a condition to match zero times, any condition consisting solely of _X? or X*_ will match no matter what. This is because, logically, _X? is equivalent to _X OR _. Further, X?_Y? does not just allow the rule to match both X_ or _Y, but also _, and any rule matching _ will be applied everywhere
Joint Conditions
Another piece of advanced functionality supported by this SCA is the capacity to combine mulitple conditions in one rule using OR. For example, if the same transformation occurs under multiple conditions, they can be joined together:
o e > a / X_ OR _Y % change e and o to a when preceded by X or followed by Y
You can now sign up for the fourth Tumblr Conlang Relay!
It will start on the 1st of November, with possible delays over holiday periods depending on everybody’s availability. This signup will be used to help plan the relay in terms of timing and texts.
Hello everybody, I’d like to grab your attention for a second to get planning into gear on a fourth tumblr conlang relay!
If you are potentially interested in participating this year, please send an ask or email, or comment on this post, with the following information:
- What format are you most interested in? Looking back at the texts used in the last 3 TCRs, are you more keen to try very short, medium length, or long texts to translate? Anything you want to avoid?
- When do you think you might be free, or have time over a few days, in the general range of September to January? This will obviously be very tentative but will help show when common holiday and exam periods are, for example.
- If you would want to join but have concerns about the stress or pressure, or would otherwise be unsure about participating due to e.g. health problems, I am very open to discussing this privately. The relay format imposes a certain level of time pressure and social contact but I hope to make this as accessible an event as possible with your feedback. Feedback on past TCRs is also more than welcome.
I will be reblogging this for a while. At present I am not opening a call for sign ups - that will come after the initial planning THIS post is kicking off! Thank you :)
Hey all you ConLangers out there! I haven’t forgotten all of you! In fact, I’ve been working on a goodie that I think you’ll really like! Ever since I started my ConLang, I’ve been frustrated that there aren’t any utilities to help construct them, so I’ve been tinkering here and there with a construction/publication toolkit. In the next couple of weeks I’m going to start a limited release of PolyGlot, a program to do just that!
It’s in beta now, and a little bit buggy, but that’s the whole point of a limited release. If you would like to help me test it out, or play with it before Is start making larger releases, please let me know!
Deconstructed Construction is going to be coming back, albeit on an inconsistent schedule. In the next few weeks I’ll be continuing the Historical Conlanging series. Since the last post, both Jordan and Tommy seem to have left the blog. Thus, I am looking for someone to write things for this blog with me!
Please send a message to this blog or my main blog if you’d be interested in helping out. A link to your conlanging tag would be appreciated so I can see your language and get a feel for the tone of your work, but it’s not required. You can choose to continue one of the previous series of posts or just start something new! Over the next few days I’m going to be working on cleaning up this blog a bit and getting it ready for some new content.
Followers, thanks for sticking around even though there’s been no new content in quite a while! I’m looking forward to getting back into the swing of things.
How sounds are used in languages across the world, what sounds are the most common, and some phonology terms to help understand the lot of it - for those interested in linguistics and/or conlanging.
My conlanging friend made this website for conlangers, filled with great tools for building your lexicon and sharing your conlang with others. It’s very new (released just in the last week), but there are already dozens of members. Definitely check it out!
i’ve been checking out this site - it looks pretty cool so far! it unfortunately relies on being able to translate your words 1:1 for an English word at the moment, but it does look like it has better handling of morphemes/ etc than other similar projects I’ve seen.
As over-late as it is, I hope you will enjoy finally seeing the results of this year’s Tumblr Conlang Relay! This time around, the relay was run with 6 small torches instead of 1 longer one. Please let me know if any usernames of conlangs have typos or need changing. Thank you very much to the many participants this year~
Relay Results
Torch 1: Sibling Betrayal
Torch 2: Drinker
Torch 3: Birdwatching
Torch 4: Honour
Torch 5: Song of the Rain
Torch 6: Impatience
Participants & Conlangs
Aru (Athal)
Cedh (Buruya Nzaysa; Doayâu; Farwo n-Abebbu; Ndok Aisô; Proto-Mbingmik; Tmaśareʔ)
Charlie (Fasime)
Geekhyena (Shibai)
Irrhythmic (Churra)
Josh (Ěrídàn)
Kelemta (Akut-ipalna)
Nick (Anikele)
Otto Maria (Jànne) [no links]
Sofia (Malbja-elj)
W. (Tsrul)
This is a Kickstarter campaign to create a publication for everyone who’s interested in language to read interesting, accessible, long-form stories about language and linguistics. It definitely seems like a project that will appeal to protolinguists: from Michael Erard, the creator:
I remember, as a kid, being interested in language but finding only technical books. Schwa Fire is for that kid — and for everyone who wants a meaty but accessible view of why language matters.
It actually reminds me a bit of the old Verbatim magazine, which was fantastic and it’s a pity that it isn’t still around.
More details on Schwa Fire in the video below:
It’s only been two days so far, and already the project is over 20% funded. I just pledged as well, and I’d encourage anyone who wants to make this happen to also share the link or contribute. I want to exist so I can read it!
This is the successor to my old ASCA program that nobody asked for. It is, however, much better tested - I’ve been working professionally as a computational linguist for the last year and have learned a lot about software design.
I don’t have a clever name for it, but it’s an SCA and it’s part of a set of tools I’m developing for future dissertation research. Let’s just call it HTS for now. I’m interested in people’s feedback on usability, documentation, and any problems - as stated above, I needed to develop this as part of another project, but I wanted to make it available for public use.
- contains jar, an example batch file, and example PIE to Kuma-Koban lexicon and rules. If you have an ASCA rules file, it will be compatible with this, though because HTS handles combining characters differently, the intent might be slightly off.
I’ll try to be as concise as possibe here, but there is one really critical thing to understand before using this tool: HTS does not manipulate strings.
It is designed to operate on phonetic segments, and handles combining diacritics and modifier letters intelligently. A rule targeting p will not affect pʰ, ever, under any circumstances. Symbols like <ʰ>, and others like <ˣ>, <ʶ>, combining diacritics, alphanumeric sub- and superscripts, are understood to not be characters on their own, but modifiers on another (preceding) character.
Important Caveat: all diacritics are will currently combine with the segments they follow, so pre-aspiration as denoted ʰp is not possibly at the moment, though it will be once support for phonetic features is added (though it will need to be pre-defined). Also, rules and lexicon entries are normalized using canonical composition in unicode, so you don’t have to worry about manually converting between forms with combining accents and their precomposed equivalents. <size=150>Running HTS This is a stand-alone Java application - you will need the JRE installed at the moment, but there are no external dependenes. Run it with a script or from the command line. HTS needs three arguments: lexicon, rules, and output, in that order.
<size=150>Rules The rule format is supposed to be pretty intuitive. You can add comments using % anywhere in a line - anything after % will be ignored. The following characters are reserved and should only be used in commands:
# % _ / > ( ) { } * +? =
HTS uses spaces to delimit lists, but is insensitive to the number of spaces (or tabs). This lets you format your rules into nice blocks if you like. Variables are simple - unlike in ASCA, there are not restrictions on naming. The following block demonstrates some of what can be done:
Q = kʷʰ kʷ gʷ K = kʰ k g KY = cʰ c ɟ P = pʰ p b T = tʰ t d [PLOSIVE] = P T KY K Q [OBSTRUENT] = [PLOSIVE] s
As you can see, a variable is assigned with a label, the = operator, and a space-delimited list of segments or variables. Also take node ofK andKY. When HTS checks for variable names, it will always match the longest one first. So basically, if you also have a variable calledY and you think it’s going to ever show up afterK and don’t want it confused withKY, give it a different name. You can also modify variables by just redefining them, or you can add a symbol to a variables like this:
C = C s
This will have the effect of adding s toC. Transformation rules are a bit more complicated. Unlike programs that used the // notation, HST uses > for transformation, and / to denote the condition:
h₁ h₂ h₃ h₄ > ʔ x ɣ ʕ bʰ dʰ ǵʰ gʰ gʷʰ > pʰ tʰ ḱʰ kʰ kʷʰ % GRASSMANN'S LAW CH = pʰ tʰ cʰ kʰ J = b d ɟ g CH > J / _R?VV?C*CH y w > i u / _{C X #}
As in other rule languages, # indicates a word-boundary. In conditions, you can used regular expressions. The semantics of ?, *, and + are traditional, but HTS uses sets with {} rather than pipes or square brackets. You can delete characters using 0:
xa xə > 0 / [LongV>]_ X > 0 / _{C #} X > 0 / C_ ʔ > 0 / #_
As you can see in the first line, any number of elements on the left can be deleted by a single 0 on the right. As in the following examples, you can combine segments and variables:
r̩X l̩X > ə̄r ə̄l / _{C #} r̩X l̩X > ər əl / _V
You can also use two variables in a transformation, but this is discouraged in most cases. In principal, you can do the following, but there are usually better ways to write an equivalent rule.
NX > Nə / #_C
In conditions, you can use sets. Like in ASCA, they are denoted by curly braces {}. As in other places, the items listed inside are delimited by spaces. A condtion _{C X #} will match if the symbol is followed byC,X, or a word-boundary.
Regular Expressions
The first thing to remember is that in HTS, parentheses do not mean “optional”. I’ll probably make this configurable in a later version, but for now parentheses are used when you need to apply ?, *, or + to a series of segments or variables, or to separate potentially-conflicting variable names like these: (K)(Y), K(Y), (K)Y. If you are not familiar with regular expressions, the semantics here should be fairly straightforward. ? indicates that the preceding expression (group, segment, or variable) can be matched zero or one times - this is equivalent to the use of parenthese to make something optional. * will match the preceding expression zero or more times - using variables from our examples, C* indicates any number of consonants. + is similar, matching an expression one or more times. Not that you’d be likely to need to, but I built HTS to parse expressions into state machines, so you have a lot of power in writing conditions (provided you don’t need back-references). For example, you can write conditions like the following:
_{ab* (cd?)+ ((ae)*f)+}tr _{ab {cd xy} ef}tr
though gods protect you if you need the first, and the second has redundant nesting. <size=200>Future Development I’ve been developing HTS with hooks in the code for future additions, like being able to load additional rules or variable definitions from inside another rule file, or reading and writing lexicons in the same way. Also, I’d like to add support for compound conditions, like
X > 0 / _{C #} OR C_
and possibly also exceptions for blocking conditions. The next step is integrating features into the rule system. The segment-based approach I’ve taken already support this and is used by sequence alignment code that I might release soon as well - this uses dynamic programming and a hybrid articulatory-perceptual feature system to align sequences as a first stem in researching semi-automated reconstruction.
Hey there, folks. You might remember my mentioning, at the start of this year, that I am curating a project whereby various members of the conlanging community contribute literature in their language/s, and these are collected in a compendium showcasing conlang creative writing.
The first...
Alright conlangers I’m gonna introduce you to a program completely unrelated to conlanging but that I’ve used in conjunction with it for years. I’ll be covering a lot of information here, and a lot of it is meant to be up to you— aka, I’ll be linking a lot of tutorials and download links. I’ve been using this program for 3 years, so I know what I’m doing, but I understand that it can be very confusing! So, lets dive into:
I’m compiling some syntax-testing sentences for translating as a reference for conlanging. (There’s a lot of word lists and some sentences lists but few of them focus on syntactic and morphosyntactic structures.
At the moment this is largely an exercise in showcasing English’s different structures; if anyone has any suggestions for other sentences or types of sentences to be added (focusing on syntax and morphosyntax), feel free to add them on.
simple intransitives, aspect, mood
There is a man.
The man runs.
He runs.
I run.
Three men run.
He ran.
He is running.
He was running.
He should run.
He should have been running.
Run!
Don’t run!
He doesn’t run.
He didn’t run.
He won’t run.
He ran quickly.
He ran away.
He ran after her.
He ran on Tuesday.
simple transitives
He hits her.
She hits him.
You hit yourself.
The two of you hit each other.
He hits her with a stick.
He throws it to her.
She throws it to him.
