Localizing Java Software

During my second year at MIIS, I am very fortunate to be volunteering for the Arctime localization project. Arctime is a powerful subtitling/video editing software developed by a Chinese company. Through out this year, I have worn the PM hat, the loc engineer hat as well as the translator hat to drive the localization, testing, and translation of the Arctime official website and software. I’m very proud to say that our team of seven have accomplished a lot! We delivered the glossary validation project, EN software QA testing project, zh-TW software localization project, WordPress website migration project, and EN website continuous localization project. If you are interested in learning about these projects in details, please find our presentation here. In this article, I will be focusing on our core project—zh-TW Software Localization. We localized .properties file from simplified Chinese to traditional Chinese.

Arctime Software in Its Source Language: Simplified Chinese
Source: Actime Official Website Feature Page

zh-TW Software Localization

Before we took over the Arctime volunteer project, the class of 2019 has laid a solid foundation of externalizing the strings and translating the software from simplified Chinese into English. Therefore, this year we carried on by doing glossary review and client validation to ensure the translation consistency and quality before we start with any other projects, running QA testing on the translated English software, and continuing to translate software into traditional Chinese for users in Taiwan and Hong Kong.

Previous Translation Process

In the previous year, volunteer linguists translated the Java .properties files directly in the Transformer software, a .properties file editor provided by the client. This way, they could save time on creating projects on TMS and importing/ exporting the texts files.

New Translation Process

This year, our team decided to move the translation process into Memsource. Our new workflow include the following steps.

  1. Unpack the software and collect the source .properties files
  2. Unescape the codes in the .properties files
  3. Copy the unescaped texts into .txt format
  4. Pretranslate the project with MT and termbase on Memsource
  5. Linguists MTPE on Memsource
  6. Linguists review on Memsource
  7. Export .txt files from Memsource
  8. Escape the codes in .txt files and paste them into properties files
  9. Repackage the software
  10. zh-TW software LQA testing
The Actual Process of String MTPE on Memsource

At first glance, it might seem that we overcomplicated the process by introducing several additional steps. However, translating in TMS have several advantages:

  • Ensure translation consistency across different linguists because TM is stored real-time in the cloud, so when they translate, they can refer to others’ translation to avoid style and terminology difference
  • Accumulate TM for the localization of traditional Chinese website and tutorial videos next year
  • We can pretranslate with MT with one click on Memsource, as opposed to copying and pasting MT output into each .properties file in Transformer


Due to time and resource limitation, we weren’t able to finish the entire project. We have finished up to the fifth step—MTPE on Memsource, so the team taking over the project next year will need to continue the process from reviewing the translation. Yet, my teammate Shiyu and I have done a pilot run to test if all the listed steps work, and we have documented and solved the technical difficulties during the process, so the team will be able to continue the project smoothly next year.

Technical Difficulties

During our pilot run, we ran into quite a few issues we hadn’t foreseen, including:

  • Finding the right converter to escape and unescape codes: All the online character escape converters more or less introduced some extra characters when they convert codes, which later led to the corruption of codes when we repackaged the .properties files. Therefore, we had to pick the one which introduced least changes and manually clean up the codes after conversion.
We used the Java Converter on the Left of this Website.
  • Memsource parsing the .properties files incorrectly: The unescaped .properties files shown up as garbled on Memsource no matter which converter we used. Therefore, we decided to paste the codes from the .properties files into .txt files and import them to Memsource instead. This inevitably adding two manual steps, but this is already the most time-saving way we came up with.
  • Packaging the translated files back into software: After translation and incorporation (the process of putting the translated file back into the folder and build into software,) no matter how many times we tried, the software wouldn’t run. It was because we didn’t keep the original jar file in the folder. The correct way of packaging file is as below:
    1. Rename the original string package xxxx.jar file as xxxx_original.jar and keep it in the package (Path: Contents/Resources/Java,)
    2. Zip up the translated and escaped cn, e, and META-INF folders into a new xxxx.zip string package.
    3. Change the xxxx.zip name from xxxx.zip to xxxx.jar (the original string package name.)
    4. Put this new xxxx.jar file into the package (in the same path: Contents/Resources/Java.)

Final Thoughts

During this year of managing the glossary review/validation project, the software localization project, and the QA testing project, I have gained and learned so much about Java software internationalization and localization. Yet, my biggest takeaway in this type of volunteer project is to work as closely with the client as possible.

Ask the client whenever you need help regarding the product or process. I was reluctant to ask the client for help when I couldn’t find contexts for the terms which our linguists found confusing. I also spent hours and hours experimenting how to package the translated files and build the software. However, with the client’s guidance, I was able to solve the issues real quick. For those who have experience working at an LSP, the service mindset tends to stops us from asking clients questions and prompting us to solve the problems internally. However, our collaboration with the client on this volunteer project is different from the traditional buyer-service provider relationship essentially. The client treats our team as a partner and is really willing to teach and help us, so instead of trial and error by ourselves, we should go to our client for help when we need it. After all, he is the one who coded the entire software and knows in and out about it. We should treat him as our partner, someone we can go to and ask for help as long as we need it.

Localizing a Unity Game!

Why Unity?

Unity is the most commonly used game engine in the industry. It supports multiple languages like C#, JavaScript (UnityScript) or Boo. Unity is used to make games and other types of content for more than 25 platforms, including mobile, PC, WEB, AR, and VR. The use of Unity has expanded beyond games into film, animation, architecture, and automotive, etc. After learning to use Unity, our team was amazed by how powerful Unity is in creating movements, adjusting the atheistic of the elements, and building games, so we decided to work on something challenging but interesting — localizing a game that was built on Unity.

Intro to Our Project

After searching through tens of hundreds of games on UnityList, the open-source marketplace, our team came across a simple yet fun game — the Flappy Bird. In the game, players try to control a bird by clicking the mouses or tapping space bars to fly between obstacles without hitting them. We decided to localize it from English to simplified Chinese.

How did we localize it?

Although Unity has released its localization package (in Beta) We went with the I2 Localization plugin because we want to experiment not only on the strings, but also on other elements. We first imported the plugin as an asset. Then we played the game over and over again to identify the strings in the game. There are, in total, four strings in Flappy Bird, including Game OverFlap To RestartRecord, and Score

Localizing the Strings

The steps to localize strings in I2 Localization are pretty straightforward:

1. Add Languages

2. Add terms (keys) for each string

3. Locate the strings in .cs files. (They are usually in GUIManager and GameManager files.)

4. Wrap the strings with I2.Loc.LocalizationManager.GetTranslation(“TermName”).

However, the difficult part is actually locating the strings. We couldn’t find the Game Over and Flap To Restart strings in the codes. We later learned they were actually built-in texts in the GameOverText and RestartText objects.

So we literally added the strings of GameOverText and RestartText objects to the source cod.

  1. Analyze how other strings are written.
  2. Imitate the style and add the strings of GameOverText and RestartText into the GUIManager.cs file after analyzing what I already had for Record and Score.

a. “Public” the GameObject of gameOverText and “Private” the Text variable of gameovertext.

b. Add a GetComponent<Text> function to the variable.

3. Continue to localize the strings with I2 Localization as described above.

Localizing the Strings and Fonts

In order to provide a more comprehensive experience for the players and make this project even more challenging, we also decided to localize the fonts and sprites in the game as well. This can actually be done in I2 Localization too!

On Canva, We purchased some images (a Chinese-feeling sky, Chinese-style clouds, and bamboos) and edited them to make them fit into the games in terms of their sizes, lighting, and colors. We put them in the Sprites folder in the game assets.

The Steps are pretty simple:
1. Add a sprite (e.g. sky) as a Term in I2 Localization and select the Type as Sprite.
2. Select the Chinese-style sprite (e.g. sky_zh-CN) for simplified Chinese.

3. Select the element and add I2 Localize component to it.

4. Make sure the sprite for English and simplified Chinese were correctly set.

Localizing the Font

Very similar to localizing the sprites, all you need to do is to add a Term for fonts and add a component. The key is to select the Type as Font.

This is how the game looks like with Chinese-style sprites and fonts!


After we successfully localized everything and added a language picker , we found a bug in the Chinese version: he bird would died even before hitting bamboos (which made the game super hard lol).

We started to dig into the files again and found that we need to adjust the Size of the Box Collider 2D component of bamboos. Even though the size of bamboos and columns are different, the Size settings of the bamboos remain the same as those of the columns. (The X number was 1.2 and should be lower.)

After several rounds of trial and error, we learned to set the X number to 0.7. Now, it matches the width of the bamboos perfectly.

 Final Product

After 7 or 8 hours of work of three people, we finally localized and debugged the game. It looks pretty cool in Chinese now!

No-source-video Challenge: Localizing a Commercial from Scratch with After Effects


Quick question! How do you localize an After Effect video? The answer seems pretty straightforward: ask your client to provide an AE project file (.aep), investigate it thoroughly to see whether you are able to access the texts in the video, either pull them out using an AE library aetextio or create a picture list of the texts manually, feed the texts into a CAT tool to translate, and then import them back to the video either through aetextio or manually. This is the ideal scenario because the source texts in the video are not in your way. They can be replaced by target texts directly. However, if you can’t get a project file from your client, things can get a little bit crazy. You’ll have to hide the source texts away and reproduce all the effects for your target texts.

With a goal to challenge myself to learn the different text effects in AE I localized this 1’27 long commercial of Google from scratch:

Seems pretty simple right? Well, it actually took me a solid 22 hours to finish it, and I am going to show you what’s taking me so long. Maybe you will be able to sense the challenges I faced in the finished target video:

The background music of this demo was removed.


1. Masking through Shapes

Fortunately, the background colors of the texts in the video are mostly monotone, so the most efficient way to mask the source texts is to create shapes. It’s not as simple as you might think though because the source texts move a lot and the colors/brightnesses of the backgrounds change if they are buttons!

In these cases, you’ll have to create several shapes for different frames and carefully match their appearances and motions against the buttons in the source.

In the screenshot, you can see that in order to match the motions and opaqueness of the button and the message box, I created several shapes.

  • My tips:
    1. Start from the creation of relatively static backgrounds, like those without any animation.
    2. Then move on to the animated backgrounds. Create shapes larger than texts and with some extra room and match their positions to the motions of the texts.
    3. If the source texts are magnified, adjust the sizes of the shapes under “scale”.
    4. If the background colors changes, duplicate the shapes and change the colors using the “eyedropper” feature.
    5. If the brightness of the background color changes, duplicate the shape and place it at the frame when the changes start. Adjust the color of target shapes to the color of source shapes that appear in the middle of the brightness gradation process. Then you can apply the “Brightness & Contrast” effect to adjust the brightness of the target shape accordingly.

2. Masking with the New Feature: “Content Aware Fill”

This new feature isn’t that difficult to apply. I learned the gists in this Youtube tutorial. Users just need to mark the movements of the objects they want to remove with shape masks (created directly on the video layer):

I experimented with different fill methods, and found that “Edge Blend” works best with my video.

The result is quite impressive:

  • My tips:
    1. Limit the range of “Content Aware Fill” to “Work Area”. Otherwise, it will take AE days to generate the .png mask that hides the objects away.
    2. Hide the shape masks of your objects by moving them outside of the display area. Or the shape masks will be there during the entire video, and you will “content aware fill” something that should not be removed.

3. Recreating Typewriter Effect

In the source video, typewriter special effect occurs whenever there is a search bar.

There is already a typewriter effect in the effect library, with which I created my credit at the end of the video. However, it does not come with a cursor:

Therefore, I turned to Youtube for help. This tutorial taught me how to install a text effect preset in AE, and I managed to match the speeds and starting points of the typewriter effects by endless experiments with the “Speed” and “Start After” setting:

  • My tips:
    1. Align target texts to source texts first.
    2. Adjust Start After setting. For Chinese characters, the number should be pretty small. 0.01 to 0.05 work just fine.
    3. Then you can match the speeds against those of the source texts.

4. Recreating Blur Effect

Sometimes, the shapes do not fit well with the backgrounds when they are not absolutely monotone or static. In these cases, you can apply “Fast Box Blur” effect to soften the edges of the shapes.

Sometimes the source texts also move so fast that they look blurry. You can apply the “Fast Box Blur” effect to the target texts to match the animation of the source texts in this case.

5. Adjusting Contents in the Video to fit Text Contraction/Expansion

Inevitably, when a language is translated into another, the texts expand or contract. In this project, when English is translated into traditional Chinese, it shrinks a great deal. You can see the length differences of the texts in the following screenshots:

In such cases, besides texts, video contents also need to be adjusted as well. I believe it’s feasible to recreate the objects and animations directly in AE. Worst case scenario, users can always create them in Photoshop or screenshoot the objects, import the image files into AE, and then animated them. Due to time constraints, I wasn’t able to incorporate these additional side projects this time, but I believe they are definitely fun to work on too!

Key Takeaways

1. Always adjust the beginning and end keyframes first, and then work on the middle keyframes if needed.

2. If the backgrounds are monotone , stay with shapes. “Content aware fills” takes longer time, involves more steps, and is very CPU-consuming.

3. Organize the layers well! Rename and lock every layer after creations or modifications to prevent unintentional changes or, worse case, deletion.

4. Analyze shapes movements before creation. Group the shapes of the same movements together to modify them in bulk and ensure consistent spacing in between.

5. Display grids when you are positioning texts or shapes. Tiny spacing issues often slip through if you only rely on your sense.

6. Numbers are your guide when you are matching the fonts and positions of texts.

Final Thoughts on After Effects

Through this challenging no-source-video localization project, I learn the most important lesson the hard way:

Never localize AE videos when there are no source files!!!

Consider the additional AE and Photoshop projects to fix text expansion and contraction as well as the excruciating masking and animation recreation process. If you have no other choices but to do so,

Estimate billable hours smartly. Charge enough for your time and efforts.

Also, the new “content aware fill” feature is powerful, indeed, but it’s not intelligent. Users must manually insert tons of keyframes to mark an object that needs to be removed. If Adobe can automate the object recognition and marking process, it will definitely save users a lot of tedious manual work.

Last but not least, one final appeal to Adobe: Can we have features like animation (motion, opaqueness, position, brightness, etc) detectors? I tried many of the set effects in the library, but I wasn’t able to to create identical animations for the source texts with any of them, so I had to create the animations keyframe by keyframe from scratch. I believe loc engineers and DTP specialists who are responsible of reproduce text animations and text integration would definitely appreciate some sort of AI detectors! Go Adobe! We count on you!

Translation Management System (TMS) Matters.

A translation management system (TMS) is a tool, either in the form of software or a website, which enables you to:

  • manage and track translation/localization projects
  • submit, track, download, and store project files
  • manage and store linguistic resources like translation memories (TM), glossaries, reference files, etc
  • communicate with stakeholders including clients and vendors such as agencies, translators, editors, DTP specialists, QAers, dubbers, subtitlers, etc
  • issue and record payments through documents like vendor P.Os and client invoices

In the TMS course taught by Professor Adam Wooten, I have learned a great deal about SDL WorldServer and GlobalLink through hands-on training from the professor and TransPerfect project managers, the difference between different TMSs through our group comparison project, and professional consulting skills through the consulting project for our client.

In this blog post, I will discuss about the key takeaways and present deliverables of our projects.

TMS Group Comparison Project

In this project, my team compare SDL WorldServer and GlobalLink against the need of our “client” Hulu, an American video streaming service provider owned by Walt Disney and Comcast. I learned that the key to select the best TMS is to understand and define the needs of a company, set up the weights of different requirements that are taken into consideration, and compare the performance of the TMS objectively with their scores.

The following is our presentation slides and detailed business requirement scorecard (links to Google Drive):

Business requirements scorecard

TMS Group Consulting Project

In this project, we experienced and analyzed a TMS product of our client. The TMS was used internally originally, and the client meant to sell it as an affordable solutions to individual translators. Our team looked into the possibility of turning this TMS as an enterprise-level solution for media streaming companies. As the market of media localization grows exponentially, we believe it’s a great opportunity for our client to step into this side of the industry. We envision the target consumers of this TMS to be small language service providers (LSPs) specializing in subtitle localization, subtitlers, translators, and big and small streaming media platforms.

Small LSPs probably wouldn’t have the budget to purchase MediaNext,  the only video localization tool on the market provided by TransPerfect, nor would they be able to build their own platform, so they would be the perfect target clients for our client. Also, we suggested our client to keep the affordable pricing strategy of the product to attract more individuals whose work revolves around subtitles.

In order to win the streaming media service providers, our client needs to make some adjustments to the product:

  • Support more subtitle file types that can be imported and exported into and from the TMSL:
    • ASS (existing), SSA, SUB, SMI, and WEBVTT
  • Customize the user interface for video localization with some new features:
    • Text editing and formatting
    • Video timeline
    • In-context subtitle QA feature (refer to the real-time video preview feature of MemoQ)
  • Improve the workflow
    • Create setting and parsing templates for subtitle projects
    • Enable PMs to assign the projects and vendors to claim them

For more details, please watch the consulting video that we delivered to our client (link to Google Drive):

Client Consulting Video

Advanced CAT with MT Portfolio

  1. Introduction:
    • In this semester, we built on on what we had learned about CAT tools in the Intro to CAT class and explored some advanced Trados features. The major projects we worked on include training Microsoft Translator hub (SMT) and Microsoft Custom Translator (NMT), using Regex (regular expression) to create QA filters in Trados, and creating a training video on a tool that can be useful in localization workflows. In this post, I will present the result of these projects and discuss my biggest takeaways from each of them.
  2. NMT Training Project Using Microsoft CustomTranslator
    • This is absolutely my favorite projects out of all. Our group Team Machine trained a NMT model to translate AI related TED talks from English to simplified Chinese. I learned so much from this hands-on experience of training an neural machine translation engine. I now know how to:
      • extract multlingual srt files from the TED talks on Youtube with this useful website
      • choose from several alignment solutions, including Trados, MemoQ, TMX Mall Alignment (paid per use, intuitive user interface), and Wordfast Aligner (free, fully automatic, but must work with 100% texts with identical numbers of segments)
      • clean up files in word using advanced find and replace feature in MS Word
      • decide what materials should be used in training tuning, or testing:
        1. Training: general materials of the same but broader domains and from a larger time frame
        2. Tuning: specific and recent materials of the exact same domains
        3. Testing: : specific and recent materials of the exact same domains. There should only be one single set of data to be compared against with through out the entire training process.
      • train NMT in Microsoft Custom Translator (fter 11 rounds of training, I have been quite familiar with the process.)
      • evaluate MT outputs with the quality evaluation model with weights and threshold we established
      • streamline the post editing and evaluation process with a specially designed Google sheet
      • root cause analyze the quality issues
    • Project Deliverables (Link to Google Drive):
      1. Original Pilot Proposal
      2. Updated Proposal
      3. Presentation on Lessons Learned
  3. Utility Demo/Training Video
    • I also recorded a demo for XnView, a powerful photo view, organizer, and converter, with Zoom and a magnifier tool called Zoomit. XnView is especially helpful for localization project managers and DTP specialists because we often have to manage a large number of images and multimedia files like those in user manuals, brochures, product catalogues, and commercial videos. I navigated its interface and demonstrated some of its most useful features in the video.
    • Project Deliverable (Link to Google Drive):
      1. video
  4. Tips for Trados QA (using Regex)
    • We have learned the basics of Regex and applied it not only to the QA setting in Trades, but also to Olifant and XBench (to clean up our tuning data for the NMT training project). For this small Regex project, we analyzed the specific punctuation and stylistic issues in Chinese and established QA checker rules to catch these issues.
    • Project Deliverable:
      • Rules:
        1. 4 consecutive full-width punctuation marks in Chinese: \W\W\W\W
          • In Chinese, we use full-width punctuation marks, and they should be no more than three in a row, e.g. ……)
        2. Chinese date format should be YYYY/MM/DD: \d\d(/|.)\d\d(/|.)\d\d\d\d
          • We write our dates with year at the beginning 2019/04/19/.
        3. There should be no double space before full-width punctuation marks: \s\s\W
          • Full-width punctuation marks should be with words without any space in between, e.g. 下雨了。
        4. There should be no half-width quotation marks ‘ ’  “ ” ‘ ‘  ” “: [‘’“””””]
          • If we have English in target text, we use our full-width punctuation mark to modify it.
        5. There should be no space between full-width punctuation marks: \W\s\W
          • We use our full-width punctuation in a row, e.g !)
          • Result
The rules capture all the errors successfully!

Mini Portfolio for Social/Local Translation Crowdsourcing


Crowdsourcing means harnessing the wisdom, energy, talents of the crowd in a streamlined/semi-automated manner for a common goal or purpose. In the field of localization and translation, many companies and organizations often turn to passionate volunteers for help, including Facebook, Trello, TED, Mozilla, etc. Though not necessarily more cost efficient, crowdsourcing is indeed a good way for companies to engage its users in the creation of the products and contents of the company. In this blog post, I will present the presentations and other deliverables from the course Social/Local Translation Crowdsourcing taught by Professor Adam Wooten.

Professional Presentations

Recommendations to optimize the Quantity of translation (by my teammate Lina)

Recommendations to optimize the Quality of translation 

In addition to generating a satisfying amount of translation, it’s crucial to have translation of satisfying quality too. Otherwise, the poorly translated content might not only fail to achieve our original educational and marketing goals, but also do enormous harm to the brand image. To safeguard and boost the quality of the content translated by the non-professional community, we have designed several solutions for Codecademy:

  • Interactive Training Process

It goes without saying that contributors must develop an understanding of the content and also acquire basic translation skills before they can provide quality translation. 

For starters, to make sure translators have an understanding of the content, we believe translators should be recruited from the existing active user community.

For content like course materials, we advise Codecademy to stipulate that only those who finish the courses they would like to translate are eligible to translate the course content. 

Moving onto building translation skills, we were inspired by the LegoDragon training Google designed for its linguists and came up with the idea to combine the initial training and screening process together in gamified activities. 

Our proposal is to create short interactive courses on elements listed in style guide (like tone, punctuation, and tags), glossary (ideally created by Codecademy employees who are already product experts, including course advisor, coaches, and content creators), tools, and workflow(like rating schemes). After contributors finish the short courses, they will have to pass a test before diving into translation. Since our goal is to include every community member who would like to make contribution, we recommend Codecademy to provide unlimited attempts for members to take the courses and a test, so if they cannot pass the test in their first try, they can take it as many times as they want. That way, we kill two birds with one stone! We do not turn any members down and we make sure our contributors are fully qualified.

  • Built-in Automatic QA Feature 

It saves a lot of time and effort in the editing and proofreading stage if we integrate the right CAT tool that comes with essential QA feature (with spell, grammar, punctuation, and tag checks) onto the collaborative translation platform. Ideally, the QA feature should run automatically after confirming segments, saving contributing translators extra time to go through translation again. Based on our research, Lilt (https://lilt.com) seems to be the best choice on the market because it is one of the most intuitive, user-friendly tools and it also comes with an Auto QA feature.

  • 3 Reviewing Approaches

In addition to the above-mentioned QA in the translation stage, we also suggest Codecademy to incorporate community voting and/or a final review conducted by professional translators and reviewers to make sure the translation result align with the demand of users and avoid any extra errors. Community voting system has proved to be successful in many crowdsourcing and community translation cases. The voting and flagging in Translate Facebook (https://www.facebook.com/translations) and the validating in Google Translate Community are the 2 most significant examples. Nevertheless, the publishing timeframe of translation outputs will be more difficult to control for companies, so hiring professionals to review is also a good workaround worth considering. If possible, Codecademy might even be able to invite its employees who are already product expertsto review the content too.

  • Raising Quality Awareness Through Level-Up

Most crowdsourcing and community translation platforms evaluate contribution by amount. We argue that the quality of translation is equally or even more important than the amount of translation, so taking approved/rejected segment ratio and error statistics into account while building the gamified leveling up structure might be a great way to stress the importance of quality in the community.

  • Reliable Community Managers

Existing managers of the Codecademy learner community and contributors with more experiences and better performances can become translator community managers. As reliable points of contact, they can provide answers to questions and make sure contributors abide by community guidelines.

Final Project Files:

RBMT Hybrid MT Engine Training Project

by Yiping Liao and Cheng Qian

  1. Description: 

Our rule-based hybrid MT engine is customized for skincare product ingredient analysis. Our goal for this engine is to translate product label lists. The most common file types it will handle are MS Word documents and Excel spreadsheets. 

  • Sources:  http://www.cosdna.com/

It is a web-based data collection of cosmetics information, mainly ingredients. Data sources include international experts, institutions, and publications. Users can submit a new item to the ingredient list, if anything is missing. Available languages include English, Simplified Chinese, Traditional Chinese, and Japanese.

  • Dictionary: https://docs.google.com/spreadsheets/d/1taY_zae1V3AdiB0EM7QRKJokHVBJlQIMCbVdpyqWI94/edit?usp=sharing
  • Time used
    1. Dictionary building: 90 min (19:45 – 21:15)
    2. Dictionary upload and training initiate: 12 min (21:43 – 21:55)
    3. Data processing: 65 min (21:55 – 23:00)
    4. Training running: 20 min (23:00 – 23:20 Training succeeded) 

How do you boost your translation quantity in translation crowd-sourcing, community translation, and social localization?

The ideas of crowd-sourcing, community translation, and social media localization appeal to companies looking for a relatively cost-effective solution to translation or wanting to engage more users and build their own contribution communities. However,  increasing the volume of contribution to a level high enough to satisfy their needs is likely to be a tough nut to crack for beginners or those on the fence. Nevertheless, there are already several successful predecessors in the industry whose experiences are worth learning from. In this article, I will list the motivating and demotivating factors of such contribution and give out some tips for companies to boost the quantity of translation based on the best practices I’ve learned in the course Social Local/Translation Crowdsourcing.

To increase quantity of translation, the most important thing is to:

  1. Recruit more contributors through providing and advertising incentives
  2. Prevent losing contributors by avoiding as many deterrents as possible


Common Incentives for Translation Volunteering:

  • An opportunity of a new experience (whether in general or in the sense of professional career building)
  • A sense of fulfillment (can be reinforced and amplified by public recognition)
  • Fun (not only in the translation task itself, but also in the gamification elements like leader board and badges that facilitate friendly competition)
  • Social elements (whether it is a networking chance for volunteers to make new connections, an old connection that drives them to start volunteering, or a sense of belonging to a community)
  • Free education/training (which some novice translators or translators-to-be are looking for)
  • Internal privileges (such as a higher access level or a special user interface)
  • Perks (like free food, transportation fee, schwags, etc)
  • More personal causes such as the alignment of values


Common Deterrents for Translation Volunteering:

  • Poor management (eg. poor and unfair implementation and enforcement of management policies or standards)
  • Mismatched anticipation of job responsibilities and contribution goals
  • Lack of recognition
  • Low flexibility to do things whenever contributors want or how much they want (not breaking chunks of work down into micro tasks)
  • Lack of continuous communication
  • Low social motivation such as feeling they are translating/working on it alone
  • Inconsistency of motivations
  • Competing causes such as contributors finding that they can get paid elsewhere for what they are doing
  • A lack of meaningful/good enough feedback
  • Complexity of tasks (e.g. long sentences and tag issues sometimes even aggravated by not allowing contributors to skip segments)



After companies make sure that they have as many contributors in their pools as possible, here are some extra-detailed tips on how to achieve higher quantity of translation:


  • Make the contribution platform easy and user-friendly
    • A clear UI
    • A trouble-shooting feature (e.g. FAQs, contributor forum, issue escalation channel, etc)
    • Reference materials ready (TM, glossaries, style guide, and auto look-up feature should be in place)
  • Make the contribution process fun and a little bit competitive through gamification
    • Public recognition system (e.g. badges and leader board)
    • Visualization of the translation project progress with a thoughtful theme (e.g. city building or space exploration)
    • Progress/status updates on projects and personal records
    • Leveling up (to unlock features or a special interface and icon)
    • Social media integration (allowing contributors to invite friends and share their achievements)
  • Make it effortless for contributors to engage in the process
    • Split workload to enable both large and small contribution
    • Easy access of the translation/collaboration platforms (e.g. mobile apps)
  • Strict Implementation of public recognition and gratitude expression
    • Aforementioned recognition system and resume/professional certifications/badges that prove to the public the engagement of contributors
    • Simple gifts that stress company spirit like company logo stickers and t-shirts
    • Personal relationships through face-to-face meetings/dinner/holiday greeting cards, etc
  • Evangelize your companies and products and build a community or fandom
    • With a greater passion and belief, contributors will be able to work for you more efficiently and for a longer period of time.
    • It’s harder for contributors to stop working on the projects when their valued peers and friends continue to contribute.

What I Learned in My First LPM Course

Course Overview

As a former intern of localization project managers (LPMs) and a freelance translator myself, prior to this course, I have already accumulated some insights into localization (L10N) process through observation. Therefore, when I was introduced to the standardized process and best practices systematically in this course, I had plenty of experiences to draw from. I found myself constantly comparing the localization practices I’ve observed or adopted with what I was learning in the course: from quote creating, quote issuing, pre-translation preparation, translation, reviewing, post-translation layout to linguistic testing. Thanks to our beloved professor Alaina Brandt, I have successfully gained a comprehensive understanding of a good L10N process through a project simulation.

Team Project: Beat Saber Press Kit Web Page Localization

In simulation, our team undertook a web page localization project from Hyperbolic Magnetism, an indie game studio based in the Czech Republic. We localized the press release page of Beat Saber, a very cool VR rhythm game, into six languages, including Russian, Simplified Chinese, Traditional Chinese, Mexican Spanish, German, and Japanese. We decided on this client because many of the actual clients who need L10N services are software or gaming companies and we wanted to go through the actual process to see what potential problems may be.

In this project, we first built an LPM office and then adopted a standard workflow, including three main phases: pre-production, production, and post-production.

We set up our office by…
  • Creating team Trello board and adding lists and cards to define what we need to do for the 3 mentioned phases
  • Creating a team Dokuwiki page which contains subpages of our team, client, and project
  • Creating a OneDrive folder structure template
  • Setting up job codes and tracking time spent for different stages with TopTracker
As for pre-production phases, the actions include…
  • Drafting specification templates and pinning down our project specification
  • Creating a project style guide for different languages
  • Stipulating talent screening requirements and procedures and recruiting translators
  • Creating quote template and quote our clients according to market rates
  • Creating WO and PO templates and draft the actual ones for our translators
  • Wiping off files properties
  • Creating translation and projects, TM, and TB in Memsource
  • Preparing a translation kit with translation project, TM, TB, WO, PO, and Style Guide in it
In preproduction phase, the actions involved are…
  • Translating: We translated project file on Memsource. Due to time constraints and the fact that we didn’t have professional linguists to translate for us, we machine translated it.
  • Editing: We ran QA check and spell check on Memsource and check translation quality in terms of terminology, accuracy, and fluency in bi-text format
  • Proofreading: We exported the files, ran checks again, did a final examination on formatting and locale specific details (numbering, currency, time format, etc)
  • Final Verification: We verified our deliverables once again, paying attention to both content (e.g. the number of paragraphs, brand tiles, etc) and structure (e.g. file type, file name, etc)
Finally, we entered post-production phase. The actions include…
  • Handing off deliverables to our client Updating TM, TB, and Style Guide
  • Invoicing our client and translators
  • Sending a follow-up email
  • Managing customer feedback and making changes if applicable
  • Conducting a post-mortem team meeting
  • Archiving the project

Lessons Learned

  1. Money matters.

As a novice LPM team, we sort of messed up when quoting client because we weren’t familiar with industry customs. For our translation fee, we charged our client with the exact translator rates, meaning that we didn’t profit from translation services. Therefore, we could only earn from the project management fee in this project.

Nevertheless, we still did a good job by setting a high rate for services we didn’t want clients to ask for. For example, we charged a pretty steep rate for alignment because we wanted to discourage our client from requesting.

In our final budget tracking, we found ourselves running slightly over budget. We were less than 2 hours over billable time, which made us the best performing team in the course. However, the fact is we were still over budget. According to Alaina’s suggestion, in this scenario, there were three solutions:

  • Shaving off the costs in the following stages. For instance, LPMs can cut down further billable hours like buffer time or lower the cost for editing.
  • In the worst-case scenario, LPMs will have to l tell clients the truth and wait for their approval before proceeding with further work. LPMs may also need to create a new quote for client review.
  • Or LPM’s organization can simply absorb the cost.

Based on my own judgement, I believe this 2-hour extra cost can be made up by saving up in future stage, as long as we identify this problem earlier in the stage. Therefore, it’s important that we LPMs keep track of budget constantly in every single stage.

  1. Start organizing from the very beginning.

Prior to the course, our team members and I didn’t really have a habit of tracking time during work. Since it was our very first time using Toptracker to record the time spent, we paid more attention to reminding one another to turn it on than setting a naming convention for our jobs. Therefore, we used ADM for almost every task, and we didn’t specify and name tasks consistently. So it goes without saying, when we tried to calculate how much time we spent on different stages or types of task, it took us an excruciatingly long period of time to manually rename the tasks and clean the data up. Therefore, I’ve learned the importance of reaching an agreement on the naming standard for our task. The standard should be set up as early as in the LPM office building phase.

  1. As an LPM, you can never be too careful.

I learned this lesson the hard away after we redid our production phase all over again. Memsource wrongly segmented our source file, and we didn’t notice it until we entered the QA stage because we machine translated it without paying much attention. (Also some of us don’t speak the language we were working on.) Since we wanted a usable TM, we had no choice but to fix this problem. We tried several times reuploading the file on a certain day, but it didn’t work. However, when we tried it again later on another day, it magically worked, so we assumed Memsource experienced some bug on the previous day. I believe after this experience, everyone on our team will always check segmentation in CAT tools before sending files to translators.



« Older posts
Sites DOT MIISThe Middlebury Institute site network.