# elfcat: turning an ELF binary into a readable HTML page

> elfcat is a small Rust command line tool that reads an ELF binary and writes an HTML file rendering it as a hex dump, so a binary can be looked at in a browser and shared as a single file. It is published on the Rust package registry, carries a permissive licence, and its own roadmap admits that large files are still slow to open.

**rbakbashev/elfcat** — ELF visualizer. Generates HTML files from ELF binaries.

- Repository: https://github.com/rbakbashev/elfcat
- Website: https://crates.io/crates/elfcat
- Stars: 994 · Forks: 28
- Language: Rust
- License: Zlib
- Published: 2026-10-20 · Updated: 2026-10-20 · Language: en
- Canonical page: https://hysenlabs.com/projects/rbakbashev-elfcat

## What the tool produces

elfcat is an ELF visualiser, and the output is a single HTML file. You point it at a binary and it writes an HTML page next to the binary, showing the contents as a hex dump with an ASCII column, which you then open in a browser. That is the whole product, and the value of it is in the format rather than in the analysis. A terminal hex dump is fine for the person who made it, but an HTML file can be sent to somebody, opened on a machine with no tooling, and read at whatever width the reader's window happens to be. The example output the README links to is a tiny hand-written program, which is a useful hint about the intended scale. The project is written in Rust, the package is published on the Rust registry under the name elfcat, the manifest describes the edition it targets, the version is 0.1.10, and the licence is the permissive Zlib one, with the text in a licence file at the root of the repository.

## The workflow, from source to a page

The README walks through a complete example, and it is worth following because it shows what the tool is for. You write a small assembly program that writes a string to standard output, you assemble it, you link it with a linker script of your own, and then you run the visualiser on the result:

```shell
cargo install elfcat
elfcat path/to/file
```

The full sequence the README gives assembles the file in the 64 bit ELF format, links it with the custom script, runs elfcat and opens the generated page:

```shell
nasm hello_world.s -f elf64
ld hello_world.o -o hello_world -n -T link.ld
elfcat hello_world
xdg-open hello_world.html
```

The linker script in the example is worth a second look, because it contains a comment that explains the offset choice, placing the first segment at the minimum mapping address of the virtual machine plus the file offset of that segment. A reader who has never looked at an ELF by hand will find that comment confusing and that confusion is the point of the tool.

## Why HTML, and what that costs

Producing a web page instead of printing to a terminal is a deliberate trade, and it is worth being clear about both sides of it. On the good side, the artefact is self-contained, portable and easy to attach, and it renders with the fonts and the zoom of the reader's own browser, so a wide hex dump is readable on a laptop in a way a fixed-width terminal is not. On the bad side, the same decision produces a document that has to be parsed and laid out by a browser, and the tool's own list of things to do starts with a better text renderer to fix the poor performance when opening big files. That is an admission, written by the author, that the current renderer struggles with large inputs. The other cost is that the format is ELF only, and the roadmap mentions the visualisation of virtual memory mappings as a further step, which tells you the tool is aimed at the file format and not at executables in general.

## The roadmap, and what it says about the current state

The README has a short section of upcoming features, and it is a good indicator of the project's maturity. The first item is a better text renderer to fix the performance when opening big files. The second is the ability to tune the width instead of the hardcoded sixteen bytes per line, so the layout is currently fixed by the author rather than by the reader. The third is a visualisation of virtual memory mappings, which is the feature that would turn a hex dump into something closer to a memory map of the process image. The fourth is a dark theme, and the fifth is highlighting the bytes in the ASCII column, which is a small touch that says what the author cares about. A crate at version 0.1.10 with five items on its list is a project in progress, and the presence of a changelog file and a forks list in the wiki suggests that other people have taken it further.

## Where elfcat fits against the standard tooling

The honest comparison is with the tools every machine already has. The standard binary utilities can print sections, symbols and headers in a structured form, can disassemble, and are written to stream a file of any size, so they are what a person doing analysis should reach for. elfcat is not trying to replace them and does not claim to, because it prints bytes rather than interpreting them. What it offers instead is a single artefact that is pleasant to read and easy to pass on, which the standard tools do not produce. The one case where it is clearly the right tool is a small binary, a teaching example, or a fragment of a file where the point is to see the bytes and the context around them. A second realistic use is a quick check of what is actually inside a file that claims to be one thing, where a hex view answers the question faster than a header dump.

## The state of the repository

The tree is small, which is what you would expect from a single-purpose tool. There is a source directory, a manifest, a lock file, a changelog, a licence file, a readme and a formatting configuration, and nothing else, so the project is one crate rather than a workspace. It is published to the Rust registry rather than through tagged releases, and the registry page is the home page the README points at, which means the install path and the release path are the same thing. The last push to the branch was on 2026-04-05, and the manifest still names a single author, Ruslan Akbashev, with the repository listed under the same handle. The forks list in the wiki is the interesting part for anyone assessing the project, because a tool that people have forked is a tool whose ideas have been carried further than its own changelog suggests.

## Conclusion

elfcat fits somebody who wants to look at a small binary in a browser, share the result as one file, or paste it somewhere that does not accept a terminal, and it fits a teacher who wants a hex dump that a student can open without installing anything. It does not fit a reverse engineer, because the standard tooling gives structured output, handles large files and disassembles, and it does not fit anything that is not an ELF file. Before you reach for it, look at the size of the binary, because the tool's own list of upcoming work starts with a text renderer to fix the performance on big files, and check the changelog, since the last push was on 2026-04-05 and the crate is still on a 0.1 version.

## FAQ

### What is elfcat?

It is a small Rust command line tool that reads an ELF binary and writes an HTML file rendering the contents as a hex dump with an ASCII column, published on the Rust registry under the Zlib licence.

### How do I install and run elfcat?

Run cargo install elfcat, then run elfcat with the path of a binary. The HTML file is written next to the binary, as the example in the README shows when it produces hello_world.html.

### What does the elfcat output show?

The bytes of the binary laid out in a hex view with an ASCII column. The worked example in the README builds a small assembly program by hand, links it with a custom linker script, and renders the result.

### What features are planned for elfcat?

A better text renderer to fix the performance when opening big files, a tunable width instead of the hardcoded sixteen bytes, a visualisation of virtual memory mappings, a dark theme, and highlighting of the bytes in the ASCII column.

### How does elfcat compare with the standard binary utilities?

The standard tools print structured headers, sections and symbols, can disassemble, and handle files of any size, so they are the right choice for analysis. elfcat produces one shareable HTML view of the raw bytes, which is better for reading a small binary and for handing it to somebody else.

### Which licence is elfcat released under?

The Zlib licence, with the terms in the licence file at the repository root and the same identifier recorded in the package manifest.

## Sources

- [Issues](https://github.com/rbakbashev/elfcat/issues)
- [License: Zlib](https://github.com/rbakbashev/elfcat/blob/master/LICENSE)
- [Project website](https://crates.io/crates/elfcat)
- [rbakbashev/elfcat on GitHub](https://github.com/rbakbashev/elfcat)
- [README](https://github.com/rbakbashev/elfcat/blob/master/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/rbakbashev-elfcat