An open source terminology management solution. The main goal of this app is to help translators to manage their glossaries in a structured but at the same time highly configurable way. Termbases are a highly valuable resource and require time to be built and validated, they are key for professionals to adapt to their customers' and domain requirements while ensuring consistency and high quality. One of the main concerns of my approach to terminology management is that one's data must always reside on one's own machine, so terminological entries must be stored in a local database and be never sent over the network.
Once upon a time, when my career as a software developer had not started yet, I happened to work in the field of professional translation. At that time, no free and open source solutions existed, the only tools that were available were expensive and hard to use. Here is an attempt to provide an alternate solution as free software. This is still mostly work in progress, so feel free to experiment, report bugs and suggest possible improvements. This project is developed in my free time, so please be patient.
MetaTerm is intended as a concept-oriented terminology management tool, allowing glossary makers to create terminological entries for concepts (rather than for terms), each of which can have multiple lemmata for multiple languages (when more terms for the same language coexist in the same entries they are to be considered alternatives or parasynonyms). Each entry, language or term within a language can be described by one or more properties, whose name, level and type can be defined for each termbase in the definition model, in order to guarantee a flexible structure depending on the domain or the user's requirements. The structure of the form for term insertion can be customized as well, as it is referred to as the input model (configurable for each termbase too). Entries can be filtered according to a fuzzy or exact match on their descriptive fields or lemmata. Fields that are marked for inclusion in search are fuzzily matched against the content of the search field in the main toolbar.
This is the main application screen where entries can be browsed and opened.
When entering input mode, new entries can be added. The number of fields displayed by default without having to add terms or properties is defined in the input model (step 3 of the creation wizard). The input model can be changed at a later stage in the Edit termbase dialog.
This is very similar to the input mode, but instead allows to edit existing entries adding/deleting properties or terms for individual languages.
This allows to configure filtering for the current list of entries displayed. By default the lemma of the source language is the only currently included field (with fuzzy match in the search field of the toolbar) but other fields can be included either in the global display (fuzzy or exact match) or the toolbar search (fuzzy).
This dialog shows some aggregate statistics about the current termbase, plus the completion rate of each language. A language is considered complete depending on the number of entries it appears on (synonyms or parasynonyms in a langauge are counted just once).
The settings dialog allows to change the application language (currenty supported: English, Italian and Spanish).
Browse existing termbases
Create a new termbase
Edit termbase
This project was also created as a playground to experiment with some frameworks and libraries I wanted to learn (and play a little with). It is a pure Kotlin project taking advantage of the Kotlin multiplatform technology, even though no native code was needed and it's all in the JVM flavour. The UI layer is written in Jetpack Compose, using the desktop porting of the library which is still experimental (but reliable though).
In order to have state mapping and retention (aka ViewModels) and navigation in a desktop/multiplatform environment, I chose the Decompose library which gives the ability to create a tree or arbitrary depth of components with each layer only knowing and managing its direct subchildren. Dependency injection, on the other hand, is obtained through the Koin framework.
The persistence layer was written with JetBrains Exposed ORM library, combined with the JDBC driver and an embedded H2 database, since it was crucial to me to keep data within the user's local machine.
Since this is an open field for experimentation, I am willing to accept change proposals/suggestions and even to rewrite entire layers of the application architecture just for fun.
During development I have already switched the following technologies:
- SQLite ➞ H2 for persistence
- Kodein ➞ Koin for DI
- Precompose ➞ Decompose for MVVM and navigation (progressively, with the refactoring of #36)
The name "MetaTerm" is a pun between the name of well known commercial solutions and the Greek verb μεταφράζω meaning "to translate". This is part of a larger set of translation tools that I am creating in my spare time. If you like the idea, please check out MetaLine which is used for text alignment to create translation memories in TMX.
If you are willing to compile the project yourself, this is a Gradle project so you can run Gradle tasks by using the gradlew (Gradle wrapper) executable present in the root directory of the project. The Gradle version used is 7.5.1 so at least Java 18 is required (reference here) so make sure you have a suitable version of the JDK, especially if you are using pre-bundled OpenJDK versions on GNU/Linux distros.
And if you are reading this: thanks 🙏