Selected Customers

Specials run until 8/10/2021

Offers are for commercial and industrial customers only.
All prices are net.

Complete Price Sheet.

Not sure which edition is the right one? Visit our Edition Comparison

Update to Version 4

Sisulizer version 4 is a paid update recommended for all Sisulizer customers.

Update to Sisulizer 4

Still using Sisulizer 3 or Sisulizer 1.x/2008/2010?

Time to update to version 4 now and profit from all new features in version 4.

Software Localization News

Version 4 Build 374 released


The new build comes with many new features. [...]



Tutorials updated [...]

.NET Support updated


New in May 2018: [...]

Sisulizer 4 Build 366


Build 366 - support for Visual Studio 2017 [...]

10 Years Sisulizer


Celebrate and save Big. [...]

Our customers use Sisulizer...

to reach international customers with software in their language

to localize their in-house software in the international subsidiaries

to build multilingual custom software for their clients' enterprises

as Localization Service Providers because it is the localization tool of their customers

to localize software at Government Agencies

To teach software localization at Universities

for software localization on Electronic Devices

To translate software for Biomedical Hardware

to localize software in the Mining Industry

to create multilingual software for Mechanical Engineering


.NET's satellite assemblies and runtime language change

.NET has a build in feature using satellite assemby files. They are resource file that contain localized forms and resource data. When a .NET applications starts .NET runtime is looking for a possible satellite assembly file from the sub directories of that directory where the original file is located. If .NET runtime can find a satellite assembly file it uses resources of the satellite assembly file instead of the original assembly file.

Sisulizer extends .NET framework by providing classes to performs runtime language change. This makes it possible to start application in one language and later change the language on run time as many times as possible. Sisulizer's runtime language change is very fast and flicker free.

Initial language

When .NET runtime starts an application it looks for a possible satellite assembly file. A satellite assembly file is a resource only assembly file that has .resources.dll extension instead of .exe ir .dll (if the main assembly is a library). Satellite assembly files always locate on a language specific sub directory of the applciation's main directory. If application file is Converter.exe then the Japanese satellite assembly file is ja\Converter.resources.dll.

The file .NET runtime looks for depends on the user interface language of your operating system. If you have an English (US) OS the runtime will look satellite assembly file from en-US or en. On Finnish OS the runtime looks for fi-FI or fi. This method to select is a bit limited because the user has not control over the initial language except installing a multilingual OS or reinstall OS with different language. This seems way too heavy to just select different initial language for your application. Fortunately there is easier way. By adding just one line of code to your applciation you can the initial language selection smarter.

Thread.CurrentThread.CurrentUICulture = CultureInfo.CurrentCulture;

This line of C# code makes .NET runtime to look for satellite assembly file that matched the default locale of the user. Not the user intrface language of the operating system itself. Changing the default locale of the user is easy using the control panel. You can read more about how to make the application to use the user default language.

Runtime language change

Note! Runtime language change works only if you use Windows Forms. It does not support WPF.

Sisulizer contains functions that let you change the language of .NET application on run time. <sldir>\NET contains the source code of C# library project that contains the classes. If you compile this project you will have Sisulizer.dll library assembly file. It contains all the classes.

Sisulizer.Translator is a class that translates forms. Sisulizer.Resources ia a class works with satellite assembly files. Finally Sisulizer.SelectLanguage contains a dialog that show availabel languages and lets the use to select a new language.

Adding runtime language change is very easy. At minimum it only requires that you add one line of code into your application.

private void languageToolStripMenuItem_Click(object sender, EventArgs e)

It is simple like that!

Form translating requires more explanation. Sisulizer.SelectLanguage.Select calls Sisulizer.Resources.SetUILanguage function that performs the resource loading and calls Sisulizer.Translator.Translate function that translates existing forms. It is very important to understand what happens here. Sisulizer reads the localized form data from satellite assembly file. This means that all the component and properties of the form that exist in the localized form data will be assigned. However if you changed any property value from code, for example in Load or Show events, the property values do not change. If these so called dynamic property values need to be localized you have to set them again after language change. Let's have an example.

<sldir>\NET\CSharp\Select contains a simple application using runtime language change. Both Form1_Load and Form1_Shown events set property values or use data that is locale depend. Form1_Load set the initial position of the main form and updates the caption of the main form.

private void Form1_Load(object sender, EventArgs e)
  Left = 0;
  Top = 0;
  Width = Screen.PrimaryScreen.WorkingArea.Width;
  Height = Screen.PrimaryScreen.WorkingArea.Height;
  Text = Properties.Resources.Loading;

Form1_Shown sets the document URL using a resource string.

private void Form1_Shown(object sender, EventArgs e)
  webBrowser1.Url = new Uri("http://" + Properties.Resources.Url);

webBrowser1_DocumentCompleted that is called after document is loaded sets the caption again, sets the panel and finally enabled the language menu.

private void webBrowser1_DocumentCompleted(object sender, WebBrowserDocumentCompletedEventArgs e)
  Text = String.Format(Properties.Resources.Caption, Properties.Resources.Url);
  toolStripStatusLabel1.Text = Text;
  languageToolStripMenuItem.Enabled = true;

When application has loaded the document its state (= values of properties) is not the same as in design time. The design time state is the state that exist in the .resx file (e.g. form data). The caption of the main form, document URL, and language menu state have been changed on run time. When a language change occurs Sisulizer automatically updates the static properties (e.g. those that exist on the form data) but does not change these dynamic properties. This is why you have to set them again. The following code changes the language and translates dynamic properties.

private void languageToolStripMenuItem_Click(object sender, EventArgs e)
  if (SelectLanguage.Select("en"))
    Form1_Load(this, new EventArgs());
    Form1_Shown(this, new EventArgs());

SelectLanguage.Select changes the language, Form1_Load and Form1_Shown resets the dynamic properties using the new language. There is no need to call webBrowser1_DocumentCompleted because webBrowser1 is calling it automatically after setting Url in Form1_Shown.

Now our application works. After language change you have to remember to resets any dynamic properties. This might seem a bit complicated but in most cases your language change routine is on the main menu or on the main form. In a situation like that you only have one form existing at that moment so you only have to take care if resetting dynamic properties of that form. All the other forms that you create after language change will automatically use the new language.

<sldir>\NET\CSharp\LangChange is another sample application that uses it's own user interface to select the new language instead of Sisulizer's select language dialog.