Sandboxie Plus: Windows application isolation from the community fork

The problem Sandboxie Plus solves for Windows users

Sandboxie creates a secure operating environment in which applications can be run or installed without permanently modifying local and mapped drives or the Windows registry. That is the whole product in one sentence, and it is a narrower promise than a virtual machine. You are not booting another OS. You are redirecting the file and registry writes of a normal Windows process into a private store, then discarding or selectively recovering those writes later.

The intended audience is anyone who has to execute something they do not trust. Installers from unknown publishers, browser sessions on hostile sites, game clients with aggressive launchers, and programs that scatter configuration across the registry. The README also describes controlled testing of untrusted programs and web surfing as the core use case.

It is not a security boundary for the paranoid. It is a containment boundary for the practical. The distinction matters when you read the feature list: the newer Plus options include restricting syscalls and endpoints, limiting memory per process and per box, and blocking access to components like the printer spooler and clipboard. Those exist because the default isolation is not absolute.

One thing to settle early: this is a community fork that took place after the release of the Sandboxie source code, and the README states plainly that it is not the official continuation of the previous development. If you are looking for the pre-open-source product line, you are in the wrong repository.

How the sandbox works: driver, service, and per-box isolation

The mechanism is a kernel driver plus a service, not a user-mode wrapper. The README lists a Maintenance menu whose job is to uninstall, install, start, and stop the Sandboxie driver and service. That menu exists because the driver is the component doing the interception, and it has to be registered with the OS before any box can run.

On top of that sits the box. You can create virtually unlimited sandboxes and run them alone or simultaneously, to isolate programs from the host and from each other, while running as many programs in a single box as you wish. So the isolation unit is the box, not the process, and the box is where policy lives: internet access restrictions, start and run restrictions, a per-sandbox network firewall built on the Windows Filtering Platform, DNS blocking or redirection, and memory and process-count limits.

File and registry state inside a box is kept separately from the host. The Plus edition adds a Snapshot Manager that takes a copy of any box so it can be restored when needed, and an Encrypted Sandbox described as an AES-based data storage solution. Boxes can also be imported and exported as 7z files, which is the practical way to move a configured box between machines.

There is a trigger system that fires actions when a sandbox goes through stages such as initialization, box start, termination, or file recovery. That is the extension point for anyone who wants recovery to happen automatically rather than by hand.

The two editions share the same core components, so the README states they have the same level of security and compatibility. The difference is interface coverage, and that is where the next section lands.

Plus versus Classic: same core, different interface reach

Sandboxie Plus ships a modern Qt-based UI. Sandboxie Classic keeps the old MFC-based UI, which the README describes as no longer developed. Both editions share the same core, so the security and compatibility level is identical. What changes is whether you can reach a setting from the interface.

The README is direct about the consequence: Classic lacks native interface support for Plus features, and although some of the missing features can be configured manually in the Sandboxie.ini configuration file or replaced with custom scripts, the Classic edition is not recommended for users who want to explore the latest security options.

That is a real fork in the road, and the honest reading is that Classic is a compatibility choice. If you have an existing Sandboxie.ini with years of hand-tuned settings, or scripts that drive the old interface, Classic keeps that working. If you are starting fresh and want the privacy-mode boxes, security-enhanced boxes with restricted syscalls and endpoints, the per-box WFP firewall, or the custom UAC dialog that can fake, grant, or cancel an elevation attempt, Plus is the only edition that exposes them natively.

Plus also carries the quality-of-life layer: search in Global Settings and Sandbox Options, an internal INI editor with visual hints and tooltips, configurable external text editor, custom fonts and colors, Start menu integration for boxes, a browser compatibility wizard, a troubleshooting wizard, and an add-on manager.

Neither edition is a separate download of a different engine. Choosing Classic does not buy you less isolation. It buys you less control surface.

Installing Sandboxie Plus and running a first boxed program

System requirements are Windows 7 or higher, 64-bit. The README points to the latest release page for downloads, and the repository's Installer directory holds the installer sources. There is also a portable mode: the README states you can run the installer and choose to extract all files to a directory instead of installing.

No command line is documented in the README for downloading or installing. The release page is the source the README gives, so start there and pick the asset for your architecture.

After installation, the driver and service must be running. The Maintenance menu in Plus is where the README says you uninstall, install, start, and stop them. The repository also ships SandboxieTools and a TestCI.cmd script at the top level, which are build and test helpers rather than user-facing commands.

Once the service is up, the box is the unit you work with. Creating a box and running a program inside it happens through the Plus interface: the README describes boxes as the isolation unit, with internet access restrictions, start and run restrictions, and the per-box firewall configured as box options rather than at launch.

The README does not document a command-line start utility, so treat the UI as the supported path for launching a first sandboxed program. The program opens with a colored border indicating it is sandboxed, and anything it writes goes into the box rather than the host.

To see what a boxed program wrote and pull selected files back out, use the recovery view in the Plus UI. The trigger system can be configured to act on the file recovery stage, which is the documented way to make that step automatic.

Where Sandboxie is the wrong tool

The 64-bit requirement is the first hard boundary. Windows 7 or higher, 64-bit, is the stated system requirement. A 32-bit Windows install is out, and so is anything that is not Windows NT-based, because the product is described as sandbox-based isolation software for Windows NT-based operating systems.

Sandboxie is also not a substitute for a virtual machine when you need a different OS, a different kernel, or hardware-level separation. It shares the host kernel. A kernel-level exploit that escapes the driver is outside what this design can promise, which is exactly why the Plus edition adds syscall and endpoint restrictions and a token creation mechanism that differs from the pre-open-source version.

Classic is the wrong choice for anyone who wants the newer security options through the interface. The README says so directly. You can hand-edit Sandboxie.ini, but you are then maintaining configuration the UI will not validate for you.

There is a caveat in the documentation itself. The README's documentation section points to a GitHub copy of the Sandboxie documentation, and the excerpt here is truncated at that point. Anything about rollback of a failed driver update, or about recovering a corrupted box store, is not documented in the README as provided. Treat the Snapshot Manager as the mechanism the project offers for that class of problem, and verify the details in the full documentation before relying on it.

Finally, the project is a community fork. If your procurement process requires an official vendor continuation of the original product, the README's own note about the fork should stop you before you get to the feature list.

Alternatives and the difference in approach

Windows Sandbox, the Microsoft-supplied feature, is the obvious comparison and the one users ask about. The difference is architectural. Windows Sandbox starts a disposable, lightweight virtual machine with its own kernel; everything inside it is discarded when it closes. Sandboxie keeps your normal Windows session and redirects file and registry writes from individual processes into a box. That means Sandboxie can box one program while you keep working in the same desktop, and it can keep a box alive across reboots, which a disposable VM does not do. The trade-off is that Sandboxie shares your kernel, while the VM does not.

A full virtual machine from any hypervisor takes that separation further: separate kernel, separate drivers, separate everything, at the cost of a second Windows licence and a much heavier footprint. If your goal is to run one installer and look at what it drops, that is overkill.

Application-level sandboxing built into browsers is a third option and covers the web-surfing case only. It does nothing for a downloaded executable or a game launcher, which is where Sandboxie's box model still has a role.

The practical split: use Sandboxie when you want to keep your desktop and isolate a process, use Windows Sandbox or a VM when you want to assume the whole environment is compromised.

Licensing, maintenance, and upgrade cost

The repository carries two licence files, LICENSE.Plus and LICENSE.Classic, and the README badges label them as Custom and GPL-3.0 respectively in the repository metadata. That means the two editions are not under the same terms, and the licence that applies to you depends on which edition you install. Read the file that matches your edition; this article is not legal advice.

Maintenance is active in the literal sense. The most recent release listed is v1.18.4, dated 2026-09-06, and the last push to the default branch was on 2026-09-19. The repository is not archived. Releases have been arriving on a roughly two-week cadence across v1.18.2, v1.18.3, and v1.18.4.

That cadence is the upgrade cost. The release numbering pairs a Plus version with a Classic version, for example v1.18.4 alongside 5.73.4, so both editions move together. If you pin a version, you are pinning both. The CHANGELOG.md file is where the project records what changed, and the README suggests searching it with Ctrl+F for the `=` sign to find feature additions.

For a hand-tuned Sandboxie.ini, every upgrade is a chance that a setting is renamed or a default changes. The internal INI editor with visual hints is the mitigation the Plus edition offers. The Snapshot Manager is the mitigation for a box that breaks after an upgrade, since it takes a copy of a box that can be restored later.

Editorial conclusion

Adopt Sandboxie Plus if you need to run untrusted Windows programs, test installers, or keep browser and game data out of the host registry, and if you are willing to work through Sandboxie.ini and the driver and service maintenance menu yourself. Do not adopt it on 32-bit Windows, on non-Windows hosts, or if you expect the Classic MFC interface to expose the newer security options; the README states Classic lacks native interface support for them. Before trusting it, verify the Windows 7 or higher 64-bit requirement against your machine, confirm which licence file applies to the edition you install, and read the SECURITY.md and CHANGELOG.md files in the repository.

Frequently asked questions

Official sources

1. License: GPL-3.0
2. Project website
3. README
4. Releases
5. sandboxie-plus/Sandboxie on GitHub