Welcome to the first Multilingual App Toolkit official blog!  It seemed only fitting that the first blog is about a service release to improve the toolkit itself…

Today we released an update for the Multilingual App Toolkit v2.1 that addresses community reported issues.

One key issue addresses the loss of additional language support when retargeting a JavaScript app from Windows 8 to Windows 8.1.  Even though the localized resources are added to the app’s PRI file, the manifest language list was not updated. This prevented access to the additional app languages when testing and publishing to the store.  After applying this update the workaround of adding the languages manually to the manifest will no longer be required.

Another fix in this release enables support for blank resources.  Prior to this release resources that were empty (“”) or only contained spaces (“    “) would cause a build error. With this release, blank resources are processed correctly.

We also took this opportunity to implement some performance tuning around translation suggestions.  We worked with the Microsoft Terminology API team to tune our calls to their service.  We also enhanced the editor suggestion experience by calling all the providers in parallel to improve the overall suggestion performance.

Additional fixes include editor changes to better support with Pinyin input and corrected translations in the Editor UI.

Developers using the Multilingual App Toolkit will receive an update notification via Visual Studio.  If you don’t want to wait for the notification, you can download it directly from the MSDN download pages today: http://msdn.microsoft.com/windows/apps/bg127574

With this release, the MAT team is pleased to announce the launch of the Multilingual App Toolkit feedback site http://multilingualapptoolkit.uservoice.com.  This is similar to Visual Studio (http://visualstudio.uservoice.com) and Windows Phone Developer platform (http://wpdev.uservoice.com) feedback and voting sites.  We are looking forward to the same level of success.

Our goal with the feedback site is to provide a common location for feature suggestions as well as community voting on the recommended features.  While we can’t promise to implement every feature, we are very interested in learning what features will benefit the developer community when deliver Windows platform apps to the global market.

Thank you,

The Multilingual App Toolkit team

You probably have been using the Microsoft Language Portal website to lookup strings for your apps for a while now - I know that I have!  What you may not know is that a little while back Palle's team in the Microsoft Language Services group created the Terminology Service API to access these resources directly.  (Learn more in Palle’s blog ‘Announcing the Microsoft Terminology Service API’.)

You probably also noticed that the Multilingual App Toolkit has incorporated the Terminology Service since v2.0 via the Microsoft Language Portal Provider. This provider connects you directly to these resources from within the Multilingual Editor (and Visual Studio) just like it does with machine translations via the Microsoft Translator service.  But did you know that you can tune the service to your specific needs, such as specifying which products or product versions are returned?

In this blog, I’ll show how you can tune the results to match your specific requirements.  It’s easy and may even help you find that perfect translation for your project!

The first thing you need to know is that the Microsoft Language Portal Provider configuration file lives at ‘%ALLUSERSPROFILE%\Multilingual App Toolkit\MicrosoftLanguagePortalProvider\LanguagePortalSettings.xml’.  Let’s open this file and see what’s inside.  Note: You will need to have administrator privileges to save any changes.

Here are the default contents of the configuration file.  Most of these elements align directly with the Terminology Service API parameters, and as such are self-explanatory.

<?xml version="1.0" encoding="utf-8" ?>
<LanguagePortal>
  <Translation>
    <Enabled>True</Enabled>
    <SearchOperator>Exact</SearchOperator>
    <TranslationSources>
      <TranslationSource>UiStrings</TranslationSource>
      <TranslationSource>Terms</TranslationSource>
    </TranslationSources>
    <UniqueResults>True</UniqueResults>
    <IncludeDefinitions>False</IncludeDefinitions>
    <Products />
  </Translation>
  <Suggest>
    <SearchOperator>Contains</SearchOperator>
    <TranslationSources>
      <TranslationSource>UiStrings</TranslationSource>
      <TranslationSource>Terms</TranslationSource>
    </TranslationSources>
    <UniqueResults>True</UniqueResults>
    <IncludeDefinitions>True</IncludeDefinitions>
    <Products />
  </Suggest>
  <ServiceOptions>
    <CacheRefreshDays>7</CacheRefreshDays>
    <ConnectionLimit>10</ConnectionLimit>
    <ConnectionTimeout>60</ConnectionTimeout>
  </ServiceOptions>
</LanguagePortal>

As you can see, the provider’s configuration is split into <Translation> and <Suggest> sections.  The values (for the most part) map directly to the Terminology Service API SDK documentation values.  Keeping the translate and suggest configurations separate allows the provider to tune the results base on the type of request.  This is something to keep in mind when tuning the provider’s configuration as translate will usually differ from those used when getting suggestions.

For this blog, we’ll focus on the tuning the products and product versions within the <Suggest> configuration so we can easily see the results in the Editor’s suggestion panel. 

By default the service uses all products to locate the best possible match.  However, if you wanted product specific strings from Windows, for example, you would simply expand the <Products /> node to reference Windows specifically.  The format is:

    <Products>
      <Product Name="Windows" /> 
   </Products>

But what if you wanted to use strings from Windows 7, Windows 8, Windows 8.1 as well as strings from Visual Studio 2013? In this case, you would simply add the version configuration as well.

    <Products>
      <Product Name="Windows">
        <Version Value="7"/>
        <Version Value="8"/>
        <Version Value="8.1"/>
     </Product>
      <Product Name="Visual Studio">
        <Version Value="2013"/>
     </Product>
   </Products>

Now all suggestions will be scoped to the specified products and product versions.  But what if you want to choose between the Windows and Visual Studio results returned from the suggestion request?  How would you know which is which?

To accomplish this, you will enable the service’s definition and terminology metadata feature.  While this configuration is already on, the configuration for insuring unique results obscures the metadata.  Disabling unique results will allow the service to deliver the metadata.  To set the results to non-unique, change the <UniqueResults> value from True to False.

    ...
    <UniqueResults>false</UniqueResults>
    ...

One quick note about non-unique results – if you don't scope the product list, you run the risk of maxing out your suggestions (defaults to 5, max of 20) with the same suggestion across multiple products or even the same product with multiple versions.

With the reconfigured system, open a XLF file in the Multilingual Editor. Selecting a resource in the ‘Strings’ tab and clicking the suggest button will result in a list of suggestions based on the specified products and product versions. At first the results look the same, but the metadata is discoverable by hovering over the provided suggestion.

For my example, I used the string “Menu Item”.  After selecting suggest, hover over the result to see the related metadata, which now includes Product Name and Version.

Translated result Visual Studio 2013 resources

Translated result from Windows 8.1 resources

Don't forget to set the configuration back to the default, or the configuration that works best for you.

Today we released Multilingual App Toolkit v2.2. This release implements feedback received from the Multilingual App Toolkit user voice site. (We love this feedback so please keep it coming!)

The user voice request “Prevent translation getting silently overwritten when source resx file entry is modified” was the biggest change to the toolkit. Previously the approach was to invalidate any translation if the source string was changed. The design was intended to provide a clear model to ensure that modified strings would not be shipped with the previous (and possibly now invalid) translations.  Joost van Schaik wrote a blog that clearly covers both the pros and cons of this approach – it is worth a quick read.

MAT’s new approach is to preserve translations when the original source string is changed. This is a simple enough logic change, but allowing the developer to know which translations are still valid and which ones need reviewing provided an interesting challenge. The solution is to provide notifications that don't block development efforts and are easy to review as well as remove!  Let’s walk through an example to show how this works so you can take advantage of it right away. 

We’ll intentionally add some typos and grammar issues as well as phrases that should be rewritten.  As such, the initial strings look like this:

These errors did not get noticed until after they were translated and imported into the project.  In fact, it was actually the translator that pointed them out.  We now have translations based on our original source strings, including the errors.  We decided to fix the typos and grammar errors as well as update the “Dare to play me again?” text to be a little more, hmm…, user friendly.

When the project is rebuilt, the translations are retained and a warning is produced stating that some existing translations need to be validated against their updated source strings.

Great!  Now we are notified that there are translation concerns, but against what strings?  Well, simply double-clicking the warning will start the Multilingual Editor and open the related XLF file.  When the editor opens this file, it will determine if any strings need to be reviewed, and if found the message tab will be populated with the list of affected resources.  Double-clicking (or right-click and select “Go to…”) on the specific message takes us to the resource in question. Now we can quickly check if this translation is still appropriate for the updated source string. 

However, if not fluent in the target language - Japanese in this case - we can press the suggest button to get new suggestions from the Microsoft Terminology and Microsoft Translator services.  If no satisfactory match is found, the XLF file can be sent back to the translator.  If the translator is using MAT’s editor, they get the same notifications and can quickly make any necessary adjustments.

OK, this is great, but most of the translations are still valid because they were typos that the translator was able to work around.  So how do we quickly remove these warnings? 

For the editor there are a couple of options, but first let’s examine the new comment that was automatically added to the updated resource.  The combination of that comment and a translation state of “Needs review” tells the system that the source string’s translation needs to be reviewed.  Changing the translation state (for example: to ‘Translated’) or removing the comment will disable the indicator that triggers this notification.  Pressing the “Clear’ button in the ‘Translation’ ribbon group will clear the message while retaining the existing translation.  Note: Pressing the ‘Reset’ button will remove the translation and set the translation state to ‘New’.

The quickest way to do this globally in the editor is to select the ‘Filter’ tab, then the ‘Source Changed’ ribbon button.  This will limit the grid view to only the strings that have changed sources with retained translations.  Selecting the grid, pressing Ctrl+A, then clicking the ‘Clear’ ribbon button (on the ‘Home’ tab) will remove the notification for all resources.   Note: Using this filter option is another great way to quickly review the changes.

Of course, pressing ‘Clear’ with a single resource selected will leave the other resource indicators intact for later or external review – even after multiple builds.

This provides great flexibility per language, but what if we have 5+ language files with changes that are only typos or spelling corrections that didn’t invalidate the translations?  To put is simply – we just want the warning messages gone!

Easy! In the Visual Studio IDE, select some or all of the XLF files, then right-click to show the solution menu.  Doing so will expose a new menu item that reads “Clear updated source warnings”.  Selecting this menu will reset all indicators in each of the selected files. Now we’re free to build without receiving the updated source warning messages – unless changes are applied to translated source strings again.

In all fairness, we do want to point out a limitation that still exists.  If you change the resource name (it’s ID), MAT will consider that resource removed and a new resource added.  This is because the ID plays a critical role in the automatic management of the resources.  In this case, the string will need to be retranslated.  If the string was externally translated and the source string has not changed, you can recover the previous translation using the ‘Recycle XLIFF translations…’ menu.  Simply reference the XLIFF file previously sent by the translator to recover that translation.

In addition to the above new functionality, we also added the “Parallel Machine Generated Translations” user voice request.  When selecting multiple XLF files in the IDE, right-click and choose ‘Generate machine translations’.  MAT will list all the files in the dialog box and process the translation requests in parallel. Clicking the red cancel image only cancels that file’s translation operation.  The image will change to a green check mark once the file’s translation operation is completed.  If you click on the green check mark, the completed file is removed from the list.  This can be helpful to view only the remaining operations when translating numerous files at the same time.  Once all the file operations have completed, the dialog will automatically close.

The MAT team believes these community driven improvements will help your efforts to create the best global apps around!  As always, feel free to comment below and make use of the user voice site to request or vote for your favorite MAT feature.

Thank you,

The Multilingual App Toolkit team

The Multilingual App Toolkit enables the addition of 3^rd party translation providers. This allows you to connect the existing workflow provided by the toolkit to your favorite translation service or even create your own in-house translation memory.

To see a sample 3rd party provider, see the TAUS DATA based provider on CodePlex (https://tausdataprovider.codeplex.com/).

The Multilingual App Toolkit v3.0 was release on April 2^nd at the //build 2014 event. This was an exciting release as we were able to coordinate with the //build 2014 and present at the build event! This release expands the scope of the Multilingual App Toolkit as well as implements additional feedback received from the Multilingual App Toolkit user voice site.

The team was able to add support for desktop apps as requested by the community. As a result WPF, WinForm and ASP.NET MVC projects are now supported using the same workflow as that of Store and Phone apps.

Support for the new Universal Apps in Visual Studio 2013 Update 2 RC required some key implementation decisions. One key decision was how enablement should function. After some debate, we decided to enable MAT based on the specific project instead of the shared project. The key reason for this approach was to enable form factor specific translation management.

Another key area of focus was around overall performance improvements. While we still have more work in this area, we believe the current improvements will make a significant difference in your build times. We understand that overall build performance is very important and will continue to work to make it even better.

A subtle, but important improvement was made to the Microsoft Translator provider. As you may know, the Microsoft Translator HUB empowers businesses and communities to build, improve, and deploy customized automatic language translation systems. MAT v3.0 has added support for the HUB. By default it is set to the “tech” category, but can be switched to any category that you may already be using. Simply edit the Microsoft Translator configuration file and change the <category> element to specify your desired category.

The file is located here: %ProgramData%\Multilingual App Toolkit\MicrosoftTranslatorProvider\TranslatorSettings.xml.

…
<ID>B7F979A8-D491-451C-84E8-F0C49BE620E3</ID>
<Category>Tech</Category>
<Languages>
…

The MAT team believes these product and community driven improvements will help your efforts to create the best global apps around!  As always, feel free to comment below and make use of the user voice site to request or vote for your favorite MAT feature.

Summary of key changes in MAT v3.0:

1. Support for Windows Desktop apps (WPF, WinForms and ASP.NET MVC)
2. Store Universal App support
3. Build performance improvements
4. Added MT HUB support for the Microsoft Translator provider.
5. Added editor support for alt+xxxx combinations
6. General bug fixes throughout the product

Thank you,

The Multilingual App Toolkit team
multilingual@microsoft.com

The release of Windows 8.1 added a new feature called app bundles.  App bundles help your customers use less device space when installing your app.  Given device storage limits, this is a very valuable feature.

It seems that the Multilingual App Toolkit does not always play nice with app bundles.  MAT is creating the localized resources which show when run locally, but when the app bundle based package is uploaded to the store the MAT based languages are not registered.

This turned out to be a timing problem related to when MAT’s build step is executed.  The process that creates the app bundle has already completed its build steps before MAT’s build is executed.  Fortunately, we were able to get some help from the app bundle team (thank you!) to get a solution to this problem.  This fix will be included in the next release of MAT.

If you don't want to wait until the next update of MAT, here are two different workarounds that you can use today.

Option 1: Make a quick change to MAT’s .targets file
This option changes the timing of the build step so that MAT runs earlier in the process, ensuring the languages are added before the app bundle process runs.  This is a simple change that will fix the issue, but requires administrator rights.  This is the fix that will ship in the next release.

1. Open notepad using “Run as Administrator”
2. Open “C:\Program Files (x86)\MSBuild\Microsoft\Multilingual App Toolkit\v3.0\Microsoft.Multilingual.PriResources.targets”
3. Modify line 20 from:
     <TargetName="MultilingualAppToolkit"BeforeTargets="_GenerateAppxPackageRecipe">
   to read:
     <TargetName="MultilingualAppToolkit"BeforeTargets="_ValidateAppxManifest">

Note: The above assumes Drive C: is the OS drive. Adjust the file path as necessary.

Option 2: Don't use app bundles
This option will disable the optimization that app bundles provide for your customers.  It is a quick fix and matches the same behavior as Windows 8.0 apps.  It will also work with machines that don't have the manually applied fix from the preferred first option.

Project  Manifest change for option 2

Using either of these options will allow you to workaround this reported issue.

Thank you,

The Multilingual App Toolkit team  
multilingual@microsoft.com

UPDATE: Quick fix - Select MAT's repair option from Programs and Features.

The root issue is that MAT adds required references in the "devenv.exe.config" file that are removed when the Update 2 RTM is installed.  These references are added when MAT is installed and removed when uninstalled. Applying Update 2 RTM overwrites the config file, which causes MAT to misbehave.  The fix is to simply run repair MAT from Programs and Features as this will read the needed references.  Of course, uninstalling and reinstall also works. 

Sorry for this inconvenience.

----

Some users are reporting that after apply Visual Studio 2013 Update 2 RTM with MAT already installed is blocking solution file renames.  This appears to only affect machine that updated from Update 2 RC.  We are looking to the problem, but Joost van Schaik has blogged his solution that claims an uninstall and reinstall of MAT solves the issue.  Here is a copy of the blogs contents for quick reference. 

“A couple of people – me included – have been suffering from the fact that, after they applied Visual Studio 2013 update 2, it became impossible to rename files from Visual Studio. This highly annoying problem was occurring only on my Surface Pro, and not my Core i7 desktop. The difference was that the Surface Pro at one point ran the public RC of VS2013.2, and the desktop did not. Even totally deleting VS2013 and reinstalling it did not work

Today I got the golden tip from a fellow name Chung Bill (unfortunately I know only his name and e-mail address): apparently, if you did follow the upgrade path from public RC to RTM and you have the Multilingual Application Toolkit (MAT) installed, something goes wrong. The solution is also very simple: uninstall the MAT, then reinstall it again. If you then fire up Visual Studio 2013 again, renaming files works again. Note that you have to uninstall it from Windows, using Programs and Features, not from inside Visual Studio.

Somewhere in the intricate woven components of the MAT and VS2013.2 something apparently went wrong. But fixing it ain't rocket science. No harm done. Nothing broke permanently ;-).“
The original blog is located here: Fix for being unable to rename files after applying Visual Studio 2013 update 2

We will continue to look into this issue to ensure that everyone is unblock as soon as possible.

Thank you,
The Multilingual App Toolkit team  
multilingual@microsoft.com

Today we released the Multilingual App Toolkit v3.1. This release provides several key fixes as well as new and improved features.  Please note that due to updates to the setup process, you will need to perform a one time uninstall of MAT v3.0 or earlier before installing v3.1.

Visual Studio Online builds
While the Multilingual App Toolkit has supported local TFS builds for some time, building online was not available. The team took up the challenge to not only support v3.1 for online builds, but to enabled MAT v2.2 or greater as well. If you have an existing MAT v2.2 or greater project using Visual Studio Online, you can simply enable online builds and it will just work. For more information on Visual Studio Online builds, please see: http://www.visualstudio.com/en-us/products/what-is-visual-studio-online-vs

Expanded import, export and recycling
Round-tripping of resources with friends, family and professional translators has been supported since the first release of MAT. Soon thereafter, a recycling option was added so you could ‘import’ translations from other unrelated projects (or share between universal apps) without the need to send out similar resources for translation for a second (or third or fourth) time. In this release, we have merged the Import and Recycling options into the same user interface to save you some steps.

One of the more common requests has been to extend this model to support CSV files as well. I’m happy to announce that CSV files are now supported. The export steps are the same as in previous releases, except for a new drop down that allows you to choose between .XLF and .CSV output formats.

Importing provides the ability to import multiple files from multiple locations. Be sure to select the “Enable resource recycling” option if you are importing non-related projects. We’ll dive deeper into the Exporting, Importing and Recycling features in a future blog.

Improved translation and suggestion results
In previous versions the translation providers would return a confidence level of either 50% or 100%. This did not provide for any automatic differentiation between results based on case or punctuation differences. This made it difficult to easily select the ‘best’ suggestion as it was not guaranteed to be the top option.

To help simplify picking the best recommended translation, the provider model and each provider differentiates by tuning the confidence level value. This ensures the preferred recommendation is always at the top of the suggestion list as well as the result you get when you select Translate All (or Generate Translations inside Visual Studio).

And of course, no release is complete without addressing those little critters that sometimes make it into the product. Here is a list of the key fixes.

• Enabled Windows 7 + Visual Studio 2013 installation support. To be honest, this was just an embarrassing miss for v3.0
• Improved and added support for Visual Studio Express, including Windows, Desktop and Web editions
• Removed dependencies on the Visual Studio .config files to avoid future issues (see: Rename is disabled in Visual Studio with MAT)
• Incorporated fix to ensure that the Store always showed the full list of the app’s languages (See: Store is not showing my languages)
• Added better validation of translation result to prevent invalid XLIFF results
• Fixed build failure if “####” was in the source or target resource string
• Fixed offline first run issues with the language portal provider
• Fixed support for Windows Phone (Sliverlight) projects in Visual Studio 2013 Express for Windows
• Fixed support for Class Libraries, Windows Runtime components, as well as improved support for other project types
• Added Microsoft Translation provider support for language neutral codes (ja, fr, it, etc)
• Fixed loss of existing translation from first RESX in the project when converting from RESX to XLF files

The team really focused on key features as well as addressing both reported and non-reported issues in this release. We are pretty excited about the features as well as the overall level of product improvement in v3.1. We hope you will enjoy the features and fixes in this release of the Multilingual App Toolkit.

Thank you,
The Multilingual App Toolkit team
multilingual@microsoft.com
User voice site: http://aka.ms/matvoice

Today the Microsoft Terminology team announced updates to the Microsoft Terminology API.  This update expands the number of language combinations possible and provides more precise translation results.

You are probably aware that the Multilingual App Toolkit uses a language provider model to enable translation services for the Multilingual Editor and Visual Studio integration. The Multilingual App Toolkit ships with two language service providers, the Language Portal provider and the Microsoft Translation provider, which are accessed using this model.

The Language Portal provider uses Microsoft’s Terminology Service API when requesting translations.  This enables any improvements in the service to be reflected immediately when exposed via the Multilingual App Toolkit.

Palle and the Terminology API team have been committed to supporting expanded language combinations for some time now. In fact, the first version of the API included a method  to indicate the service’s language capability so changes could be dynamically enabled in the future.

GetCapability() method from the Terminology API documentation

With today’s announcement the Multilingual App Toolkit will automatically use the Language Portal provider’s expanded language support when accessing the translation service.  This means that if you have a project, for example, that uses Japanese as the source language, the expanded list of supported languages will be automatically indicated in MAT’s “Add translation languages…” dialog.

Japanese as the project’s source language

This will also show up in the Multilingual Editor as it is automatically enabled based on the service’s expanded support.

Japanese to German suggestion example

Note: The Language Portal provider caches configuration settings for up to 30 days. Until the cache is refreshed, the updated language capabilities will not be reflected by the provider. To force a refresh, simply delete the cache file located at "%ProgramData%\Multilingual App Toolkit\MicrosoftLanguagePortalProvider\LanguagePortal.cache".

The Multilingual App Toolkit team is excited about the expanded language support and hope that you will find it useful when translating your apps.

Thank you,
The Multilingual App Toolkit team
multilingual@microsoft.com
User voice site: http://aka.ms/matvoice

Recently I was contacted via http://aka.ms/matvoice by a developer using MAT with a question.  “Why are the results from the Microsoft Translator Provider in MAT different than those from http://www.bing.com/translator?  Well, that is a great question.  Let me answer the question by showing some of the configuration options available for that provider.

The quick answer: 

The release of MAT v3.0 added support for Microsoft Translator’s Hub (See: http://blogs.msdn.com/b/matdev/archive/2014/04/14/announcing-multilingual-app-toolkit-v3-0.aspx for specifics).  MAT uses the ‘Tech’ category by default as this is geared more towards software terms.  The Translator website uses the ‘General’ category when processing the requests.  The good news is that this is configurable if the Tech category does not fit your needs. 

Here is how to configure MAT to match that of the Translator website.

1. Open Notepad as Administrator
2. Open MAT’s Microsoft Translator configuration file . It is located at "C:\ProgramData\Multilingual App Toolkit\MicrosoftTranslatorProvider\TranslatorSettings.xml"
3. Change "<Category>Tech</Category>" to "<Category>General</Category>"
4. Save the file

Note:
Please adjust the above path If your %ProgramData% environment is different. 
Be sure to restart the Editor (or VS) to use the updated configuration.

Since we are here, let’s discuss some of the other options as well…

Here is a snippet of the file:
<Provider>
  <ID>B7F979A8-D491-451C-84E8-F0C49BE620E3</ID>
  <Category>Tech</Category>
  <Protocol>HTTP</Protocol>
  <Languages>
    <Language>ar</Language>
    <Language>ar-ae</Language>
    <Language>ar-bh</Language>
    <Language>ar-dz</Language>
    …
  </Languages>
</Provider >

<Category> element

As indicated above, the <Category> element is used to add Microsoft Translator’s Hub functionality into MAT’s translation services.  However, this is not limited to the General and Tech categories.  If you have a custom Hub (or your friend does), you can set the <Category> value to their Hub and take advantage of their customized translations directly within MAT.

<Protocol> element

Looking at the configuration file, you probably noticed the <Protocol> element.  The Microsoft Translator APIs allow for translation requests using HTTPS.  By default, this is set to HTTP – as indicated by the <Protocol> value.  Changing this to HTTPS will access the Microsoft Translator Service over the SSL protocol.

<Language> elements

When you look at the <language> elements, you might be asking yourself “Why we define all the region languages separately”?  The answer is that the Microsoft Translator service uses a language neutral approach to generating translations.  An example is French France which is slightly different than French Canadian, but most of the words or phrases are common between both.  As such, to enable the supported languages and indicators, we map the Microsoft Translator neutral languages (FR) to the language specific codes (fr-FR, fr-CA, etc.)  This allows us (and you) to fine tune the support to ensure the alignment is as you desire.

As you can tell, the configuration file is pretty straightforward.  I hope this helps you understand some of the options that you have when using MAT and the Microsoft Translator Provider. 

Thank you,
The Multilingual App Toolkit team
multilingual@microsoft.com
User voice site: http://aka.ms/matvoice

The Multilingual App Toolkit v4.0 Technical Preview adds support for VS + Xamarin based iOS and Android projects.  We are super excited (just had to say it) about adding MAT’s localization workflow for developers using Visual Studio and Xamarin to create great cross-platform apps! You can download it here

I am fortunate enough to be in attendance at Xamarin Evolve 2014 this week. On Monday I attended a training session presented by Craig Dunn on Xamarin localization.  Craig did a great job covering localization in general, then focused on iOS and Android projects specifics as well as RESX with Xamarin Forms.  Craig’s demo code is available on GitHub.  So of course I wanted to see how the v4.0 technical preview would handle the code.  The demo is pre-populated with the target RESX files, so I simply removed them before using MAT v4.0 preview to add Japanese (JA) and Arabic (AR).  After generating translating using the default translation providers.  As you can tell from the images below everything worked as expected.

The product still works the same - just add languages and let MAT manage the target resources and translation services, etc.  In fact if you never used MAT before but watched some of the videos (http://aka.ms/matphone or http://aka.ms/matcodechat), you might not even notice anything different in the basic workflow.

To enable Xamarin Support we have made some key changes – including some breaking ones.  We believe these changes will improve the experience for all project types and this was the right time to implement the changes.  The changes are based on user feedback as well as some technical design improvements to make management of projects easier and less intrusive to build systems.

As a result, v4.0 is not compatible with previous version.  The addition of an upgrade feature will be available in a future build but is not included in this release.  To ensure the technical preview is not accidently installed and run against v3.x projects we have added some blocks to safeguard production machines and projects. 

One such safeguard is to block setup on machines with previous versions of MAT still installed.  Once MAT v4.0 Technical Preview is installed, projects that were enabled with v3.x will fail to open to help protect the 3.x based projects.  As you can see from the message, we have documented how to manually apply an upgrade if you want to test existing projects.  Running in production environments is not recommend and it is strongly recommend that backup your projects before attempting any manual upgrades.   Please see http://aka.ms/matpreview for the download information, latest FAQ and articles, including the manual upgrade article.

Since this is a Technical Preview, it will have areas that are unfinished, just don't work as expected, and in a few cases - like 3.1 to 4.0 updates - just don’t exist.  However, your input is important and we wanted to get this preview in your hands early so we could make changes as needed.

For those you use that use MAT daily, here is the short list of changes that will be the most interesting:

Pseudo language is not automatically added when the project is enabled.
The first thing that you will notice is that Pseudo XLF file is not automatically added.  The side effect is that your project will not have any noticeable changes when enabled.   However, if you right click the project (or solution), you will see the familiar ‘Add Translation Languages’ menu.  All the languages are still available, including Pseudo, but the supported language sets vary between the different platforms.  Be sure to check each platform’s language support. Adding an unsupported language can case a build break. If this happens, simply removing the language from the specific platform will get you going again.

Restructuring of the XLIFF project management to be consistent for every project
If you’ve created a Windows Store, Phone or Desktop apps using MAT, you know that some projects use the MultilingualResources folder and others do not.  Going forward, all projects will use the MultilingualResources folder to store the project’s based XLF files.  This will provide a consistent location for projects, including the newly supported VS + Xamarin based projects.

Restructuring of the XLIFF file’s contents
Prior to the preview, MAT would create a separate XLF files for each resource file in a RESX based project, but a single XLF file for PRI based projects regardless of the number of native source resource files.  If your RESX based project only contained one resource file like mine do, this change is not as noticeable.  However, if you use multiple RESX files, you will notice the difference right away.  XLIFF supports multiple <file> elements, but we did not have a strong need of this capability.  Storing all the resources in a single XLF file has change this.  Now, each native source file (AppResources.resx and ErrorResources.resx) are store in the XLF file with unique file nodes.

No longer dependent on platform specific build integration
Build integration have been a challenge with every release.  This is evident by looking at some of the workaround blogs that we have posted.  Not being dependent on platform specific build integration lets the native compilers do all the work without MAT getting in the way.  It also allows MAT to not break when in Xamarin Studio’s IDE.  Being outside of Visual Studio, you don't get the benefit of MAT’s workflow, but you will still get multilingual builds and that’s pretty cool!

Recursive and multi-select project management
We have enabled MAT’s menus to work recursively from the selected node (or nodes).  So, if you Enable while the solution is selected, all supported projects will be enabled.  This also works for other menus like Generate Machine Translations, etc. 

Reading and Writing of Native resource formats
With the Technical preview, the workflow reads the native source resource files to populate the XLF file and then creates the native target resource files.  Windows Phones and Desktop apps are familiar with this models, but this is a big change for Windows Store apps as MAT never created the native resw or resjson files until now.  This will help with understanding the result for the target files as well as no longer calling platform specific build integrations.

Download the Technical Preview
We created a landing page at http://aka.ms/matpreview that contains links to the install point as well as the feedback and articles.  The technical preview is hosted via Visual Studio Gallery so you will automatically get update notifications one it is installed.

If you are at Xamarin Evolve 2014, be sure to look me up.

Cameron
@CameronLerum
multilingual@microsoft.com
User voice site: http://aka.ms/matvoice

The Multilingual App Toolkit v4.0 Technical Preview Update 1 is available as of this morning.  The release continues to support Xamarin (Initial Announcement), bringing MAT’s streamlined localization workflow and services to Windows, iOS and Android platforms.

This update contains fixes as well as suggestions sent by early adopter both via email to multilingual@microsoft.com and MAT’s user voice site. We love hearing your feedback so THANK YOU and please keep it coming.

One visible change is in the ‘Add translation languages…’ dialog.  Previously Hindi (and other languages) were only selectable by the language and region code (hi-IN in this example).  As you can see in the image below, Hindi is now selectable at the root language level as well.  This enables easy selection for platforms that don’t support region, or if you are just targeting the root language in your app.

To support this change, the translation providers where enhanced to work with the root language as well.  In this example, if you select Hindi (‘HI’), the translation providers will ask the related service for hi-IN based translations.  This small change allows the continued use of the translation services when selecting a root language by mapping that root language to the specific language.  In most cases this mapping will provide the desired results.  This is configurable in case you want to change the mapping, but that’s the content for another blog.

The list of major fixes are listed via the v4.0 Technical Preview article on the MAT user voice site.  Please refer to http://aka.ms/matpreview for additional details and download links.  Of course, if you already have MAT v4.0 installed, Visual Studio will let you know to install the update.

Cameron
@CameronLerum
multilingual@microsoft.com
User voice site: http://aka.ms/matvoice

Today we released update 1 for the Multilingual App Toolkit v3.1.  This update delivers enhancement to the original v3.1 release to help make your localization efforts even better by addressing developer reported issues. 

Here is a quote from Jesper Holmberg’s blog: "Overlocalization" happens when you translate something that should not have been translated. Overlocalization can give all kinds of interesting symptoms and often causes problems that are tricky to diagnose.

Well that is exactly what MAT was doing to WinForm apps.  Marking a Form as localizable enable controls to store the localizable data in the related RESX file.  However, non-localizable control information is also placed in the RESX file.  MAT was capturing both the localizable and non-localizable information and adding it to the XLIFF files.  This resulted in “all kinds of interesting symptoms” was definitely “cause problems” unless the developer was very careful during the localization of the XLIFF file.  This update ignores the non-localizable data, making WinForm localization with MAT a lot easier.

 
Another reported WinForm issue was that using the Publishing options would result in build breaks. If you set the publishing language, the build would work, but then you were stuck with only that language.  Obviously, not a very acceptable workaround. This has been fixed with this update as well.

Ever have a problem getting MAT to play nice when a project has NuGet Package Restore option enabled?  I never did – until one day I got a report of it happening.  The problem only happens if MAT was enabled after the project is enabled to auto-download missing packages.   I never saw this bug because the first thing I do on all my projects is enable MAT :-)

Here is the list of fixes included in this update:

• Added support for Visual Studio 2015 Preview
• Windows Forms over-localization reported issue
• Windows Forms publishing issue
• Language Portal Provider refresh to use the updated Terminology service API
• Fixed an editor crash if the same file was loaded in two editor instances while one was translating and the other saved the XLIFF file
• Update the Add translation languages dialog to allow resize to make pick languages easier
• Fix the conflict with NuGet restore and MAT enablement configuration

The majority of these fixes are the direct result of developers connecting with the MAT team either via email, blog comments or MAT’s User Voice site.  Thank you for the feedback that resulted in this update and please keep them coming!

Thank you,
The Multilingual App Toolkit team
multilingual@microsoft.com
User voice site: http://aka.ms/matvoice
v4.0 Technical Preview: http://aka.ms/matpreview

The Multilingual App Toolkit v4.0 Technical Preview Update 2 is available (v4.0.1246.0).  The release continues to support Xamarin (Initial Announcement), bringing MAT’s streamlined localization workflow and services to Windows, iOS and Android platforms.

This update adds additional fixes and incorporates suggestions sent by early adopter both via email to multilingual@microsoft.com and MAT’s user voice site. Your feedback is key in helping the MAT team deliver the localization workflow necessary to quickly get your apps global.  Thank you for all the feedback and please keep it coming.

User feedback and a strong desire to not contribute to menu bloat, MAT’s menus items have been incorporated in an easy to discover “Multilingual App Toolkit” menu. 

The list of key fixes are listed on the v4.0 Technical Preview article on the our user voice site.  Please refer to http://aka.ms/matpreview for additional details and download links.  Of course, if you already have MAT v4.0 installed, Visual Studio will let you know that it’s time to install the update.

Thank you,
The Multilingual App Toolkit team
multilingual@microsoft.com
User voice site: http://aka.ms/matvoice
v4.0 Technical Preview: http://aka.ms/matpreview

The Multilingual App Toolkit v4.0 Technical Preview Update 3 is available today (v4.0.1262.0).  The release continues to support Xamarin (Initial Announcement), bringing MAT’s streamlined localization workflow and services to Windows, iOS and Android platforms.

This update adds support for Windows 10 Technical Preview Tools, support for Windows Store resource qualifiers, and exposes WinForm control values such as size and location.

Universal App Platform

Store resource qualifiers

WinForm Size, Location, and TabIndex

The list of key fixes are listed on the v4.0 Technical Preview article on our user voice site.  Please refer to http://aka.ms/matpreview for additional details and download links.  Of course, if you already have MAT v4.0 installed, Visual Studio will let you know that it’s time to install the update.

Thank you,
The Multilingual App Toolkit team
multilingual@microsoft.com
User voice site: http://aka.ms/matvoice
v4.0 Technical Preview: http://aka.ms/matpreview

Having received several requests for ‘how to’ videos on the Multilingual App Toolkit around specific feature and practices, we are working on creating a series of videos targeting specific features and best practices when using the Multilingual App Toolkit.  These videos will included a range of topics on localization and globalization, tricks and tips, new and updated feature previews as well a mixing in some guest speakers and experts on both Windows and cross-platform app development.

While the series is being created, I thought it would be appropriate to mark the one month since //Build 2015 with the links to the Windows Universal App and Xamarin cross-platform videos the MAT team created for the //Build event.  Enjoy!

Thank you,
The Multilingual App Toolkit team
multilingual@microsoft.com
User voice site: http://aka.ms/matvoice
v4.0 Technical Preview: http://aka.ms/matpreview

The Multilingual App Toolkit v4.0 TP Update 4 (v4.0.1331.0*) is available.  This update delivers new features as well as several key bug fixes for Windows and Xamarin based projects.

Export filtering by state support
This update includes a key new feature that allows you to control what resource are exported for translations.  Until now, every export included all resources, regardless of the translation or localizability state.  This created the possibility for translator to inadvertently change resources that were already fully translated.  Combining this new feature with the several import fixes reported by customers makes this a great additional the MAT’s localization workflow.

Export, Import and Recycling support for XLIFF 2.0
The XLIFF 2.0 is the latest approved standard by the OASIS membership.  This release marks MAT’s initial support for XLIFF 2.0 via exports, imports and recycling.  Supporting XLIFF 1.2 and 2.0 provides greater flexibility when working with translation services and professionals. 

Jan Nelson announced MAT’s initial XLIFF 2.0 support at the Riga Summit 2015 and Kevin O’Donnell recently demonstrated Microsoft’s internal use of XLIFF 2.0 at LocWorld in Berlin, Germany.  This week also marks the official announcement of Microsoft’s intention to release the .NET based XLIFF 2.0 Object Model as open source.  We are pretty excited about the XLIFF 2.0 OM effort!

Improved project management of resource file
Redesigning the core operational architecture of MAT has been a huge undertaking, but is paying off in our ability to support multiple project types and cross-platform projects.  Making strategic decisions regarding ‘must have’ and ‘future support’ are critical to shipping any product and MAT is no exception to this reality.  One such trade-off is the level of project management support for added new resource files after adding MAT managed language files. 

The decision was to target the single resource file experiences initially.  Since most modern app models favor use a single resource file, this allowed us to focus on delivering the core workflow experience for many projects while enabling support for Xamarin based cross-platform efforts. 

Unfortunately this meant that WinForms and ASP.Net customers needed to apply the largest number of workarounds as every new form creates a new RESX file.  The improvements in the project management in this release will allow seamless addition of new resource files in your project.  While we have more project management work items in our backlog, this release provides support for dynamically adding new resource files to your project after MAT managed language have been added.

As always, the list of key fixes are listed on the v4.0 Technical Preview article on our user voice site.  Please refer to http://aka.ms/matpreview for additional details and download links.  If you already have MAT v4.0 installed, watch for the notice to install the update.

* We did a quick update as the XLIFF 2.0 OM in 4.0.1330.0 was not the right version.  XLIFF 2.0 functionality is working as planned with 4.0.1331.0.

Thank you,
The Multilingual App Toolkit team
multilingual@microsoft.com
User voice site: http://aka.ms/matvoice
v4.0 Technical Preview: http://aka.ms/matpreview

The Multilingual App Toolkit v4.0 Beta release (v4.0.1391.0) is available.  This release rounds out the support for Windows 10 apps by adding support for C++ and JavaScript projects as well as continued support for C# and VB projects.

Thank You for installing the Technical Preview releases
Key fixes in this release are the direct result of you, the community, using and providing Technical Preview bugs reports and feature requests.  While internally we use MAT daily, your real-world and numerous project types provide the best insight. Thank you for all the insights and please keep them coming!

Starting the editor and crazy XLF file sizes
The Multilingual Editor is the toolkit’s standard-alone editor that supports editing XLIFF 1.2 files with fully integrated translation services.  While this provides the ability for non-VS users to support your localization efforts, it can cause a delay before seeing the Editor’s UI when started from within Visual Studio (or if you have a crazy number of resources, and you know who you are… ). 

To help, we have added a Splash Screen with a progress indicator.  If you did not mean to open the XLF file, you can simply press Alt-F4 to safely close the editor while on the opening screen.

Those little annoyances
The Editor has several fixes that help during your translation work.  One issue that is very annoying is pasting text from a browser or other file and having a unexpected newline added. I heard about this a lot in the last week or so.  I’m glad to report it is fixed with this release.

Those bigger annoyances
The ability to Export and Importing translations to and from friends, family, professional translation services and translation venders is a key step in distributing your translation workflow as well as managing your translation quality. With v4.0, it is also the way to convert v3.1 projects to v4.0 based projects while keeping your existing translations. (Yes, we are working on the automatic update feature – I promise!)

One of the discovered bugs was related to re-importing of translations. For example, if you sent your XLF file to a vendor and then imported the results, life was good. But if the vendor then sent you a fix to a translation, the second import would report ‘0 resources imported’.  This happens due to bug that skips the updated translation because it was already set to the same state as the one in your project’s XLF file.  The fix was to correct the process to re-import the same state translations so ensure you have the latest translation.

Fixes and updates
This Beta release is all about applying fixes and updates necessary on our path to production quality.  Fixes around the resource and XLF file processing as well as the import functionality is key to the enabling v3.1 to v4.0 update scenarios.  If you are running a previous v4.0 build, this should make your life even better.  If not, now would be a great time to start checking out the benefits of v4.0!

As always, the list of key fixes are listed on the v4.0 based articles on our user voice site.  Please refer to http://aka.ms/matpreview for additional details and download links.  If you already have MAT v4.0 installed, watch for the notice to install the update. If not, you can install it directly from the Visual Studio Gallery extension download page.

Thank you,
The Multilingual App Toolkit team
multilingual@microsoft.com
User voice site: http://aka.ms/matvoice
v4.0 Technical Preview: http://aka.ms/matpreview

Hopefully you already know that MAT supports the ability to create 3rd party translation providers.  Well, a team at Microsoft decided to see what they could do to provide developers with a local translation service. 

LocShare MAT Technical Preview is the result and it is pretty cool.

‘LocShare MAT’ provides developers (and localizers) with a translation database and MAT based translation provider to allow seamless retrieval of imported data from your private translation memory. Setup adds the LocShare provider into MAT’s provider list automatically. 

All you need to do is populate the TM with your XLF based translations and your good to go.

By default, the LocShare provider is the preferred provider so your imported resources are selected first.  Since the TM is local to your machine, it even works when you are offline!

The direct link to the Visual Studio Galley download page is: https://visualstudiogallery.msdn.microsoft.com/3500d116-cd21-4e89-bb1b-cd3d26770b58

Great job LocShare team!

Thank you,
The Multilingual App Toolkit team
multilingual@microsoft.com
User voice site: http://aka.ms/matvoice
v4.0 Beta: http://aka.ms/matpreview

The Microsoft Language Portal team recently updated their service to include Microsoft’s professionally translated strings from Windows 10, Windows Mobile 10, Universal Store, Office 2016, Xbox One and more.

Palle Petersen covers all the details in his recent Microsoft Language Portal updated with Windows 10 translations blog.

While MAT is already picking up these new translations automatically, the default is to return results from all of Microsoft’s released product translations. 

The Getting the most out of MAT’s Language Portal provider blog covers all the specific details, but I wanted to call out the specific configuration related to Palle’s announcement – specifically how to limit the results to these recent translations.

For this blog, we are going to specifically limit results to Windows 10, Windows Mobile 10, Universal Store and Office for Mac 2016.  We will also enable the metadata feature to display the translation’s product and version.

Here are the abbreviated steps. Please review the previous post if you need specific step by step details.

1. Open the Language Portal configuration file as an Administrator.
2. Enable displaying of the metadata by changing <Suggestion><UniqueResults> setting from True to False.  (The default of True avoids getting the same translation across the different versions of the same product but blocks the metadata.  But since we are limiting the product scope, we do want to see the metadata when we get a suggestion.
3. Change the <Products /> node to list the different Products and versions. The change will looks like this:
   <Products>
     <Product Name=”Windows”>
       <Version Value=”10”/>
     </Product>
      <Product Name=”Windows Mobile”>
       <Version Value=”10”/>
     </Product>
     <Product Name=”Universal Store”/>
     <Product Name=”Office for Mac”>
       <Version Value=”2016”/>
     </Product>
   </Products>
4. Save the file

Create a MAT enabled project and add the string “Comments:”.  For this example I’ve add German-Germany (de-DE) as my target language.  When I open the German.XLF file in the editor and get a suggestion for “Comments:”, the first result is a German Translation used in the Windows Universal Store.  Other translations are from Office for Mac 2016 and Windows 10. 

Notes:
Hovering the mouse over the translation displays the metadata, which contains the product name and version. 

You probably noticed that I did not specify a version element for “Universal Store”.  Since there is only one version (2015), there was no need to limit it to a specific version.

I hope you enjoyed this view into the many feature of the Language Portal. 

Also - Don't forget to set the configuration back to the defaults, or the configuration that works best for you. 

Thank you,
The Multilingual App Toolkit team
multilingual@microsoft.com
User voice site: http://aka.ms/matvoice
v4.0 Beta: http://aka.ms/matpreview
Twitter: @CameronLerum