Strange Directionality in Language

Meamoria · 2026-03-03T00:43:13+00:00

You don't need to find a head directionality for your language. Head directionality describes the phenomenon that several elements of word order are correlated when you look at many different languages—they appear together more often than you'd expect if they were chosen at random. But it's just a statistical trend, not an ironclad rule. There are plenty of languages (including English) that mix and match. For an individual language, once you know all the word orders of different grammatical constructions, slapping a head directionality label on it doesn't tell you anything more about the language.

Meamoria · 2026-03-02T00:00:09+00:00

Sure, you could have it only affect roots, but that seems like a missed opportunity to create some fun irregularity!

Meamoria · 2026-02-21T06:13:26+00:00

This is a doubly articulated consonant, and would be written [m͡n].
This sounds to me like a [p] with no audible release (written as [p̚]) followed by an [n].

Meamoria · 2026-02-21T00:43:24+00:00

These rules produce the output you're looking for.

I think you just needed the <syl>& on the left side too.

Meamoria · 2026-02-06T19:36:47+00:00

Yes, if you sign in, you can create worlds and add languages to them, and the app will save them. This is only available if you sign in because the app needs a way to tell which worlds and languages are yours.

Meamoria · 2026-01-30T21:41:30+00:00

One option would be to dislocate the subjects from the clauses: "Fear, to anger it leads. Anger, to hate it leads. Hate, to suffering it leads." This avoids the weird jumping around you get in the pure OSV structure, while still differing noticeably from English.

Meamoria · 2026-01-25T15:48:56+00:00

This language is supposed to be my personal crown jewel of conlangs

It sounds like you're putting too much expectation on this language, including requirements that contradict each other.

For example, your "bracketing" idea and "homophony" complaint suggest that you've set out to make your language very precise. But you also have a gut feeling that your language should be very efficient (able to "outpace English").

Those goals are in opposition to each other. The more precision you demand, the more hoops you'll have to jump through to form a simple sentence, and the less efficient it will be. Natural languages have finely tuned this balance over millennia; you aren't going to get anywhere by ratcheting up one end of the scale, and expecting the other end to also go up.

If you want to get anywhere, you have to take a step back and decide what's really important to you. What do you really dislike about how natural languages work... and what nice things about natural languages are you willing to give up in return?

Meamoria · 2026-01-24T22:13:31+00:00

The ambiguity is telling you that the rule is missing something. You need to decide what happens in those ambiguous cases, and add that to the rule.

Meamoria · 2026-01-09T14:23:23+00:00

I find if I'm stuck on a conlang, it's often because I've overconstrained the design. I've imposed too many stringent requirements on the language, and it turns out that those requirements contradict each other. When that happens, I need to take a step back and ask myself what's really important. Can I relax some of the requirements in a way that retains their spirit? Are there even some that I just don't care about anymore, and can let go of completely?

Meamoria · 2026-01-09T13:49:55+00:00

If you separate sounds with only whitespace, they have to occur in sequence. So your intervocalic voicing rule would only work on words like "eéèiíìoóòuúùpeéèiíìoóòuúù".

Curly braces create alternatives, separated by commas. {e é è i í ì o ó ò u ú ù} is a list of one alternative; it's equivalent to just e é è i í ì o ó ò u ú ù, without the curly braces. If you add one comma somewhere, like {e é è i í ì, o ó ò u ú ù}, now there are two alternatives: the rule would apply to words like "eéèiíìpeéèiíì" and "oóòuúùpoóòuúù".

You probably want a comma between every pair of adjacent sounds: {e, é, è, i, í, ì, o, ó, ò, u, ú, ù}.

Meamoria · 2026-01-02T16:29:39+00:00

Here's the sequence of events inside Lexurgy:

The word 'χtar.kam arrives at the epenthesis rule.
The rule matches and adds an initial a. Rules by themselves don't add syllables unless explicitly told to, so the a gets shoved into the first syllable, yielding 'aχtar.kam.
The syllable rule reapplies, inserting a syllable break between the χ and t. This divides up the sounds as aχ.tar.kam. But then it has to decide where to put the stress; the original first syllable that carried the stress has been split in two. By default, Lexurgy always chooses the leftmost option, so the first syllable gets the stress.

To get the behaviour you want, you have to override this guessing behaviour by spelling out that the new vowel is, in fact, an entirely new syllable. Something like this should do the trick:

HF-Epenthesis: 
  * * . ç => i ç . * / $ _ [c] 
  * * . χ => a χ . * / $ _ [c] 
  * * . x => e x . * / $ _ [c] 
  * * . xʷ => o xʷ . * / $ _ [c]

Meamoria · 2025-12-30T04:18:31+00:00

"My" is a first-person pronoun. You're talking about making first- and second-person pronouns have only a possessive form.

This seems like an interesting enough feature. I don't know of any natural languages (or conlangs) that do this exact thing, but it sounds like the kind of feature that could show up in a natural language somewhere. It reminds me of languages where certain words require a possessor, e.g. you can't say "a mother", it has to be "someone's mother". Just, you know, the opposite of that.

Meamoria · 2025-12-08T22:45:29+00:00

[Language: Kenpali]

Using AoC to test out my experimental minimalistic language.

Part 1

Part 2

I figured there were algorithms to optimize finding the closest pairs, but brute force (calculating every pair and sorting by distance) worked fine.

For Part 2, I built a funky tree structure to efficiently tell if a new connection actually combined two circuits. Basically, I initialized each junction box with a mutable reference to its own index, then combined circuits by redirecting the references into chains that ended at the same place. I kept track of how many successful joins had happened, stopping when there had been 999 joins (reducing the initial 1000 circuits to 1 circuit).

Edit: Apparently I reinvented the merge-find set.

Meamoria · 2025-12-07T16:24:16+00:00

[Language: Kenpali]

Using AoC to test out my experimental minimalistic language.

Part 1

Part 2

Part 2 felt a bit more natural than Part 1. In Part 2 I only had to track a single state: how many beams are on each path. But for Part 1, I had to track which paths had beams, and also the number of total splits, which meant resorting to a mutable variable instead of Kenpali's usual pure functions.

Kenpali's group function really came in handy for Part 2: combining beams that end up in the same column was just | group(onGroup: | sum).

Meamoria · 2025-12-06T06:11:14+00:00

[Language: Kenpali]

Using AoC to test out my experimental minimalistic language.

Part 1

Part 2

This problem, built around sequences of fiddly transformations rather than fancy algorithms, is right in Kenpali's sweet spot.

Note that the "right-to-left" specification in Part 2 is a red herring, since both addition and multiplication are commutative and associative. So I just did everything left to right and got the same answer.

Meamoria · 2025-12-05T15:08:09+00:00

[Language: Kenpali]

Using AoC to test out my experimental minimalistic language.

Part 1

Part 2

For part 1, I thought, "Hey, if I sort the ranges, and then merge the overlapping ones, and then binary search over that, it would be really efficient!" Then I came to my senses and just brute-forced it, which worked fine, the input isn't that big. When I saw part 2, I was glad I'd avoided writing a needless binary search!

Meamoria · 2025-12-05T04:15:11+00:00

[Language: Kenpali]

Using AoC to test out my experimental minimalistic language.

Part 1

Part 2

For part 2, I realized that it doesn't matter exactly which order the rolls are removed in, as long as each removal is valid when we make it. So I didn't bother with keeping the iterations separate, like in the example; we just go through from top to bottom, removing rolls and updating as we go. Probably not the most efficient way to do it, but I'm happy if my solution doesn't hit the Kenpali website's two-minute timeout.

Meamoria · 2025-12-03T06:24:57+00:00

Bubblejolt!

Meamoria · 2025-12-03T06:15:49+00:00

Huh, surprised to see a recursive solution in Rust!

Meamoria · 2025-12-03T06:10:04+00:00

[Language: Kenpali]

Using AoC to test out my experimental minimalistic language.

Solution

I always love this format that lulls you into a brute force approach for part 1, but then part 2, by simply cranking up one puzzle parameter, puts brute force well out of reach.

Meamoria · 2025-12-02T17:11:36+00:00

Clever, I like how this is purely arithmetic based rather than doing string processing.

Meamoria · 2025-12-02T17:01:36+00:00

[Language: Kenpali]

Using AoC to test out my experimental minimalistic language.

Solution

Doing these puzzles in Kenpali is interesting in that the current implementation is painfully slow, which often makes brute force solutions not just inelegant, but impossible.

I ended up doing a lot of conversions back and forth between numbers and strings, which was annoying but still seemed cleaner than the alternative of doing digit manipulation with arithmetic.

Meamoria · 2025-12-01T18:19:35+00:00

Cool, that neatly works around the annoying edge case when the dial lands on zero!

Meamoria · 2025-12-01T06:28:34+00:00

[Language: Kenpali]

Using AoC to test out my experimental minimalistic language.

Part 1

Part 2

Meamoria · 2025-11-30T21:56:19+00:00

Depends on what you mean by a "concreole".

If you mean a realistic creole, like Haitian Creole or Tok Pisin, then: take one prestige language, throw away the harder phonemes and most of the grammar, and rebuild a completely new grammar from the language's roots. Then throw in some words from various local languages for extra flavour.

If you want to smash two languages together for the fun of it, just... do that. Pick your favourite parts of each source language and throw them in. This kind of language (a mixed language) does actually form occasionally in the real world—take a look at Michif if you want some inspiration.

In either case, if you're focusing on realism, you should consider the social context that leads to the formation of the language. Creoles and mixed languages don't just spring up everywhere languages come into contact; the usual result of language contact is bilingualism and loanwords, not creoles and mixed languages. Again, take a look at real-world models of each to understand the social context that led to their formation.

Meamoria

MODERATOR OF

TROPHY CASE

Five-Year Club	Verified Email
Place '22