Locale_Remulator for 64-bit Windows Applications
System Region and Language Simulator.
At a glance
- What is it?
- InWILL/Locale_Remulator is a Windows system region and language simulator built with Detours and SharpShell. It targets applications that need a different regional environment, including 64-bit executables, through configurable shortcuts or a context menu.
- Who is it for?
- Adopt Locale_Remulator when you need per-application regional simulation on Windows and can accept its Windows-only, .NET Framework 4.8, and Visual C++ runtime requirements. Do not adopt it as a general-purpose Linux or cross-platform localization tool, since the documented installation and deployment path is Windows-specific.
- Can I use it commercially?
- Yes, with conditions. LGPL-3.0 is a weak copyleft licence: you can use it inside commercial and closed-source software, but if you distribute changes to its own files, you must publish those changes under the same licence.
- Is it still maintained?
- Yes. The repository last received commits 88 days ago.
- What is it written in?
- Mainly C++, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on October 23, 2026, and from our analysis. They are not legal advice.
Editorial analysis
Why Locale_Remulator Exists for 64-bit Windows Software
Locale_Remulator addresses the need to run a selected Windows application as though the system uses another region or language setting. The README describes it as a "System Region and Language Simulator" and explains that it was created because Locale-Emulator does not support 64-bit applications. The stated motivation was support for Japan MapleStory becoming 64-bit, so the project has a narrow but concrete target: applications whose behavior depends on regional or language-related Windows APIs.
This is not a general translation editor. The documented workflow changes the environment used to launch an application, rather than translating the application's interface or resources. Locale_Remulator is therefore most relevant to software such as games and other region-sensitive Windows programs. The README does not claim that every application can be simulated successfully, and it does not document a list of supported applications. A prospective user should therefore treat it as a configurable launcher and API-hook layer, not as a guarantee that a particular executable will behave correctly.
The project is aimed at Windows users who need repeatable control over the locale configuration for one executable. Its two documented entry points are a right-click menu and a generated shortcut. That design keeps the region choice attached to the application launch rather than requiring the user to change the entire system configuration each time.
Detours Hooking and the Locale_Remulator Runtime Layout
Locale_Remulator is based on Microsoft Detours, which the README identifies as the component used to hook ANSI and Unicode functions. Locale_Remulator also uses SharpShell to generate the right-click menu. The repository layout separates these responsibilities into directories named `LRHook`, `LRInstaller`, `LREditor`, `LRProc`, and `LRSubMenu`, alongside shared code in `LRCommonLibrary`. This separation gives the project a clear Windows integration model: hook libraries, installation and registration tools, configuration or launch tooling, and menu components are distinct parts of the solution.
The deployment instructions state that the solution platform should be selected as x86 or x64. The listed runtime files include `LRHookx32.dll` and `LRHookx64.dll`, which correspond to the two supported process architectures. The presence of both libraries means an installation or deployment can serve applications with different executable architectures, although the README does not explain the internal selection logic. It also does not document how a particular configuration is encoded in the editor or how the hook intercepts and rewrites locale-related calls.
The deployment file list is itself an important operational constraint. Locale_Remulator expects `LREditor.exe`, `LRInstaller.exe`, `LRProc.exe`, `LRSubMenus.dll`, `ServerRegistrationManager.exe`, `SharpShell.dll`, `System.Drawing.Common.dll`, and both hook DLLs to be copied into the same directory. Moving only the editor or one hook DLL would not match the documented deployment layout. The architecture choice is therefore part of deployment, not a cosmetic build setting.
Installing Locale_Remulator and Creating a First Launch
The documented installation path is the GitHub release page followed by execution of the packaged installer. The prerequisites are `.NET Framework 4.8` and the `Microsoft Visual C++ Redistributable`. The README also says that after installing a new version over an older installation, the user should restart Explorer or reboot the system.
Download the release archive from the project's releases page. The README gives this URL:
https://github.com/InWILL/Locale_Remulator/releases/latestAfter downloading, run `LRInstaller.exe`. The README identifies this executable as the installer, and also says that running `LRInstaller.exe` removes Locale_Remulator, so the same executable is used for both installation and uninstallation in the documented instructions. If an older copy was installed, restart Explorer or reboot Windows after installing the update.
The first documented use can be performed from the editor. Run `LREditor.exe`, click `Shortcut`, choose a configuration and an application, and let the editor create a `.lnk` file in the same path as the selected application. The generated shortcut then provides a convenient way to launch the application with the selected Locale_Remulator configuration without opening the context menu.
Context Menu and Shortcut Launch Workflows
Locale_Remulator offers two separate launch methods. The first is the Explorer context menu. After installation, selecting a `*.exe` application and opening its right-click menu should show a section named "Locale Remulator x64". The user can then choose the configuration associated with that executable. This method is useful when the application is launched from File Explorer and the user does not want to maintain a separate shortcut.
The second method uses `LREditor.exe`. The documented sequence is to open the editor, click `Shortcut`, select a configuration and an application, and allow the generated `.lnk` file to be placed in the same path. The shortcut is the durable launch object described by the README. It can be placed or used independently of the Explorer menu, which may be preferable for repeated launches or for applications managed outside the usual file browsing workflow.
The README does not specify the available configuration names, the number of configurations, the settings that can be changed, or the exact command line used by the generated shortcut. It also does not describe whether a shortcut can target multiple applications. Those omissions limit the depth of configuration planning that can be done from the documentation alone. The confirmed first-use decision is simpler: use the context menu for a direct File Explorer launch, or use `LREditor.exe` when a named shortcut is preferred.
Runtime Dependencies, Error Cases, and Upgrade Boundaries
Locale_Remulator has several concrete failure boundaries. The README identifies a missing-module error for `LRHookx64.dll` and a missing `VCRUNTIME140_1.dll` error, directing users to install the `Microsoft Visual C++ Redistributable` in both cases. These messages point to a runtime dependency problem rather than an application configuration problem.
Another documented startup error is `0xc000007b`, described as "The Application was Unable to Start Correctly". For that error, the README says to update Locale_Remulator to `1.4.3-beta.2+`. This matters when an older installation is still present. The documented remedy is an update, not a manual change to an application executable.
Architecture also affects deployment. The README lists separate `LRHookx32.dll` and `LRHookx64.dll` files and says to choose x86 or x64 as the solution platform. It does not document automatic handling of mixed dependencies, incompatible third-party overlays, protected processes, or applications that reject injected hooks. It also does not claim compatibility with non-Windows systems. The last push was on 2026-07-27, and the project is not marked archived, but the README does not describe a support policy for particular Windows releases.
Upgrading requires replacing or reinstalling the packaged components and then restarting Explorer or rebooting when an old version was present. The LGPL-3.0 license governs use and distribution, but the README only directs readers to the `LICENSE` file and does not provide a legal interpretation.
Locale_Remulator Compared with Locale-Emulator
The README positions Locale_Remulator as an alternative to Locale-Emulator, with the key stated difference being 64-bit support. Locale-Emulator does not support 64-bit applications according to the project description, while Locale_Remulator is based on Detours and includes `LRHookx64.dll`. This is an architectural and deployment difference, not merely a different user interface.
Locale_Remulator also adds an installation component, `LRInstaller.exe`, and an editor workflow through `LREditor.exe` and its `Shortcut` button. The documentation does not provide a corresponding feature-by-feature comparison with Locale-Emulator, so claims about other features would not be justified. The confirmed comparison is narrow: Locale_Remulator was created to support 64-bit applications, while the README says Locale-Emulator lacks that support.
For an engineer deciding between the two, the first question is whether the target application is 64-bit. If it is not, the stated reason for choosing Locale_Remulator may be less compelling, and the other project's behavior would need to be evaluated separately. If it is 64-bit and relies on region-sensitive APIs, Locale_Remulator's x64 hook DLL is the more directly aligned choice based on the repository documentation.
Editorial conclusion
Adopt Locale_Remulator when you need per-application regional simulation on Windows and can accept its Windows-only, .NET Framework 4.8, and Visual C++ runtime requirements. Do not adopt it as a general-purpose Linux or cross-platform localization tool, since the documented installation and deployment path is Windows-specific. Verify first that the target executable is compatible with the selected x86 or x64 hook, that the required runtimes are installed, and that the intended configuration produces the required application behavior.
Frequently asked questions
How do I install Locale_Remulator?
Install `.NET Framework 4.8` and the `Microsoft Visual C++ Redistributable`, download a release from the GitHub releases page, and run `LRInstaller.exe`. After upgrading an older installation, the README says to restart Explorer or reboot Windows.
How do I launch an application with a Locale_Remulator configuration?
Right-click a `*.exe` file and choose a configuration under "Locale Remulator x64", or run `LREditor.exe`, click `Shortcut`, and select the configuration and application. The editor then creates a `.lnk` file in the application's path.
What should I do if LRHookx64.dll or VCRUNTIME140_1.dll is missing?
The README directs users to install the `Microsoft Visual C++ Redistributable` for both errors. These messages indicate that the required Microsoft runtime dependency may not be present.
Does Locale_Remulator support 64-bit applications?
Yes. The README says the project was created because Locale-Emulator did not support 64-bit applications, and its deployment includes `LRHookx64.dll` for that purpose.
Official sources
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/inwill-locale-remulator)Was this useful?