CLanC

[Zju]

CLanC (/klaŋk/, Conlang Constructor) is a tool I've been working on for a while. Its aim is to aid in conlanging.

So what does it do, exactly?

- Handles thousands of words with ease (thanks, mleibman & 6pac):


- Search and sort by anything you like:


- Import and export to many custom formats:




...but wait, there's more:

- Fully integrated morphology engine:


- Preview inflections on words:


- Be careful not to proclaim ANADEW! every other minute:



- Preview inflection in lexicon, too:


...but wait, there's more:

- Fully integrated diachronics:


- Inspect effects of specific sound changes:


- Stack as many descendants as you want:


You can explore the features by taking a look at the provided example conlang - Téstlæŋ language.

This thing is still very much in development - I've contemplated at what stage to release it, and it's gotten to the point where it could be useful to others. So keep in mind it's more of an alpha release.

Note the following:
- I'm *NOT* taking feature requests.
- Some issues and questions have been answered in the readme - take a look there first.
- The program may be unstable or buggy, lose or corrupt your data, yadda yadda. All the usual disclaimers.
- Development will be put on hold soon - it will likely resume next year and even then it will be mainly work under the hood. Don't expect many new features.
- Contributions are welcome.

Download here

[bradrn]

Wow, this looks amazing! I’m not going to try it just right now, but I must play around with it at some point. (Hmm, does it support importing from MDF?)

I know you’re not accepting feature requests, but here’s a thought: I’m currently making a new SCA (screenshot of current progress here) — might it be possible to integrate it with CLanC? The general design of my SCA actually looks fairly similar to yours, especially in the multigraph support. (I know it’s at least possible to compile Haskell to JavaScript, so if I ever get GHCJS working, this might actually be feasible.)

Also, it might be a good idea to directly link to the repo: https://gitlab.com/sfpublic/clanc.

[Zju]

Wow, this looks amazing! I’m not going to try it just right now, but I must play around with it at some point. (Hmm, does it support importing from MDF?)

I know you’re not accepting feature requests, but here’s a thought: I’m currently making a new SCA (screenshot of current progress here) — might it be possible to integrate it with CLanC? The general design of my SCA actually looks fairly similar to yours, especially in the multigraph support. (I know it’s at least possible to compile Haskell to JavaScript, so if I ever get GHCJS working, this might actually be feasible.)

Also, it might be a good idea to directly link to the repo: https://gitlab.com/sfpublic/clanc.

There are plans to provide an API for integration of third-party SCAs. But even now it should be relatively easy to integrate one, if you know what you're doing.
The two entry points for the built-in SCA are parseAllLines and executeCommandsOnASingleWord in src/core/parser.js / core/parser.ts. If your SCA doesn't do any parsing, you can hardcode the output of the former as {success: true, error:"", commands: lineStr}. Just keep in mind sometimes the execution function is called without the parsing function. And it will be trickier if you'd like to work with TS.

I don't know what MDF is, but if it's some kind of plaintext, it should be workable. You might need to rearrange the columns as I haven't gotten around to doing that.

[alice]

I don't know what MDF is, but if it's some kind of plaintext, it should be workable. You might need to rearrange the columns as I haven't gotten around to doing that.

Medium-density fibreboard. Not the easiest of formats to import from, but one of the most durable.

Anyway, this all looks very nice!

[quinterbeck]

I don't know what MDF is, but if it's some kind of plaintext, it should be workable. You might need to rearrange the columns as I haven't gotten around to doing that.

Medium-density fibreboard. Not the easiest of formats to import from, but one of the most durable.

Remember to wear a filtration mask when handling this format.

I too like the look of this!

[bradrn]

Wow, this looks amazing! I’m not going to try it just right now, but I must play around with it at some point. (Hmm, does it support importing from MDF?)

I know you’re not accepting feature requests, but here’s a thought: I’m currently making a new SCA (screenshot of current progress here) — might it be possible to integrate it with CLanC? The general design of my SCA actually looks fairly similar to yours, especially in the multigraph support. (I know it’s at least possible to compile Haskell to JavaScript, so if I ever get GHCJS working, this might actually be feasible.)

Also, it might be a good idea to directly link to the repo: https://gitlab.com/sfpublic/clanc.

There are plans to provide an API for integration of third-party SCAs. But even now it should be relatively easy to integrate one, if you know what you're doing.
The two entry points for the built-in SCA are parseAllLines and executeCommandsOnASingleWord in src/core/parser.js / core/parser.ts. If your SCA doesn't do any parsing, you can hardcode the output of the former as {success: true, error:"", commands: lineStr}. Just keep in mind sometimes the execution function is called without the parsing function. And it will be trickier if you'd like to work with TS.

Ah, OK. Perhaps I’ll try this if, as I said, I can get GHCJS working.

I don't know what MDF is, but if it's some kind of plaintext, it should be workable. You might need to rearrange the columns as I haven't gotten around to doing that.

SIL Multi-Dictionary Formatter. It is indeed plaintext, and seems rather easy to parse too. The only problem might be its flexibility — the format is organised around a hierarchy allowing each word multiple senses and parts of speech, and I’m not too sure how well that will fit into the way CLanC organises its dictionary.

[Zju]

SIL Multi-Dictionary Formatter. It is indeed plaintext, and seems rather easy to parse too. The only problem might be its flexibility — the format is organised around a hierarchy allowing each word multiple senses and parts of speech, and I’m not too sure how well that will fit into the way CLanC organises its dictionary.

The way it sounds, you'd have to write a custom script to assign the definition to each of the multiple senses. In order to import something, it has to be in somewhat of a table format, with word, part of speech and meaning in this order.
There are plans to handle multiple meanings per word, with probably optional overwriting of PoS or other irregularities, but that's far off in the future. I'm not even sure how it'll interact with import and export functionality.

[Zju]

I know you’re not accepting feature requests, but here’s a thought: I’m currently making a new SCA (screenshot of current progress here) — might it be possible to integrate it with CLanC? The general design of my SCA actually looks fairly similar to yours, especially in the multigraph support. (I know it’s at least possible to compile Haskell to JavaScript, so if I ever get GHCJS working, this might actually be feasible.)

It might be possible to integrate it without compiling it to JavaScript - for which read on.

Discussion of morphology appliers elsewhere in the forum ignited the development spark even more in me, so let me daydream a bit.

I have somewhat grand plans for this piece of software. My personal wishlist for it already spans multiple years' worth of development time, and realistically will probably never all be implemented. So when work resumes sometime next year, I will look forward to address some more fundamental development issues first:

1. The thing has been a mere browser tab so far. This has been bugging me, to put it nicely. But lo and behold, it doesn't have to be this way. Apparently, desktop javascript programs have existed for quite a while. I cannot express just how glad I am to delegate multi-OS support to something else, and for all my clumsiness in HTML and CSS, it's still the easiest way for me to define user interface. So this is going to be the first major step.

2. But it gets even better (if we have good things, why not just have better things?) - apparently, Electron apps can use C++ libraries. Meaning currently sluggish operations in CLanC can become blazingly fast. Like applying dozens of sound changes on thousands of words in an eyeblink (somewhat of a promise, but let's see). Of course I'm going to rewrite all SCA and database code in C++ and delegate TypeScript to interface only. Heck, there are already C++ database libraries. Apparently, Electron has been made to use Haskell libraries, too.

3. Let's use some buzzwords. CLanC is going to be widget-based. Currently the interface is rather wooden, but the plan is to make each piece of functionality a widget. A widget is planned to be a separate subwindow - rescalable, movable, able to be opened and closed on a user's whim. A single piece of functionality is e.g. a lexicon table, etymology information, an inflection table, a sound changes list, conlang info etc. The future interface might or might not be inspired by Blender's interface. Also, some or all widgets might be made to use 3rd party library plugins, so that you could customise almost any aspect of the program.

4. And then, the current morphology applier could use some reworking and expanding, too. There are probably better solutions out there, or there will already be, by the time development resumes. Anyway, the grander plan is to expand the SCA into a generic Change Applier, which would be an SCA plus a user-friendly wrapper around SQL - meaning you could change almost any diachronic aspect of a conlang based on almost any other aspect of it, or of its protolang.
E.g. if you deduce that a particular sound change would introduce a new nominal declension pattern, you could write

Code: Select all

noun III > noun IV / N#

and all decl. III nouns ending in a nasal would become a new nominal declension called 'noun IV'. But the syntax for all of this will have to be worked out.

All in all, I'm pretty excited about this project. I've already used its prerelease version for last year's relay, and mostly its release version this year's relay. It has decidedly sped up and made easier the conlanging process. One can see the result of a new or altered protolang sound change on a descendant's inflection in just a few clicks, and I have the hunch that it could be made almost realtime without any clicks necessary. It just has to be implemented...

[bradrn]

Ah yes, Electron. I hate it, but only because I’m terrible at web stuff; you’d probably have more luck. (I personally prefer Qt.) And yes, it is indeed possible to use Haskell with Electron, most easily with threepenny-gui. (Actually, I was involved in writing the official tutorial… which reminds me, I really need to rewrite it one of these days to get it more up-to-date.) The basic idea is that you create a local webserver and communicate with Electron from that. Unfortunately, this can be a bit clunky and unreliable. However, as luck would have it, my SCA already has some C bindings, so it would work well if those could be used with Node as you say.