Linux export: builds and distribution files — documentation

Architectures, templates, PCK, C# publication, executable permissions and startup diagnostics.

Linux export creates an executable from a Linux template and packages project data. It neither copies the editor nor compiles engine source. Successful export alone does not establish that the result runs on the target system.

Prepare and export

Save the project, assign its main level or startup prefab and verify local execution.
Add a Linux preset in Project → Export. You need a version 1.0.0 Linux template matching the architecture and debug/release mode. A platform menu entry does not establish template availability.
Set binary_format/architecture, initially x86_64. The template, third-party native libraries and C# publication must match the target architecture.
Check Resources/export filters. Enable at least one texture format: texture_format/s3tc_bptc or texture_format/etc2_astc. The first defaults to true, the second to false. Check format support on the target GPU, not just CPU architecture.
Choose Export Project and a separate output folder outside project sources. Disable Export With Debug for release, or keep it enabled for diagnostics. Do not substitute a release template for a debug template or vice versa.
Transfer the complete result to Linux, extract into a separate folder and launch from a terminal. Test startup, level loading, saves, audio and rendering on that machine.

For custom templates, enable Advanced Options and set custom_template/debug and custom_template/release. The exporter checks the custom ELF architecture against the preset. A Windows .exe is not a Linux template. Standard template names follow linux_debug.x86_64 and linux_release.x86_64; these names appearing in source do not establish installed files.

Select an architecture

Value	Target CPU
`x86_64`	64-bit x86.
`x86_32`	32-bit x86; requires matching libraries and loader.
`arm64`	64-bit ARM.
`arm32`	32-bit ARM.
`rv64`	64-bit RISC-V.
`ppc64`	64-bit PowerPC.
`loongarch64`	64-bit LoongArch.

These are preset choices, not a list of available, verified builds. Each requires a suitable template. The current .NET plugin forms publication branches for x86_64, x86_32, arm64 and arm32; this also does not guarantee an available .NET runtime pack and every native dependency. General preset choices rv64, ppc64 and loongarch64 do not establish C# export support. Linux export likewise does not guarantee compatibility with an arbitrary BSD system.

Distribute the complete output

For MyGame.x86_64 with binary_format/embed_pck disabled, the exporter creates adjacent MyGame.pck. Do not rename only one of these files. Depending on the project, output can also contain a data_… C# publication directory and native .so libraries. Preserve the full output structure.

Setting or action	Result
`binary_format/embed_pck = false`	Separate PCK; the default.
`binary_format/embed_pck = true`	PCK embedded in the executable. Does not automatically embed all external libraries or C# data.
Export Project with `.zip` extension	Linux exporter packs the project export result in ZIP.
Export PCK/ZIP	Project data only, not a standalone executable game.
`debug/export_console_wrapper`	0: no wrapper; 1: debug only; 2: debug and release. Defaults to 1; wrapper extension is `.sh`.

Embedded PCK must be smaller than 4 GiB for 32-bit export. Use a suitable architecture or separate PCK for a large project rather than trying to bypass the check by renaming files.

C# and dependencies

C# requires a suitable .NET export template and an SDK on the build machine. The plugin runs dotnet publish for the target runtime identifier and checks for the project assembly or NativeAOT library. Resolve MSBuild/publish errors before packaging; copying Windows publication output does not replace Linux publication.

dotnet/embed_build_outputs defaults to false: published files are distributed beside the executable in a generated data_… structure. With true, they are packed as project resources; third-party native extensions can still require external files. binary_format/embed_pck and dotnet/embed_build_outputs are separate settings. Do not discard .so or other files merely because the main PCK is embedded.

Templates and dependencies determine system-library requirements. Test on the target distribution: running on the build machine does not establish another system’s ABI, loader, graphics driver or dependency compatibility.

Run and diagnose

Open a terminal in the extracted directory. For the example filename MyGame.x86_64:

chmod +x ./MyGame.x86_64
./MyGame.x86_64

These are Linux commands; they were not executed by the Windows check. After extraction, executable permissions can depend on the archive tool and filesystem. The standard Linux exporter specifies mode 0755, but inspect the transferred file.

Symptom	Check
`Permission denied`	Execute permission, directory access and the `noexec` mount option; chmod alone does not fix noexec.
`Exec format error`	ELF architecture/format, then matching native dependencies.
Existing file reports `No such file or directory`	Path and availability of the ELF loader required by the build.
PCK not found	PCK name/location and complete directory structure after transfer.
C# or `.so` fails to load	Complete data/native files, correct publication target and loader messages.
Vulkan/OpenGL device creation fails	Driver and target GPU support for the selected renderer.

Execution error causes are documented in Linux execve(2). For remote SSH launch, see Remote Deploy. RECKFELL_SCRIPT_ENCRYPTION_KEY and encryption require matching templates and settings: PCK encryption.

The installed Windows editor was used to check an isolated Linux preset, option defaults and setting changes. Packaging, .NET publish, permissions and Linux execution were reviewed against source and OS documentation only; this run does not establish a finished Linux package, target ABI/graphics or support across all architectures.