Create portable applications in minutes
MoleBox Virtualization Solution (VS) creates a private and secure virtual environment for your software applications, isolating them from the underlying operating system and other software installed and running on the host device.
It is achieved by placing the application and all of its elements into managed packages which form virtual file systems and virtual registries in runtime.
Virtual file system provides the application with transparent access to original files while protecting them from unauthorized use. Virtual registry allows using ActiveX components without registration and overriding existing registry values while protecting the host registry from modifications.
Create virtual environment for your software
MoleBox VS lets you convert your application into an all-sufficient stand-alone executable, containing everything needed: components, media assets, registry entries . Moleboxed environment is private and secure, which means that all packaged elements are available to your application only and are protected from any unauthorized access.
Create portable applications
Traditional software setup process frequently requires admin rights, includes installation and registration of many components, and may take significant time. Portable moleboxed applications run without installation on any computer, from any source – USB device, CD-ROM, or network drive. Moleboxed software can run without altering host device file system: it does not extract original files not creates temporary files, and can be easily and cleanly removed when necessary.
Use any components and runtimes without installation or registration
MoleBox VS allows embedding DLLs, ActiveX and .NET components, as well as VB, FoxPro, Java and other runtimes into your application. Embedded components are loaded on demand directly to the memory and are never extracted to disk. Due to virtual registry technology, you can use ActiveX components without registration, without any changes to the host PC registry.
Run from user level, without admin privileges
Moleboxed applications require neither installation no modifications to the host device registry, and run in user mode, without administrator privileges. Your end-users won’t be discouraged with security warnings or any other problems running your software.
Avoid application conflicts, DLL hell and registry rot
With MoleBox VS you can create zero-install applications which are isolated from the host device, protecting it against changes to registry and file system. This allows using multiple versions of same applications, components and runtimes at the same time without conflicts.
Manage your software distribution, simplify delivery, reduce support and testing cost
Moleboxed applications can be delivered in a single executable that runs with zero setup. MoleBox VS allows easy creation and distribution of software updates, by creating additional packages and delivering them to end-users.
MoleBox virtualization technology eliminates the need to test software on different configurations. Software developers and IT managers may package software once and deploy it to different operating systems without repackaging.
Get your software ready for distribution as fast as possible, we’re here to help. We will package your software to a portable standalone executable ourselves, or create a project file for you that you can use later on your own.
Standard Plan – $100
With this option, our engineer will examine your application and recommend the best options for virtualization.
We can also generate command-line scripts for automatic packaging and provide consultations on integrating MoleBox to your workflow.
This service is available to users of MicroISV and Company licenses, and solely for applications developed or authored by our respective customers.
- the original, unpacked application, including all files required to run it, and
- optionally, usage scenario to test the application after being packed.
- if the application can be packed with the current version of MoleBox, you get a project file ready for packaging;
- if the application cannot be packed due to its specialty or its behavior, we’ll give recommendations how it should be changed to make it packageable.
Results in 3 business days after receiving complete application.
With this option, we take your original application and deliver it already wrapped. License purchase is not required. Pricing depends on application specifics. Service is provided when technically possible.
Additional services with Premium Plan:
- Custom packaging templates with or without additional functionality;
- Custom components to perform additional actions on application startup and shutdown;
- USB copy protection
Custom Development Service
With our extensive experience in software virtualization technologies, we can also offer:
- Custom versions of MoleBox which will fit your specific requirements, or implement additional functionality required by your applications;
- Virtualization and protection modules and components to be used in your software;
- Other software and components based on our virtualization technology.
MoleBox 9x is a virtualization solution supporting legacy operating systems from Windows 98 to Windows XP, and greater.
It lets you package your software application together with its supplementary files into a single efficient executable that runs on any computer.
MoleBox 9x also protects packed files from being viewed, modified or reused by third-party software.
Run your software without external files
MoleBox 9x processes all application files in order to create a single executable file that keeps the functionality of the original program.
The resulting executable works without extracting packed files to the hard drive and sees packed files as if they actually were on the hard drive. Instead of creating an installer, you can ship a sole executable file to your customers.
Use DLLs and of ActiveX components without installation and registration
MoleBox 9x embeds DLLs and vast majority of ActiveX components into the application and loads integrated components directly to the memory.
While embedding, it extracts all necessary information form ActiveX components and then uses it for initialization when your application loads a component in runtime.
You don’t have to install or register packed components, which allows running the packed applications under user privileges, without modifications to the host computer registry.
Avoiding DLL hell and version conflicts
By embedding correct versions of components used in your software, you can assure that your application always uses the same DLL versions it was compiled with.
Installation of another software using other versions of these components won’t harm your program’s functionality and vice versa.
Protect your DLLs and components from unauthorized use
Embedded components are loaded directly to memory and are never extracted to the hard drive. In runtime, embedded files are also hidden, which protects them from being reused by third party software.
Protect you media assets from prying eyes
Games and multimedia presentations often include a lot of exclusive content: 3D models, textures, 2D images, custom fonts, photos, sound effects and music files.
Obviously, you wouldn’t like if someone else will use your media files.
MoleBox 9x encrypts packaged content files, and these files cannot be viewed, extracted, modified or otherwise used by another person.
Get much more flexibility virtualizing your applications
MoleBox SDK is an embeddable virtualization engine.
Not only it allows you to package your own software, but also adds virtualization functionality to your application development tools.
MoleBox SDK virtualizes some system functions, like access to files or registry entries, which allows the host application to be isolated from operating system.
MoleBox SDK operates packages that can contain executable and data files, and elements of virtual environment – registry keys and environment variables.
Packages can be created with included MoleBox VS wrapper or with a 3rd party wrapper.
MoleBox SDK lets you load packages when necessary and then access files and environment elements like if they were physically installed.
Flexible application virtualization
MoleBox SDK lets you virtualize existing Windows applications with the maximum flexibility possible:
- The main executable file is not packaged. This allows to apply 3rd party wrappers or protectors, and reduces risk of antivirus false positives.
- Data packages may remain external, or they may be appended to the main executable thus producing a single-executable application.
- You gain full control over package loading time and order. For example, you may want to password-protect your media files, then you will load the data package only when the user enters correct password. Keeping package unloaded also helps to protect its content from unauthorized access.
- You can utilize your own format for data packages which is unfamiliar to hackers, to increase security of data files.
Create applications able to package content files
Here are some use cases where your users would love to hide their custom content files and make a standalone application:
- Multimedia authoring tools
- Rapid game development tools
- Educational software development tools
- Survey and questionnaire building tools
- Databases viewers, and many more