OmegaT projects can have translation memory files - i.e. files with the extension tmx - in five different places:
The omegat folder contains the
                                       project_save.tmx and possibly a number of
                                       backup TMX files. The project_save.tmx file
                                       contains all the segments that have been recorded in memory since
                                       you started the project. This file always exists in the project.
                                       Its contents will always be sorted alphabetically by the source
                                       segment.
                        
The main project folder contains 3 tmx files,
                                       project_name-omegat.tmx,
                                       project_name-level1.tmx and
                                       project_name-level2.tmx (project_name being
                                       the name of your project).
                        
The level1 file contains only textual information.
The level2 file encapsulates OmegaT specific tags in correct tmx tags so that the file can be used with its formatting information in a translation tool that supports tmx level 2 memories, or OmegaT itself.
The OmegaT file includes OmegaT specific formatting tags so that the file can be used in other OmegaT projects
These files are copies of the file
                                       project_save.tmx, i.e. of the project's main
                                       translation memory, excluding the so-called orphan segments. They
                                       carry appropriately changed names, so that its contents still
                                       remain identifiable, when used elsewhere, for instance in the
                                       tm subfolder of some other project (see
                                       below).
                        
tm folderThe /tm/ folder can contain any number of ancillary translation memories - i.e. tmx files. Such files can be created in any of the three varieties indicated above. Note that other CAT tools can export (and import as well) tmx files, usually in all three forms. The best thing of course is to use OmegaT-specific TMX files (see above), so that the in-line formatting within the segment is retained.
The contents of translation memories in the tm subfolder serve to generate suggestions for the text(s) to be translated. Any text, already translated and stored in those files, will appear among the fuzzy matches, if it is sufficiently similar to the text currently being translated.
If the source segment in one of the ancillary TMs is identical to the text being translated, OmegaT acts as defined in the → dialog window. For instance (if the default is accepted), the translation from the ancillary TM is accepted and prefixed with [fuzzy], so that the translator can review the translations at a later stage and check whether the segments tagged this way, have been translated correctly (see the Editing behavior chapter)
It may happen, that translation memories, available in the
                                       tm subfolder, contain segments with identical
                                       source text, but differing targets. TMX files are read sorted by
                                       their names and segments within a given TMX file line by line. The
                                       last segment with the identical source text will thus prevail
                                       (Note: of course it makes more sense to avoid this to happen in
                                       the first place).
                        
Note that the TMX files in the tm folder can be compressed with gzip.
If it is clear from the very start, that translations in a given TM (or TMs) are all correct, one can put them into the tm/auto folder and avoid confirming a lot of [fuzzy] cases.
Put the TMX in /tm/auto.
Open the project. The changes are displayed.
Make a slight change anywhere in the project. This
                                                      modifies project_save.tmx (by adding
                                                      proper Translation Units from "auto" TMX)
                                 
Note: if TMX is removed from /tm/auto before step 3, no extra Translation Unit is added.
If you have no doubt that a TMX is more accurate than the
                                       project_save.tmx of OmegaT, put this TMX in
                                       /tm/enforce to overwrite existing default translations
                                       unconditionally.
                        
Put the TMX in /tm/enforce.
Open the project. The changes are displayed.
Make a slight change anywhere in the project. This
                                                      modifies project_save.tmx.
                                 
Make decision about immunity of the enforced segments:
If they don't need to stay immune from further changes, then remove the TMX from /tm/enforce.
If they need to stay immune from further changes, then keep the TMX in /tm/enforce.
Note: if TMX is removed from /tm/enforce before step 3, enforcements aren't kept at all.
In the editor pane, when a match is inserted from a TMX contained in a folder named mt, the background of the active segment is changed to red. The background is restored to normal when the segment is left.
Sometimes, it is useful to distinguish between high-quality translation memories and those that are, because of the subject matter, client, revision status, etc., less reliable. For translation memories in folders with a name "penalty-xxx" (with xxx between 0 and 100), matches will be degraded according to the name of the folder: a 100% match in any of TMs, residing in a folder called Penalty-30 for instance, will be lowered to a 70% match. The penalty applies to all three match percentages: matches 75, 80, 90 will in this case be lowered to 45, 50, 60.
Optionally, you can let OmegaT have an additional tmx file (OmegaT-style) anywhere you specify, containing all translatable segments of the project. See pseudo-translated memory below.
Note that all the translation memories are loaded into memory when
                        the project is opened. Back-ups of the project translation memory are
                        produced regularly (see next chapter), and
                        project_save.tmx is also saved/updated when the
                        project is closed or loaded again. This means for instance that you do
                        not need to exit a project you are currently working on if you decide to
                        add another ancillary TM to it: you simply reload the project, and the
                        changes you have made will be included.
               
The locations of the various different translation memories for a given project are user-defined (see Project dialog window in Project properties)
Depending on the situation, different strategies are thus possible, for instance:
several projects on the same subject: keep the project structure, and change source and target folders (Source = source/order1, target = target/order1 etc). Note that you segments from order1, that are not present in order2 and other subsequent jobs, will be tagged as orphan segments; however, they will still be useful for getting fuzzy matches.
several translators working on the same
                              project: split the source files into source/Alice,
                        source/Bob... and allocate them to team members (Alice, Bob ...). They
                        can then create their own projects and, deliver their own
                        project_save.tmx, when finished or when a given
                        milestone has been reached. The project_save.tmx
                        files are then collected and possible conflicts as regards terminology
                        for instance get resolved. A new version of the master TM is then
                        created, either to be put in team members'
                        tm/autosubfolders or to replace their
                        project_save.tmx files. The team can also use the
                        same subfolder structure for the target files. This allows them for
                        instance to check at any moment, whether the target version for the
                        complete project is still OK
               
As you translate your files, OmegaT
                        stores your work continually in project_save.tmx in
                        the project's /omegat subfolder.
               
OmegaT also backups translation memory
                        to project_save.tmx.YEARMMDDHHNN.bak in the same
                        subfolder whenever a project is opened or reloaded. YEAR is 4-digit
                        year, MM is a month, DD day of the month, HH and NN are hours and
                        minutes when the previous translation memory was saved.
               
If you believe you have lost translation data, follow the following procedure:
Close the project
Rename the current project_save.tmx file
                                     ( e.g. to project_save.tmx.temporary)
                        
Select the backup translation memory that is most likely - e.g. the most recent one, or the last version from the day before) to contain the data you are looking for
Copy it to project_save.tmx
Open the project
Tmx files contain translation units, made of a number of equivalent segments in several languages. A translation unit comprises at least two translation unit variants (TUV). Either can be used as the source or target.
The settings in your project indicate which is the source and which the target language. OmegaT thus takes the TUV segments corresponding to the project's source and target language codes and uses them as the source and target segments respectively. OmegaT recognizes the language codes using the following two standard conventions :
2 letters (e.g. JA for Japanese), or
2- or 3-letter language code followed by the 2-letter country code (e.g. EN-US - See Appendix A, Languages - ISO 639 code list for a partial list of language and country codes).
If the project language codes and the tmx language codes fully match, the segments are loaded in memory. If languages match but not the country, the segments still get loaded. If neither the language code not the country code match, the segments will be ignored.
TMX files can generally contain translation units with several candidate languages. If for a given source segment there is no entry for the selected target language, all other target segments are loaded, regardless of the language. For instance, if the language pair of the project is DE-FR, it can be still be of some help to see hits in the DE-EN translation, if there's none in the DE-FR pair.
The file project_save.tmx contains all the
                        segments that have been translated since you started the project. If you
                        modify the project segmentation or delete files from the source, some
                        matches may appear as orphan strings in
                        the Match Viewer: such matches refer to segments that do not exist any
                        more in the source documents, as they correspond to segments translated
                        and recorded before the modifications took place.
               
Initially, that is when the project is created, the main TM of the
                   project, project_save.tmx is empty. This TM gradually
                   becomes filled during the translation. To speed up this process, existing
                   translations can be reused. If a given sentence has already been
                   translated once, and translated correctly, there is no need for it to be
                   retranslated. Translation memories may also contain reference
                   translations: multinational legislation, such as that of the European
                   Community, is a typical example.
            
When you create the target documents in an
                   OmegaT project, the translation memory of the
                   project is output in the form of three files in the root folder of your
                   OmegaT project (see the above description). You
                   can regard these three tmx files (-omegat.tmx,
                   -level1.tmx and -level2.tmx) as
                   an "export translation memory", i.e. as an export of your current
                   project's content in bilingual form.
            
Should you wish to reuse a translation memory from a previous project (for example because the new project is similar to the previous project, or uses terminology which might have been used before), you can use these translation memories as "input translation memories", i.e. for import into your new project. In this case, place the translation memories you wish to use in the /tm or /tm/auto folder of your new project: in the former case you will get hits from these translation memories in the fuzzy matches viewer, and in the latter case these TMs will be used to pre-translate your source text.
By default, the /tm folder is below the project's root folder (e.g. .../MyProject/tm), but you can choose a different folder in the project properties dialog if you wish. This is useful if you frequently use translation memories produced in the past, for example because they are on the same subject or for the same customer. In this case, a useful procedure would be:
Create a folder (a "repository folder") in a convenient location on your hard drive for the translation memories for a particular customer or subject.
Whenever you finish a project, copy one of the three "export" translation memory files from the root folder of the project to the repository folder.
When you begin a new project on the same subject or for the same customer, navigate to the repository folder in the and select it as the translation memory folder.
Note that all the tmx files in the /tm repository are parsed when
                   the project is opened, so putting all different TMs you may have on hand
                   into this folder may unnecessarily slow OmegaT down. You may even consider
                   removing those that are not required any more, once you have used their
                   contents to fill up the project-save.tmx file.
            
OmegaT supports imported tmx versions 1.1-1.4b (both level 1 and level 2). This enables the translation memories produced by other tools to be read by OmegaT. However, OmegaT does not fully support imported level 2 tmx files (these store not only the translation, but also the formatting). Level 2 tmx files will still be imported and their textual content can be seen in OmegaT, but the quality of fuzzy matches will be somewhat lower.
OmegaT follows very strict procedures when loading translation memory (tmx) files. If an error is found in such a file, OmegaT will indicate the position within the defective file at which the error is located.
Some tools are known to produce invalid tmx files under certain conditions. If you wish to use such files as reference translations in OmegaT, they must be repaired, or OmegaT will report an error and fail to load them. Fixes are trivial operations and OmegaT assists troubleshooting with the related error message. You can ask the user group for advice if you have problems.
OmegaT exports version 1.4 TMX files (both level 1 and level 2). The level 2 export is not fully compliant with the level 2 standard, but is sufficiently close and will generate correct matches in other translation memory tools supporting TMX Level 2. If you only need textual information (and not formatting information), use the level 1 file that OmegaT has created.
In case translators need to share their TMX bases while excluding
                        some of their parts or including just translations of certain files,
                        sharing the complete ProjectName-omegat.tmx is out
                        of question. The following recipee is just one of the possibilities, but
                        simple enough to follow and without any dangers for the assets.
               
Create a project, separate for other projects, in the desired language pair, with an appropriate name - note that the TMXs created will include this name.
Copy the documents, you need the translation memory for, into the source folder of the project.
Copy the translation memories, containing the translations of
                                     the documents above, into tm/auto subfolder of
                                     the new project.
                        
Start the project. Check for possible Tag errors with Ctrl+T and untranslated segments with Ctrl+U. To check everything is as expected, you may press Ctrl+D to create the target documents and check their contents.
When you exit the project. the TMX files in the main project folder (see above) now contain the transltions in the selected language pair, for the files, you have copied into the source folder. Copy them to a safe place for future referrals.
To avoid reusing the project and thus possibly polluting future cases, delete the project folder or archive it away from your workplace.
In cases where a team of translators is involved, translators will prefer to share common translation memories rather than distribute their local versions.
OmegaT interfaces to SVN and Git, two common team software versioning and revision control systems (RCS), available under an open source license. In case of OmegaT complete project folders - in other words the translation memories involved as well as source folders, project settings etc - are managed by the selected RCS. see more in Chapter
There may be cases where you have done a project with e.g. Dutch sources, and a translation in say English. Then you need a translation in e.g. Chinese, but your translator does not understand Dutch; she, however, understands perfectly English. In this case, the NL-EN translation memory can serve as a go-between to help generate NL to ZH translation.
The solution in our example is to copy the existing translation memory into the tm/tmx2source/ subfolder and rename it to ZH_CN.tmx to indicate the target language of the tmx. The translator will be shown English translations for source segments in Dutch and use them to create the Chinese translation.
Important: the supporting TMX must be renamed XX_YY.tmx, where XX_YY is the target language of the tmx, for instance to ZH_CN.tmx in the example above. The project and TMX source languages should of course be identical - NL in our example. Note that only one TMX for a given language pair is possible, so if several translation memories should be involved, you will need to merge them all into the XX_YY.tmx.
Some types of source files (for instance PO, TTX, etc.) are
                   bilingual, i.e. they serve both as a source and as a translation memory.
                   In such cases, an existing translation, found in the file, is included in
                   the project_save.tmx. It is treated as a default
                   translation, if no match has been found, or as an alternative translation,
                   in case the same source segment exists, but with a target text. The result
                   will thus depend on the order in which the source segments have been
                   loaded.
            
All translations from source documents are also displayed in the Comment pane, in addition to the Match pane. In case of PO files, a 20% penalty applied to the alternative translation (i.e., a 100% match becomes an 80% match). The word [Fuzzy] is displayed on the source segment.
When you load a segmented TTX file, segments with source = target will be included, if "Allow translation to be equal to source" in Options → Editing Behavior... has been checked. This may be confusing, so you may consider unchecking this option in this case.
Of interest for advanced users only!
Before segments get translated, you may wish to pre-process them or address them in some other way than is possible with OmegaT. For example, if you wish to create a pseudo-translation for testing purposes, OmegaT enables you to create an additional tmx file that contains all segments of the project. The translation in this tmx can be either
translation equals source (default)
translation segment is empty
The tmx file can be given any name you specify. A pseudo-translated memory can be generated with the following command line parameters:
java -jar omegat.jar --pseudotranslatetmx=<filename>
                      [pseudotranslatetype=[equal|empty]]
Replace <filename> with the name of the
                   file you wish to create, either absolute or relative to the working folder
                   (the folder you start OmegaT from). The second
                   argument --pseudotranslatetype is optional. Its value
                   is either equal (default value, for source=target) or
                   empty (target segment is empty). You can process the
                   generated tmx with any tool you want. To reuse it in
                   OmegaT rename it to project_save.tmx
                          and place it in the omegat-folder of your
                   project.
            
Very early versions of OmegaT were capable of segmenting source files into paragraphs only and were inconsistent when numbering formatting tags in HTML and Open Document files. OmegaT can detect and upgrade such tmx files on the fly to increase fuzzy matching quality and leverage your existing translation better, saving you the work of doing this manually.
A project's tmx will be upgraded only once, and will be written in
                   upgraded form into the project-save.tmx; legacy tmx
                   files will be upgraded on the fly each time the project is loaded. Note
                   that in some cases changes in file filters in
                   OmegaT may lead to totally different
                   segmentation; as a result, you will have to upgrade your translation
                   manually in such rare cases.