Executable Binary MIME Type

What does application/x-executable mean?

The application/x-executable media type is a deployed label for a native executable, most often an Executable and Linkable Format (ELF) program on Unix-like systems. It is not a complete format specification. The label describes the file's role, while ELF describes the container and its headers.

The freedesktop.org shared MIME database calls this type "Executable" and detects ELF-family files by their header bytes. It does not assign the type a filename glob or standard extension.¹ That distinction matters because Unix executables commonly have no suffix at all.

How do you identify an executable binary?

An ELF file begins with 7F 45 4C 46, which is 0x7F followed by the ASCII letters ELF. The next bytes record its 32-bit or 64-bit class, byte order, ELF version, operating-system ABI, and ABI version.⁴

Those four bytes identify the ELF family, not necessarily an executable. The ELF header's e_type field distinguishes several roles:⁴

This is why a detector should parse the header instead of treating 7F 45 4C 46 as proof that a file is directly runnable. The freedesktop.org database has more specific types for ELF object code and shared libraries, then uses application/x-executable as a broad executable fallback.¹

You can inspect a suspected ELF file without launching it:

file --mime-type path/to/program
readelf -h path/to/program
readelf -l path/to/program
readelf -d path/to/program

GNU readelf supports 32-bit and 64-bit ELF files. Its header, program-header, section, symbol, relocation, and dynamic-table views expose much more than a MIME guess does.⁵ LLVM's llvm-readobj offers similar low-level inspection across object formats.⁶

Does application/x-executable have a file extension?

No portable extension belongs to this media type. A Unix command such as grep or my-service normally has no suffix. .bin is sometimes used for installers or arbitrary binary data, but it does not uniquely identify an executable.

Poly has a narrower internal convention: it maps .obj filenames to application/x-executable. This is useful for consistent storage and lookup inside Poly, but it should not be treated as a universal MIME association. In the freedesktop.org database, ELF relocatable objects use application/x-object and usually .o, while .obj can refer to unrelated formats.¹

The surrounding ecosystem therefore uses several labels for different binary families:

Changing a suffix or Content-Type header does not convert one binary format into another. The target operating system, CPU architecture, ABI, loader, libraries, and actual machine code still have to match.

How do you open an application/x-executable file?

A browser has no native executable viewer and should not run a response merely because a server supplies this media type. Downloading the bytes is not the same as safely opening them.

For static inspection:

• Use readelf or llvm-readobj for ELF headers, sections, symbols, relocations, and dependencies.⁵⁶
• Use objdump or llvm-objdump when you need section contents or disassembly.⁷
• Use Ghidra for interactive reverse engineering. Ghidra can import ELF, PE, raw binaries, and other executable formats, then analyze a recognized program without requiring you to launch it.⁸

Support in Poly

Poly recognizes .obj filenames as application/x-executable. It can store, sync, share, version, download, and find these files by name. The mapping is classified as an unknown binary rather than a text or executable preview category, so Poly's format-specific processing stops there:

• Poly does not parse executable or object-file headers.
• Architecture, sections, symbols, imports, dependencies, embedded strings, and instructions are not indexed.
• There is no thumbnail, hex view, disassembler, or other in-app content preview.
• The Poly agent cannot inspect or explain the binary contents.

For searchable analysis, save trusted tool output such as readelf -a or llvm-readobj --all as a separate text file next to the original. Poly can index that report through its normal text workflow, while preserving the binary unchanged.

Can you convert an executable binary?

There is no general conversion from an executable to source code, PDF, text, another CPU, or another operating system. Choose the operation that matches your goal:

• Export headers, symbols, relocations, or disassembly as text for review.
• Extract debug information with format-aware tooling when it is present.
• Rebuild from source for another architecture, ABI, or operating system.
• Package the original in an archive if the goal is transport, not format conversion.

A decompiler can produce a higher-level approximation, but it cannot reliably recover original names, types, comments, build settings, or source structure that compilation removed. Stripped binaries preserve even less symbolic context.

Security and compatibility

Treat every unfamiliar executable as active content. Do not run it merely to discover what it is. Linux's execve can reject a file because its format is unrecognized, its architecture is wrong, an interpreter is missing, or execute permission is denied, but a successful launch says nothing about whether the program is trustworthy.⁹

Static inspection also involves parsers handling attacker-controlled input. Keep analysis tools patched, work on a copy, verify hashes and signatures when available, and use an isolated environment for hostile or unknown samples.

Compatibility requires more than an ELF magic number. Check at least the CPU machine value, 32-bit or 64-bit class, byte order, operating-system ABI, requested program interpreter, and needed shared libraries. A valid ELF executable built for another architecture or loader can be perfectly well-formed and still be unusable on the current system.