
GITNUXSOFTWARE REVIEW
Manufacturing EngineeringTop 8 Best Shims Software of 2026
Compare shims software options like CrossOver, ScummVM, and PlayOnLinux for compatibility workflows, setup needs, and platform fit.
How we ranked these tools
Vendors set the topic, but our editors set the inclusion criteria and the evaluation framework before research starts.
AI search agents find sources, extract figures with provenance, and aggregate written reviews. They also transcribe video reviews and podcasts.
Framework: Features 40% · Ease 30% · Value 30%
Gitnux may earn a commission through links on this page — this does not influence rankings. Editorial policy
CrossOver is the best pick for engineering teams that need local Windows app compatibility with controlled per-app environments because its bottle-based runtime isolates dependencies and avoids cross-app DLL conflicts, whereas ScummVM fits legacy point-and-click game fans who want consistent per-title interpreter routing on modern desktops thanks to its centralized engine and config flow.
Editor’s top 3 picks
Three quick recommendations before you dive into the full comparison below — each one leads on a different dimension.
CrossOver
CrossOver bottles provide isolated, per-application Windows runtime environments with curated dependency handling.
Best for: Fits when engineering teams need local Windows app compatibility with controlled per-app environments.
ScummVM
Editor pickScummVM’s per-game interpreter routing runs many classic adventure titles via shared configuration and engine selection.
Best for: Fits when legacy adventure games need a standardized runtime shim on modern desktops.
PlayOnLinux
Editor pickProfile-scoped Wine prefixes driven by PlayOnLinux installer scripts for repeatable Windows setups.
Best for: Fits when a team must run a fixed set of Windows apps on Linux desktops with repeatable installers.
Comparison Table
CrossOver
SMBCrossOver runs selected Windows applications on macOS, Linux, and ChromeOS without a Windows license.
CrossOver bottles provide isolated, per-application Windows runtime environments with curated dependency handling.
CrossOver targets engineering teams that need an application compatibility layer without running full virtual machines. It packages Windows application compatibility through a curated Wine-based runtime and adds per-app configuration to reduce version skew and DLL mismatch issues.
CrossOver also focuses on repeatable install workflows via GUI-assisted installs, bottle management concepts, and scripting hooks for provisioning-like reuse. CrossOver is distinct among shims tools because it ships a compatibility runtime as a productized environment rather than asking teams to assemble the layer themselves.
- +Wine-based compatibility runtime reduces per-app build effort for common Windows apps
- +Per-application bottle isolation helps avoid cross-app DLL conflicts
- +GUI-driven installs speed up initial compatibility validation and iteration
- +Scripting hooks support repeatable environment setup for multi-machine use
- –Compatibility coverage depends on the specific Windows app version and its dependencies
- –Deep enterprise governance like RBAC and audit logs is limited for large fleets
- –Some apps still require manual DLL or configuration tuning outside defaults
IT admins for legacy apps
Launch unsupported Windows utilities
Access stays on the host
Small teams on macOS
Use Windows office tools
Avoid maintaining full Windows
Show 2 more scenarios
Developers running checks
Script repeatable app smoke tests
Repeatable compatibility checks
Launch configured Windows applications from scripts to repeat basic validation across workstations.
Engineers needing Windows tools
Operate supported engineering utilities
Windows tool access elsewhere
Attempt to run Windows-only engineering utilities on alternative desktop platforms using CrossOver-managed compatibility.
Best for: Fits when engineering teams need local Windows app compatibility with controlled per-app environments.
ScummVM
vertical specialistInterpreter and compatibility shim that runs classic point-and-click adventure games on modern operating systems.
ScummVM’s per-game interpreter routing runs many classic adventure titles via shared configuration and engine selection.
ScummVM functions as a runtime interposition layer by redirecting game execution to its bundled interpreters instead of the vendor binaries. The core capability is launching supported games from local data files while presenting consistent controls and audio handling across environments. The packaging model is built around per-game configuration and engine support, so compatibility depends on having the right interpreter for the target title and having correct game assets installed.
A key tradeoff is that unsupported games stay out of scope unless a matching interpreter is added, so coverage is title-specific rather than generic. The best fit is an engineering or IT maintenance scenario where a controlled emulator-like runtime can be standardized for legacy adventure software on modern operating systems, replacing per-title workarounds.
- +Title-specific interpreters provide consistent runtime behavior across hosts
- +Game launch and asset discovery flow is centralized in ScummVM
- +Config-driven setup reduces custom wrapper code per game
- +Works as a user-space shim without kernel integration requirements
- –Compatibility is limited to supported engines and specific game distributions
- –Some titles require careful configuration and correct data file placement
Desktop support teams
Standardize legacy game launch
Fewer broken launches
Systems integrators
Bundle a compatibility runtime
Repeatable deployments
Show 2 more scenarios
Indie preservation maintainers
Keep archives playable
Longer playable lifespan
Interpreter support keeps old game binaries out of the critical path for execution.
QA teams
Reproduce behavior across machines
More stable test baselines
Consistent runtime handling supports cross-machine regression testing for supported games.
Best for: Fits when legacy adventure games need a standardized runtime shim on modern desktops.
PlayOnLinux
SMBGraphical frontend for Wine that simplifies installing Windows applications on Linux through preconfigured shim environments.
Profile-scoped Wine prefixes driven by PlayOnLinux installer scripts for repeatable Windows setups.
PlayOnLinux manages Wine prefixes per application profile, which helps keep registry state, installed DLLs, and Windows components from colliding across different software. The installer automation comes from PlayOnLinux scripts that drive common setup steps through a scripted Wine environment. This fits engineering teams that need a controlled user-space runtime for legacy Windows tooling on Linux desktops or lab machines.
A key tradeoff is that PlayOnLinux does not provide an API surface for orchestration beyond the desktop workflow and its own script repository. It works well when a small set of specific Windows applications must be made reproducible for a group, but it is less efficient for broad application coverage or for headless deployment pipelines.
- +Wine version and prefix isolation per program profile
- +Installer scripts automate many common Windows setup flows
- +Per-app configuration reduces cross-app dependency conflicts
- +User-space compatibility work avoids kernel-level changes
- –No native automation API for fleet-wide provisioning
- –Coverage depends on available scripts for each app
Internal IT desktop support
Deploy legacy Windows tools on Linux
Fewer failed installs per release
Engineering validation labs
Run vendor utilities for testing
More consistent test environments
Show 1 more scenario
Procurement and operations
Maintain Windows-only business applications
Lower operational overhead
Repeat known-good setup steps through PlayOnLinux profiles for predictable upgrades.
Best for: Fits when a team must run a fixed set of Windows apps on Linux desktops with repeatable installers.
Lutris
vertical specialistOpen-source gaming platform that installs and manages games using compatibility shims like Wine and Proton.
Per-executable shim rules that redirect loaded modules and paths at runtime for specific binaries.
Lutris positions itself as a shims solution for Windows-side compatibility through DLL interception and process-level remapping. It focuses on turning missing or mismatched dependencies into controlled runtime substitutions, so legacy binaries can run against newer component sets.
- +DLL load redirection enables targeted fixes without repackaging application binaries
- +Per-application rules keep compatibility scoped to specific executables and environments
- +Deterministic shims behavior supports repeatable results across test and staging machines
- +Path mapping covers common dependency skew caused by version differences
- –Win32-only scope limits direct use for non-Windows automation workflows
- –Complex dependency graphs can require multiple layered rules to fully resolve
Engineering teams
Map DLL paths per Windows app
Repeatable compatibility setups
IT teams standardizing machines
Deploy consistent launch environments
Less drift across PCs
Show 1 more scenario
Developers with many dependencies
Handle mismatched runtime modules
Fewer dependency failures
Use DLL interception and process-level remapping to substitute missing or mismatched dependencies.
Best for: Fits when Windows engineering teams need controlled runtime compatibility for legacy apps across mixed dependency versions.
Wine
developerWine provides a compatibility layer for running Windows applications on Unix-like operating systems.
Winetricks-focused runtime dependency installers plus per-prefix DLL overrides for controlled application-specific compatibility.
Wine runs Windows applications on Linux and other POSIX-like systems by translating Windows API calls into native system calls. It provides a compatibility runtime that supports many Win32 user-mode components and common multimedia and networking paths without needing Windows itself.
- +Win32 API translation runs Windows GUI and console apps on Linux
- +Layered DLL loading and override support for targeted compatibility tuning
- +Buildable components and clear architecture for contributors and custom patches
- +Good coverage for common Windows dependencies like user32 and gdi32 calls
- –Compatibility varies widely by application and Windows feature usage
- –Many edge cases require per-app configuration and DLL overrides
- –Debugging failures often needs Wine logs plus Windows binary inspection
- –Kernel-driver or deep OS features from Windows apps are not supported
Linux and macOS gamers
Run configured Windows games
Use Windows game libraries
Software engineering teams
Validate Windows software in CI
Repeatable release checkpoints
Show 2 more scenarios
Archives and researchers
Keep retired Windows tools accessible
Longer usable software life
Maintain ongoing access to historical Windows applications through a reproducible compatibility runtime.
Developers with limited source access
Avoid immediate source-level porting
Possible Unix execution route
Provide a user-space compatibility path when source code is limited or a rewrite is impractical.
Best for: Fits when engineering teams need a user-space Windows compatibility layer for Linux execution and CI validation of legacy apps.
DOSBox-X
vertical specialistDOSBox-X emulates DOS hardware and supports legacy DOS applications and games.
DOSBox-X configuration supports detailed CPU and DOS environment tuning per emulated machine, which reduces per-binary breakage during launches.
DOSBox-X is a DOS emulator that functions as a compatibility layer for running legacy DOS binaries on modern systems. It uses configurable CPU core behavior, DOS environment setup, and device emulation to match expectations from older games and utilities.
- +Practical per-app configuration for DOS environment, memory, and device mapping
- +Strong file-based workflow using disk images and repeatable emulation settings
- +Better chance of running real DOS software than generic compatibility layers
- +Debug-oriented runtime behavior helps diagnose legacy binary expectations
- –No API surface for automated compatibility decisions across a fleet
- –Legacy support depends on emulator tuning for each title or utility
- –Compatibility varies by DOS program size, timing sensitivity, and hardware access patterns
- –Limited governance controls like RBAC and audit logging for enterprise rollouts
Retro gaming communities
Run DOS utilities on modern PCs
Utilities run on modern hosts
Support teams for legacy workflows
Start per-instance DOS sessions
More consistent DOS behavior
Show 1 more scenario
Operations teams maintaining tools
Use file-based compatibility launch
App-level compatibility without refactors
Provide shim-style execution via controlled launch and DOS environment emulation for older applications.
Best for: Fits when teams need repeatable workstation-level execution for DOS titles without custom shims.
Bottles
developerBottles manages isolated Wine environments for Windows applications and games on Linux.
Bottle environments bundle dependencies and runtime components so each legacy app runs under an isolated configuration.
Bottles positions shims as an automated packaging and runtime layer for legacy Windows applications, with execution inside controlled bottle environments. It focuses on component isolation, per-application environment configuration, and reproducible launches through a GUI-first workflow.
- +Per-application bottle isolation reduces cross-app dependency conflicts
- +Environment configuration is adjustable without rebuilding the legacy app
- +GUI workflow supports fast setup and iterative compatibility testing
- +Repeatable launches via stored bottle configuration
- –Limited support for enterprise-scale RBAC and audit logging
- –Windows runtime compatibility varies by application and requires tuning
- –API surface for automation and provisioning is not a primary feature
- –Cross-host consistency depends on how bottle components are managed
Individual legacy app users
Run Windows apps in a bottle
More predictable app launches
Teams migrating slowly
Configure runtime components per app
Compatibility without app edits
Show 1 more scenario
Operations staff standardizing legacy setups
Create reproducible launches
Lower setup variability
Use GUI-first bottle workflows to package consistent runtime environments for repeatable execution.
Best for: Fits when teams need controlled, repeatable execution of legacy Windows apps for testing or internal use without source changes.
FEX-Emu
vertical specialistUser-mode x86_64 to ARM64 binary translator for running x86 applications on ARM Linux.
Dynamic instruction translation with a translation cache designed for fast repeated execution of user-space workloads.
FEX-Emu translates guest instructions into a host-executable form and then dispatches translated blocks through a runtime that preserves observable process behavior. Compatibility hinges on managing syscall translation and the guest user-space ABI expectations so common binaries reach steady-state execution. Integration is typically done by launching the target executable under FEX-Emu with a workload-specific runtime configuration.
- +Runtime instruction translation enables frequent legacy binary validation
- +Syscall and ABI mapping supports many real-world user-space workloads
- +Workload-scoped runtime configuration helps isolate compatibility issues
- +Translation cache improves throughput for repeated execution
- –Compatibility coverage varies by binary and can fail at runtime
- –Debugging requires emulator-aware logs and reproduction discipline
Platform engineering teams
Validate legacy user binaries on new hosts
Faster compatibility triage
CI test automation teams
Add emulation runs to regression suites
Earlier break detection
Show 2 more scenarios
Security and reverse engineering teams
Reproduce behavior of foreign binaries
Repeatable execution traces
Execute target binaries in user-space to observe syscalls and runtime behavior with emulator-controlled configuration.
Application migration teams
Plan modernization from observed runtime gaps
Migration backlog clarity
Compare emulator success paths and failure points to prioritize rebuild work for the most critical binaries.
Best for: Fits when engineering teams need Linux user-binary compatibility testing across host changes.
Conclusion
After evaluating 8 shims software, CrossOver stands out as our overall top pick — it scored highest across our combined criteria of features, ease of use, and value, which is why it sits at #1 in the rankings above.
Use the comparison table and detailed reviews above to validate the fit against your own requirements before committing to a tool.
How to Choose the Right Shims Software
This guide covers shims software used to maintain compatibility when a runtime, dependency set, or platform diverges from what a legacy binary expects. The coverage spans ScummVM, PlayOnLinux, FEX-Emu, Lutris, Wine, CrossOver, Bottles, and DOSBox-X.
Each tool review maps a different shim shape to the operational outcome it enables. ScummVM focuses on per-game interpreter routing with shared configuration, while FEX-Emu targets dynamic instruction translation with a translation cache for repeated user-space workloads.
Shims Software that inserts compatibility adapters into a legacy runtime path
Shims software provides compatibility layer behavior by redirecting calls, loads, or execution flow so older applications run under newer hosts. Lutris uses per-executable shim rules to redirect loaded modules and paths at runtime, which keeps compatibility scoped to specific binaries.
Some shims act as user-space compatibility runtimes that translate or execute legacy instruction paths. FEX-Emu implements dynamic instruction translation with a translation cache, plus syscall and ABI mapping to validate Linux user binaries across host changes.
Shim integration controls that determine compatibility outcomes
Each shim tool changes runtime behavior by rerouting execution or load paths, so the control surface determines whether compatibility stays scoped or spreads across unrelated apps. Tools like Lutris and PlayOnLinux both rely on per-application scoping, but they implement that scoping at different layers, which changes what teams can standardize.
The most decisive differentiators across these tools are interpreter routing versus module path redirection versus instruction translation, plus how repeatable the configuration is when multiple legacy binaries must be validated. ScummVM centralizes per-game interpreter selection, while FEX-Emu focuses on runtime instruction translation with a translation cache for fast repeated workloads.
Per-title or per-executable routing that keeps compatibility scoped
ScummVM runs classic adventure titles through shared configuration with per-game interpreter routing. Lutris applies per-executable shim rules that redirect loaded modules and paths at runtime for specific binaries.
Runtime translation and caching for repeated legacy workload validation
FEX-Emu provides dynamic instruction translation with a translation cache designed for fast repeated execution of user-space workloads. This caching behavior supports frequent compatibility checks after host changes.
Repeatable Windows app setup via automated installer scripts and isolated prefixes
PlayOnLinux uses installer scripts to drive Wine version selection and program profile isolation via separate Wine prefixes. This approach improves reproducibility when teams must run a fixed set of Windows apps on Linux desktops.
Layered DLL overrides and Winetricks-driven dependency installation
Wine uses Winetricks-focused runtime dependency installers plus per-prefix DLL overrides to tune compatibility for specific apps. This tuning model supports CI validation workflows that depend on consistent dependency state.
Bottle-level environment isolation for Windows apps with curated dependency handling
CrossOver runs Windows apps inside isolated per-application bottles with curated dependency handling. Bottles also provides per-application isolated environments that bundle dependencies and runtime components for repeatable execution.
Emulator configuration that targets workstation-level DOS runtime reproducibility
DOSBox-X relies on detailed CPU and DOS environment tuning per emulated machine. It also uses disk images and repeatable emulation settings to reduce per-binary breakage during launches.
Choose by shim placement: interpreter routing, module redirection, or instruction translation
Shim placement determines what can be controlled without repackaging and what failures look like at runtime. ScummVM routes execution through per-game interpreters, Lutris redirects module and path loads per executable, and FEX-Emu translates instructions at runtime for user-space binaries.
Teams also need to decide how repeatable setup must be across machines. PlayOnLinux and Wine emphasize scripted or override-based dependency provisioning, while CrossOver and Bottles emphasize containerized isolation through bottles and bundled dependencies.
Match the shim mechanism to the failure mode: runtime interpreter versus load redirection versus instruction translation
If legacy behavior depends on selecting a supported engine and running the title through a known interpreter, ScummVM’s per-game interpreter routing is the closest match. If the legacy binary fails because it loads the wrong DLLs or resolves the wrong module and path at startup, Lutris’ per-executable shim rules target that load-time problem.
Validate frequently with minimal re-run overhead when binaries must be tested across host changes
If compatibility testing requires frequent execution of Linux user binaries under changing hosts, FEX-Emu’s dynamic instruction translation with a translation cache is designed to reduce repeated overhead. This fits engineering workflows that run the same binaries many times after host updates.
Standardize Windows app setup on Linux using scripts and isolated prefixes
If the team needs repeatable Windows app setups across many Linux desktops, PlayOnLinux uses installer scripts with Wine version and prefix isolation per program profile. This makes the provisioning repeatable for a fixed set of apps.
Choose per-prefix DLL override tuning when CI depends on deterministic dependency state
If the validation workflow needs dependency installers and DLL overrides tied to each Wine prefix, Wine plus Winetricks supports layered DLL loading and per-prefix DLL override control. This is best when teams accept that compatibility can vary by application and requires per-app tuning.
Pick bottle isolation when dependency conflicts between Windows apps must stay compartmentalized
If multiple Windows apps must not interfere with each other via shared DLL state, CrossOver runs apps inside isolated bottles with curated dependency handling. Bottles similarly bundles dependencies per app so each legacy app runs under an isolated configuration.
Use DOSBox-X when the requirement is repeatable DOS execution from emulation settings and disk images
If the compatibility target is DOS titles and utilities that break due to DOS environment differences, DOSBox-X provides detailed CPU and DOS environment tuning per emulated machine. It also uses disk images and repeatable device and memory mapping to keep launches consistent.
Who benefits from these shim controls in engineering workflows
Shims fit teams that must keep legacy binaries operational while host systems change, dependency sets shift, or platform expectations diverge. The right tool depends on whether compatibility is best handled by interpreter selection, load-time path redirection, or runtime instruction translation.
Engineering teams also differ in how they provision environments. Some teams can live with manual per-app configuration, while others need repeatability via scripts or isolated environment containers.
Engineering teams standardizing legacy Windows app execution on Linux desktops
PlayOnLinux focuses on profile-scoped Wine prefixes driven by installer scripts, which supports repeatable setups for fixed app sets. Wine provides Winetricks-focused dependency installers plus per-prefix DLL overrides when CI must control dependency state per app.
Teams that need compatibility validation for Linux user-space binaries across host changes
FEX-Emu translates instructions at runtime and uses a translation cache to accelerate repeated executions. Its syscall and ABI mapping supports user-space workload compatibility testing without rebuilding legacy binaries.
Windows engineering teams routing legacy runtime behavior through executable-scoped overrides
Lutris redirects loaded modules and paths using per-executable shim rules, which keeps compatibility scoped to a specific binary. This model helps when mixed dependency versions break legacy apps and the fix must stay targeted.
Teams maintaining legacy DOS titles with repeatable emulated machine configurations
DOSBox-X provides CPU and DOS environment tuning per emulated machine and a file-based workflow using disk images. This reduces per-title breakage when launching workstation copies of DOS content.
Teams running many classic adventure titles with consistent interpreter selection
ScummVM centralizes game launch and asset discovery while using per-game interpreter routing. This approach standardizes runtime behavior across hosts for supported engines and distributions.
Common shim selection and operations mistakes that cause runtime failures
Shim tools can fail in ways that look like missing dependencies, missing engine support, or runtime incompatibilities. These failures usually track to configuration scope, supported coverage, and the debugging workflow needed to reproduce runtime behavior.
Teams often underestimate how coverage limits apply to specific binaries or how much configuration discipline is needed when rules stack across multiple components.
Choosing a tool for its general compatibility claims without checking supported engine or distribution coverage
ScummVM compatibility is limited to supported engines and specific game distributions, so incorrect title placement or unsupported engine selection leads to runtime failures. FEX-Emu coverage can vary by binary and can fail at runtime, so binary selection and reproduction discipline matter.
Relying on per-app compatibility without enforcing a consistent configuration workflow
Lutris can require multiple layered rules when complex dependency graphs must be resolved, which can turn small edits into broad breakage. Bottles supports adjustable environment configuration but lacks enterprise-scale RBAC and audit logging, so teams can lose control over changes across multiple users.
Assuming enterprise fleet governance features are available when running many Windows apps
CrossOver notes that deep enterprise governance like RBAC and audit logs is limited for large fleets, which impacts controlled rollouts. PlayOnLinux provides profile-scoped isolation but has no native automation API for fleet-wide provisioning, which complicates standardized deployment across many machines.
Treating emulator tuning as transferable across titles instead of per-title configuration
DOSBox-X requires per-emulated-machine tuning for CPU and DOS environment, and compatibility depends on emulator tuning for each title or utility. Using the same emulation settings across different DOS content increases breakage risk.
How We Selected and Ranked These Tools
We evaluated ScummVM, PlayOnLinux, FEX-Emu, Lutris, Wine, CrossOver, Bottles, and DOSBox-X by scoring features at 40% and then scoring ease at 30% and value at 30%. We weighted integration depth by checking whether each tool provides a repeatable configuration surface such as per-game interpreter routing in ScummVM or profile-scoped Wine prefixes via PlayOnLinux installer scripts.
We weighted automation and API surface by favoring tools that centralize configuration flows, while penalizing products that lack a native automation API for fleet-wide provisioning, which affects PlayOnLinux. ScummVM separated itself by combining per-game interpreter routing with centralized game launch and asset discovery flow, which reduces the number of manual steps needed to keep runtime behavior consistent across hosts.
Frequently Asked Questions About Shims Software
How does a shim runtime differ between ScummVM and Wine for legacy applications?
When should PlayOnLinux be used instead of Wine alone for Windows installers on Linux?
What breaks when FEX-Emu targets Linux user binaries that depend on kernel features?
Which tool is better for redirecting missing Windows DLLs at runtime: Lutris or CrossOver?
How do BOM-like dependency installs get automated in Wine environments compared with Bottles?
When does Lutris need more governance discipline than ScummVM?
What security and audit controls exist around configuration changes in Wine versus Bottles?
How should engineering teams approach data migration when moving a legacy Windows workflow to CrossOver or Wine?
Where does throughput fall short for DOSBox-X compared with native execution, and how is that tied to configuration?
Tools reviewed
Primary sources checked during evaluation.
Referenced in the comparison table and product reviews above.
Funding and competing interests
This study was co-funded by several of the vendors assessed in it. No single vendor funded it. Funders could propose the market studied.
They had no role in selecting vendors, setting or weighting criteria, analysing data or drawing conclusions, and they received the same factual-accuracy check as every other vendor assessed.
Market definition, inclusion rules and criteria weights were fixed by an editor before research began and did not change afterwards. Editorial process →
- Review · 2026 · Manufacturing EngineeringShim Software
- Review · 2026 · Manufacturing EngineeringShaped Software
- Service review · 2026 · Manufacturing EngineeringBim Engineering
- Service review · 2026 · Manufacturing EngineeringTooling Design
- Review · 2026 · Manufacturing Engineering3D Manufacturing Software
Keep exploring
Comparing two specific tools?
Software Alternatives
See head-to-head software comparisons with feature breakdowns, pricing, and our recommendation for each use case.
Explore software alternatives→In this category
Manufacturing Engineering alternatives
See side-by-side comparisons of manufacturing engineering tools and pick the right one for your stack.
Compare manufacturing engineering tools→