Running Arma Reforger on Steam Deck: A Deep Technical Guide for Linux

Arma Reforger is not designed for the Steam Deck. Valve's own compatibility rating says "Unsupported." The game's Steam page lists a minimum GPU requirement of an NVIDIA GTX 1060 or AMD RX 480 -- dedicated graphics cards with 6GB of VRAM. The Steam Deck's custom AMD APU shares 16GB of LPDDR5 system memory between the CPU and GPU with no dedicated VRAM at all. It delivers roughly 1.6 TFLOPs of FP32 compute at its GPU peak.

And yet players run it. Some play it daily. To understand why this works at all -- and how to make it work well -- you need to understand what is actually happening between the game engine, the compatibility layer, the hardware, and SteamOS. That chain of translation is where all the interesting problems live, and where every meaningful optimization decision gets made.

This guide does not offer quick tips. It explains the system. Once you understand the system, the tips become obvious -- and you'll be able to invent your own.

The Hardware Reality of the Steam Deck APU

The Steam Deck (LCD) ships with AMD's Van Gogh SoC -- codenamed "Aerith" internally at Valve, referencing the Final Fantasy VII character. It is manufactured on TSMC's 7nm process and measures 162mm². The OLED model uses the updated "Sephiroth" die (Valve's internal name, continuing the FF7 theme) on TSMC's 6nm node -- a shrink that delivers meaningful efficiency gains with the same fundamental architecture. Both use four Zen 2 CPU cores (eight threads), eight RDNA 2 Compute Units on the GPU side, and 16GB of LPDDR5 memory across a 128-bit (four 32-bit channels) memory bus. The OLED model's memory runs at 6400 MT/s versus the LCD's 5500 MT/s, a difference worth noting for bandwidth-constrained workloads.

That memory bandwidth figure matters enormously -- but requires a critical nuance. Analysis of the Van Gogh APU by Chips and Cheese found it achieves over 70 GB/s of practical memory bandwidth from the GPU side -- notably higher than integrated graphics on mainstream laptop APUs of similar era. However, the same analysis found the CPU side achieves only around 25 GB/s of usable bandwidth from the same LPDDR5-5500 pool -- a figure the researcher described as "on the wrong planet" for a 128-bit LPDDR5 setup, and one that AMD's Renoir APU with DDR4-3200 actually exceeded. This asymmetry is not a bug; it reflects the engineering priorities of a device designed for GPU-intensive workloads. But it has direct consequences for Arma Reforger. When the CPU-side simulation (AI, physics, game state) generates cache misses and reaches for main memory, it competes for a bandwidth budget that is considerably tighter than the GPU enjoys.

But here is the central tension of the Unified Memory Architecture (UMA): the CPU and GPU share that same pool. When the game's Windows binary, running under Proton, makes D3D12 calls that eventually ask VKD3D-Proton to allocate GPU-local memory, those allocations come from the same 16GB that the OS, Gamescope, and every other process is also using. There is no dedicated VRAM. The GPU's "local" memory is a region carved from system RAM and designated for GPU use through BIOS settings -- by default only 1GB is reserved, though this can be adjusted. The rest of what the GPU actually uses during a game session gets allocated dynamically.

This creates an important implication: Arma Reforger's texture streaming, terrain LOD system, and object draw distance settings are not just visual quality knobs. Each one directly adjusts how much of your shared 16GB gets consumed at a given moment, and how much pressure that puts on the memory bandwidth that both CPU and GPU need simultaneously.

The CPU side presents its own constraints. Zen 2's four cores run at up to 3.5GHz boost on both models (though sustained clock behavior differs due to the 7nm vs 6nm thermal envelope). Crucially, Van Gogh has only 4MB of L3 cache per CCX -- desktop Zen 2 dies have 16MB. This dramatically reduces the CPU's ability to absorb cache misses before hitting main memory. In a game like Arma Reforger, where the simulation layer (AI, game state, physics, network) hammers the CPU with irregular access patterns, that reduced L3 capacity matters more than raw clock speed. There is a secondary issue that compounds this: Chips and Cheese's analysis of Van Gogh found that under the default schedutil governor, clock speeds start at 1.4 GHz and ramp to 1.7 GHz quickly, but then sit at that frequency for hundreds of milliseconds before gradually climbing to maximum. For burst simulation workloads -- exactly the pattern Arma Reforger's entity ticks and event bursts generate -- this delayed ramp means the CPU is running below its peak precisely when it needs those clocks most. This is the physical reason why switching to the performance governor produces measurable gains.

The TDP envelope, controllable through SteamOS's Quick Access Menu or via Decky plugins like PowerTools, runs from 4W to 15W. At 15W -- the maximum the firmware allows by default -- the APU divides that budget between CPU and GPU dynamically via the SMU (System Management Unit) many times per second. For Arma Reforger specifically, the game tends to be CPU-bound in populated multiplayer scenarios and more balanced in solo play, which means the default 15W TDP setting is the correct starting point for multiplayer. Do not reduce it unless you are playing on battery and willing to drop frame targets.

The Translation Stack: DirectX 12 to Vulkan on Linux

This is the most technically interesting layer in the entire pipeline, and the one that determines whether Arma Reforger runs at all on the Steam Deck.

Bohemia Interactive built Arma Reforger on the Enfusion engine, their ground-up replacement for the Real Virtuality engine that powered the Arma series for over a decade. Enfusion was designed from the start as a cross-platform, DirectX 12-native engine. The engine's HLSL shaders, its resource management, its descriptor heap handling -- all of it is architected around D3D12's explicit GPU control model.

DirectX 12 does not exist on Linux. It is a Windows API. Running it on Linux requires a compatibility layer that translates D3D12 calls into Vulkan, which is the cross-platform graphics API that the Mesa RADV driver (the open-source AMD Vulkan driver on the Steam Deck) understands.

That translation layer is VKD3D-Proton, a fork of the original Wine VKD3D project that Valve's partner Hans-Kristian Arntzen maintains specifically for Proton. It is not a simple shim. VKD3D-Proton maintains its own pipeline state object (PSO) cache, handles D3D12's resource descriptor model, translates D3D12 root signatures into Vulkan descriptor sets, manages synchronization between command queues, and implements feature levels up to D3D Ultimate on RDNA2 hardware. Version 2.13 introduced VK_MESA_image_alignment_control support -- a Vulkan extension that Mesa exposes on the Steam Deck's RADV driver stack -- specifically to reduce memory bloat on AMD hardware. That same release fixed two Arma Reforger-specific rendering bugs: MSAA feature exposure for depth-stencil, and a bug in the MSAA resolve implementation when dealing with custom resolve formats. Both were cited explicitly in the v2.13 release notes as "Fixes Arma Reforger." Version 2.14 then extended these RDNA2 memory improvements further. If you were playing Arma Reforger under an older Proton build and noticed rendering corruption or unusual performance characteristics, these fixes are why updating your Proton version matters -- not merely for general improvements, but for game-specific correctness.

The practical consequence of this architecture is the shader compilation problem. When D3D12 games first run under VKD3D-Proton, the layer needs to translate the game's HLSL-compiled shader bytecode into Vulkan SPIR-V. This happens the first time each unique shader combination is encountered. You will see stutters the first time you play. You will also see Valve's Steam shader pre-compilation step running before first launch -- that step applies Valve's crowd-sourced shader cache for this title, which dramatically reduces first-play stutters but does not eliminate them entirely.

The community-documented launch option is:

echo "%command%" | sed 's/ArmaReforger_BE.exe/ArmaReforgerSteam.exe/' | sh

This sed substitution runs at launch time within the Proton environment's shell, replacing the BE executable path with the Steam executable path before Steam invokes it. BattleEye on Arma Reforger uses a server-side component that validates client integrity through runtime checks -- not purely through a privileged kernel driver -- which is why the Proton/Wine environment can satisfy those checks even when the initial process launch goes through the Steam executable path.

Proton Version Selection and Its Consequences

Not all Proton versions are equal for Arma Reforger. The choice of compatibility layer has direct performance and stability implications.

Stock Proton (Valve's official builds) packages Wine, VKD3D-Proton, and DXVK together with Valve's testing and stability verification. Proton Experimental ships the latest bleeding-edge versions of these components. Community builds like GE-Proton incorporate additional patches, codec support, and game-specific workarounds.

GE-Proton is worth trying if you encounter audio issues or specific rendering artifacts, as it includes additional codec libraries and media foundation patches that Valve's builds sometimes lack. For pure gaming performance on Arma Reforger, the difference between recent stable Proton releases and GE-Proton is typically marginal -- both ship comparable VKD3D-Proton versions as of early 2026.

One environment variable worth understanding: VKD3D_CONFIG. VKD3D-Proton exposes runtime configuration flags through this variable. It can control DXR (ray tracing) enablement, descriptor heap allocation strategies, and debug modes. As of VKD3D-Proton 2.x, DXR is now enabled automatically on RDNA2+ when the driver supports it -- the old VKD3D_CONFIG=dxr flag is no longer required to opt in, though VKD3D_CONFIG=no_dxr can be used to disable it explicitly. For the Steam Deck, DXR ray tracing on 8 CUs at 15W TDP would be prohibitively expensive and contributes no meaningful visual benefit given the render resolution, so this requires no active management for typical play. The variable VKD3D_CONFIG=single_queue disables asynchronous compute and transfer queues, which is occasionally useful for debugging stutters but should not be set in normal use.

Gamescope: The Compositor That Changes the Rules

Every game running on the Steam Deck in Game Mode passes through Gamescope, Valve's custom Wayland-based microcompositor. Gamescope is not an afterthought. It fundamentally changes how the rendering pipeline operates.

When Arma Reforger renders a frame at, say, 720p internally, Gamescope intercepts that frame before it reaches the display. It can then upscale it to 800p (the Deck's native resolution) using AMD FidelityFX Super Resolution (FSR). This happens at the compositor level, not inside the game. Gamescope implements FSR 1.0 as a post-process spatial upscaler applied to whatever the game renders. This means FSR works on Arma Reforger on the Steam Deck even though the game itself has its own native FSR 1.0 support -- Gamescope's version provides a fallback path and lets you set render resolution independently of the in-game setting.

Rendering Arma Reforger at 60-70% of the 1280x800 display resolution (roughly 768x480 to 896x560) with Gamescope's FSR upscaling active can yield meaningful FPS gains. The visual quality at these settings is acceptable for a military sim where situational awareness matters more than crisp textures. Community testing found performance in the 40-55 FPS range at all-low settings at 1280x800 in AI-heavy local scenarios, which provides headroom for the render scale reduction approach.

Gamescope also controls the Deck's frame rate limiter. Setting a 40 FPS cap through the Quick Access Menu instructs Gamescope to hold frame delivery at that cadence. At 40 FPS, the Deck's display switches to 40Hz refresh rate, and Gamescope synchronizes frame presentation to that interval. This eliminates tearing and produces extremely consistent frame times -- the subjective experience of 40 FPS locked with perfect frame pacing is substantially smoother than 45 FPS unlocked with variable frame times. For a game like Arma Reforger that will not consistently hit 60 FPS on the Deck, targeting 40 FPS locked is the sound strategy.

Graphics Settings: What Each Setting Actually Costs

Understanding what each graphics option in Arma Reforger actually does to the rendering pipeline -- specifically on a bandwidth-constrained unified memory architecture -- allows you to make principled decisions rather than following generic advice.

View Distance and Object Draw Distance are the most impactful settings on the Steam Deck, for CPU and memory bandwidth reasons as much as GPU reasons. Arma Reforger's open world on Everon spans hundreds of square kilometers. Every entity, terrain chunk, and static object within the view distance has to be processed by both the CPU (game simulation, culling, LOD selection) and the GPU (draw calls, geometry processing). On a four-core Zen 2 processor with 4MB of L3 cache, the CPU culling work for a 4000-meter view distance in a populated multiplayer scenario creates significant pressure. Setting view distance to 1600-2000 meters and object draw distance to Medium represents a practical ceiling for consistent performance.

Grass Quality and Grass Draw Distance deserve special attention because they disproportionately impact fragment shader load on the RDNA 2 GPU. Grass rendering in Enfusion involves high-density geometry with alpha testing. On a GPU with only 512 FP32 shader processors clocked at 1.6GHz, this geometry density is expensive. Community testing consistently finds that Grass Quality set to Lowest and draw distance reduced to 80-100 meters can contribute 15-20 FPS in open terrain scenarios. The tactical impact is minimal -- grass at 100 meters still provides concealment context for close engagement.

Environment Quality controls cloud simulation resolution and atmospheric rendering. At higher settings, Enfusion's volumetric cloud system requires multiple passes of ray marching through a 3D noise volume -- a significant fragment shader consumer. Setting Environment Quality to Low substitutes simplified cloud rendering with a meaningful performance return. Community testing consistently puts the gain from this single setting at 15-20 FPS.

Shadow Quality controls the resolution of the shadow map cascade. Higher settings increase the shadow atlas texture size, consuming memory bandwidth for sampling and storage. Medium shadow quality represents a balanced choice. The contact shadows sub-setting adds a screen-space pass for small-scale geometry and should be disabled on the Deck.

Texture Detail is less impactful on the Steam Deck than on discrete GPU systems. Because UMA means textures already reside in the same physical memory the CPU uses, texture detail primarily affects total memory footprint and sampling bandwidth. Medium texture detail reduces memory pressure without dramatic visual quality loss given the 800p display resolution.

Anti-Aliasing requires careful consideration. Hardware Anti-Aliasing (MSAA) renders geometry at higher sample rates and is extremely expensive on a bandwidth-limited UMA system -- avoid it entirely. Post-processing AA (FXAA or TAA) operates in screen space after rendering and is comparatively cheap. FXAA at High is the recommended option: it runs as a single post-process pass with modest cost and provides edge smoothing appropriate for the Deck's display resolution.

CPU-Side Bottlenecks and the Arma Simulation Model

Arma Reforger's simulation model is fundamentally different from most shooters, and understanding this explains why even desktop CPUs struggle -- and what that means for the four-core Zen 2 in the Steam Deck.

Every AI entity in Arma Reforger runs a full behavior tree evaluation, pathfinding query, perception update, and state machine tick. These are not simplified LOD-reduced simulations. The Enfusion engine's Enforce Script runs this logic in a managed scripting environment layered over C++, which adds interpreter overhead on top of the underlying computational cost. Multiplayer servers offload this to the server-side CPU, but the client still processes animations, audio, rendering decisions, and game state updates for every entity within network relevance range.

The practical consequence is that joining a server with 60+ players and active AI combat will be the hardest test for the Zen 2 cores. On SteamOS, the schedutil CPU frequency governor (the default) sometimes produces sub-optimal behavior for games that issue burst workloads followed by idle periods -- the governor may not ramp up clocks fast enough. The performance governor locks clocks at maximum, eliminating this latency at the cost of higher power draw and heat.

# Set performance governor (resets on reboot)
$ echo performance | sudo tee /sys/devices/system/cpu/cpu*/cpufreq/scaling_governor

Note that SteamOS will reset this on reboot, and that 15W TDP at locked performance clocks will increase heat substantially. The Decky Loader plugin ecosystem provides a more user-friendly alternative. Decky Loader is a homebrew plugin launcher for SteamOS, installable from decky.xyz in Desktop Mode; once installed, the PowerTools plugin exposes CPU clock controls, SMT toggles, and GPU clock adjustments through the Quick Access Menu. For Arma Reforger, enabling all four cores with SMT enabled (the default) is correct -- disabling SMT does not help in this title's threading model.

Memory Allocation and the UMA VRAM Question

The Steam Deck's BIOS allows configuration of the UMA Frame Buffer Size -- the portion of the 16GB LPDDR5 pool permanently reserved for GPU-local allocations. By default this is set to 1GB. VKD3D-Proton can allocate additional memory beyond this reservation dynamically, but the "local" designation affects how the hardware prefetcher and cache hierarchies treat those pages.

For Arma Reforger, the question is whether increasing the UMA frame buffer reservation improves performance. The answer is nuanced. Very large UMA reservations (4GB+) can actually reduce performance in some workloads because the GPU-local region competes with CPU-accessible memory for the same physical pages, giving the OS less flexibility to allocate large contiguous regions for other purposes. A 2GB or 4GB UMA reservation is a reasonable experiment -- the game's texture memory footprint at medium-low settings fits within this range, and having those textures in a GPU-designated region may reduce the frequency of bandwidth-costly re-fetches.

# Power off completely, then hold Volume Up and press Power
# Navigate: Advanced > UMA Frame Buffer Size
# Return to default if instability occurs

The BattleEye Situation in 2025 and 2026

BattleEye has had a complex history with Linux. The anti-cheat vendor announced Linux (Proton) support in 2021 following pressure from Valve. The actual implementation uses kernel-level and user-space components, and Valve's Proton BattleEye Runtime enables this for games that use supported BE versions. (The runtime is a free tool in your Steam library -- search "Proton BattleEye Runtime" and install it as you would any other tool.) The complication with Arma Reforger is that the game uses a version of BattleEye that Proton's BE Runtime does not support -- the same limitation that affected Escape from Tarkov. This is why installing the runtime does not solve the launch issue for Reforger even though it does for games like Arma 3.

For Arma Reforger, the ArmaReforgerSteam.exe launcher bypass has become the de facto standard for Linux/Deck play. It is not a hack -- it is simply using the Steam-integrated launch path that Bohemia provides as an alternative to the BattleEye-wrapped path. The Bohemia community wiki confirms that connecting to BattleEye-secured servers and playing as normal remains possible using this method. The reason this works is that BattleEye on Arma Reforger relies on server-side runtime integrity checks; bypassing the BE launcher executable on the client side satisfies those server-side checks, because the checks do not require the client to have launched via the BE wrapper -- they validate running process state, not launch path.

Storage, Loading Times, and the microSD Reality

Arma Reforger's install footprint is substantial and continues to grow with updates. The game's asset streaming model means that slow storage creates visible hitching as terrain chunks, texture mipmaps, and entity assets stream into memory during play.

The Steam Deck's internal NVMe storage (available in 256GB, 512GB, or 1TB depending on model) delivers sufficient sequential read speeds for smooth streaming. microSD cards are a meaningful concern. A fast A2-rated microSD card (UHS-I U3 / V30) delivers roughly 150-200 MB/s sequential reads -- substantially slower than the Deck's NVMe options, which achieve 800-1000 MB/s. The original 64GB LCD model used eMMC storage over PCIe Gen 2 x1, which provides roughly 200-250 MB/s sequential reads -- faster than a microSD but significantly below the NVMe models. If internal NVMe storage is available, use it for Arma Reforger.

An underappreciated optimization: ensuring Arma Reforger's profile and cache directories also land on fast storage. Under Proton, the game writes its profile data to ~/.local/share/Steam/steamapps/compatdata/1874880/pfx/drive_c/users/steamuser/Documents/My Games/ArmaReforger/. This directory contains the resourceDatabase.rdb cache files that the game uses for faster subsequent loads. These files should be on the internal drive.

"Unsupported" Does Not Mean Broken

Valve's "Unsupported" rating for Arma Reforger on Steam Deck means specifically that Valve's automated compatibility testing found issues that prevent it from being rated Playable or Verified. It does not mean the game is broken. Valve's certification process checks for specific criteria: controller navigation of all menus, no required keyboard/mouse interaction in the flow to start play, no performance issues in their standardized test scenario, and proper display scaling.

Arma Reforger fails these checks for predictable reasons. The game's menu system -- especially the mod browser and server browser -- benefits from keyboard input and precise pointer interaction. The performance profile falls outside what Valve considers acceptable for a portable device. And Bohemia Interactive has not submitted the game for Deck review, which would be required for a Verified rating.

None of this prevents competent play. The Steam Deck's right trackpad serves as a precision cursor for menus that require mouse interaction, and this works well in practice. The "Unsupported" label is a Valve certification status, not a verdict on whether the game functions. Do not expect Bohemia to optimize Arma Reforger specifically for the Steam Deck -- future engine updates may improve performance, but these will target the broader PC and console player base. The optimizations detailed in this guide exist because Deck players learned to work within constraints.

Practical Configuration Summary

The following represents a synthesis of the analysis above into a workable starting configuration. Every value here has a technical justification rooted in the hardware and software architecture described throughout this guide.

SteamOS Quick Access Menu: TDP Limit: 15W (do not reduce for multiplayer). GPU Clock: leave on auto. Frame Rate Limit: 40. Half Rate Shading: Off (creates visible artifacts in Reforger's deferred renderer). Scaling filter: FSR if rendering below 1280x800 internally.

In-game graphics (baseline for multiplayer):

Resolution:              1280x800 (or 960x600 with Gamescope FSR active)
Window Mode:            Fullscreen
View Distance:          1600m
Object Draw Distance:   Medium
Terrain Surface Detail: Flat (lowest option)
Environment Quality:    Low
Grass Quality:          Lowest
Grass Draw Distance:    80m
Shadow Quality:         Low
Distance Shadows:       Off
Contact Shadows:        Off
Model Geometric Detail: Low
Texture Detail:         Medium
Texture Filtering:      High (near-zero cost, prevents blurring at distance)
Hardware AA:            Off
Post-Processing AA:     FXAA High
Depth of Field:         Simple
Motion Blur:            Off

For solo play or low-population servers, Environment Quality can be raised to Medium, shadows raised to Medium, and grass draw distance pushed to 150m with minimal impact.

The Deeper Lesson About Constraints and Understanding

There is something worth extracting from this exercise beyond the settings list. Arma Reforger running on the Steam Deck is a collision between a simulation built for dedicated gaming hardware and a handheld designed around power efficiency and portability. Making it work requires understanding six distinct layers of technology simultaneously: the game's simulation and rendering architecture, the DirectX 12 API abstraction, VKD3D-Proton's Vulkan translation layer, the RADV Mesa driver, the Gamescope compositor, and the physical constraints of the Van Gogh APU.

Players who treat this as a black box and simply turn settings down will get a playable game. Players who understand the layers will get the same or better performance with higher visual fidelity, because they know which settings are constrained by bandwidth, which by compute, which by the CPU's simulation load, and which by the translation overhead of VKD3D-Proton's PSO cache.

The fact that it produces playable tactical military simulation at 40 FPS on a 15W handheld device is, when you understand everything that had to go right to make it happen, remarkable.

Sources and Further Reading

• Bohemia Interactive Community Wiki, Arma Reforger Linux/Proton guide (Uncle_Sagbag): community.bistudio.com/wiki/User:Uncle_Sagbag/Sandbox
• Bohemia Interactive Community Wiki, Arma 3 on Linux (official): community.bistudio.com/wiki/Arma_3:_Play_on_Linux
• Chips and Cheese, "Van Gogh: AMD's Steam Deck APU" (March 2023) -- source for CPU/GPU bandwidth figures and clock ramp analysis: chipsandcheese.com/p/van-gogh-amds-steam-deck-apu
• Jon Peddie Research, "AMD's Second-Gen Steam Deck APU -- OLED" (December 2023): jonpeddie.com
• VKD3D-Proton v2.13 release notes (Arma Reforger MSAA fixes, VK_MESA_image_alignment_control): github.com/HansKristian-Work/vkd3d-proton/releases/tag/v2.13
• VKD3D-Proton v2.14 release notes (RDNA2/3 VRAM bloat reduction): github.com/HansKristian-Work/vkd3d-proton/releases/tag/v2.14
• VKD3D-Proton repository and configuration reference: github.com/HansKristian-Work/vkd3d-proton
• Tom's Hardware, "Steam Deck's Custom AMD Processor Exposed" (December 2023): tomshardware.com
• Steam Deck official tech specs (OLED: 6400 MT/s LPDDR5; LCD: 5500 MT/s LPDDR5): steamdeck.com/en/tech
• Gamescope documentation: wiki.archlinux.org/title/Gamescope
• ninelore, "Play Arma on Linux" (ongoing guide, last updated 2024): 9lo.re/project/armaonlinux/
• Steam community discussions, Arma Reforger (App ID 1874880): steamcommunity.com/app/1874880
• Valve/Proton GitHub issue #5847 -- Arma Reforger BattleEye launch failure: github.com/ValveSoftware/Proton/issues/5847
• Decky Loader (homebrew plugin launcher for SteamOS): decky.xyz
• PowerTools plugin for Decky Loader (CPU/GPU tuning via Quick Access Menu): git.ngni.us/NG-SD-Plugins/PowerTools