The long-running game of “can it run DOOM?” has acquired an especially practical-looking contestant: the FNIRSI DMC-100 multimeter. Developer Artur Bieniek has adapted doomgeneric to run on the compact measuring device’s Artery AT32F415 chip, transforming a tool intended for electrical work into a colour-screen machine capable of playing Freedoom: Phase 1.

This is more than a boot-to-title-screen novelty. The port reportedly includes the first episode’s E1M1 through E1M9 maps, four save slots, intermission sequences and the episode finale. Input can even come from a DJI RC-N1 drone controller. It is an absurd combination in the best sense: a meter built to inspect circuits now has enough room in its routine to confront a digital army of demons.

It is important, though, to be precise about what is running. The project uses Freedoom: Phase 1, rather than presenting itself as the original commercial DOOM game. The distinction matters because the port’s stated playable content is Freedoom’s first episode, using the familiar E1M1–E1M9 level progression. That makes this a remarkable embedded-game project without blurring the line between the engine work and the game data being used.

From measuring instrument to game hardware

A multimeter is designed to measure electrical properties in a circuit. The DMC-100’s ordinary job is not entertainment; its display, controls and internal processor exist to support its measuring role. Bieniek’s work demonstrates that the device’s computing hardware can be repurposed for a very different task when custom firmware and a suitable game engine are brought together.

At the centre is the Artery AT32F415, the chip identified as the multimeter’s main computing component. In simple terms, this is the embedded processor that normally coordinates the device’s functions. Embedded hardware is a broad term for computing systems built into a dedicated product rather than sold as a general-purpose computer. A multimeter is a classic example: it has a processor, firmware and a display, but those components are arranged around one focused task.

That focus is exactly what makes a project like this entertaining. The hardware was not marketed as a handheld gaming system, yet the port reaches beyond a static demo. A title screen, level transitions, save capability and an ending imply that the game flow has been accommodated rather than merely a single scene rendered for a photo.

The price point adds to the appeal. The FNIRSI DMC-100 is described as a $30 device, putting this experiment in the realm of relatively inexpensive consumer hardware rather than a rare development board or a purpose-built retro handheld. That does not make the project simple, however. The tool list and compiler requirements show that the accessible hardware is paired with a decidedly technical software process.

What doomgeneric brings to the project

doomgeneric is the engine layer used for this port. Its relevance is in the name: it is built to make adapting DOOM-style engine functionality to varied platforms more manageable. Every target still needs platform-specific work, because the target must provide a display, audio or timing where applicable, storage behavior and a way to accept controls. In this case, the achievement is getting that work to coexist with the DMC-100’s hardware and firmware constraints.

Related coverage includes DOOM Runs on a $30 FNIRSI Multimeter.

The result is not simply “DOOM on anything” as a slogan. It is a small embedded-systems adaptation involving a screen, the device’s processor, firmware space and external control support. The optional DJI RC-N1 setup is particularly revealing. A drone controller is not an obvious gamepad, so making it usable as an input device illustrates the project’s willingness to treat available peripherals as adaptable parts of the experience.

That spirit is why unconventional ports remain such a durable part of gaming culture. They are playful, but they also make technical limitations visible. A conventional PC installation hides countless decisions behind an operating system, standard drivers and plentiful storage. On a dedicated instrument, each requirement has to fit the device and its available resources.

There is a wider creative angle here as well. Experiments that reframe fixed-purpose devices as flexible computing platforms are one small answer to questions about tools, authorship and experimentation—subjects also raised in this discussion of what creation means. The multimeter project is not presented as a replacement for its original purpose; it is a demonstration of what a curious developer can reveal inside familiar hardware.

The build requirements are unusually specific

Anyone tempted to reproduce the port should not mistake the low-cost device for a plug-and-play gaming mod. The stated process was developed under Linux, although the basic file-copying portion can work from any system capable of copying files to a USB drive. A USB-C cable is required alongside the DMC-100 itself.

The software requirements include GNU make 4.3 or newer, clang and ld.lld version 20 or later, Python 3 and Git. Several LLVM utilities are also named: llvm-objcopy, llvm-nm, llvm-size and llvm-dwarfdump. These are development tools rather than game-launcher dependencies. They help build, inspect and package the firmware image that ultimately has to fit on the device.

Two names in that list are worth unpacking:

  • clang is a compiler: it converts the project’s source code into machine code for the target hardware.
  • ld.lld is a linker: it combines compiled pieces and arranges them into a final program image that can be placed in the device’s memory.

Memory layout is not an academic concern in this build. The project notes that clang 19 or older produces firmware that does not fit, with the image running into the settings page. In other words, the final program can become too large for the designated space and collide with a part of memory reserved for device settings. The setup used clang 23, lld 23 and Python 3.14, while the listed baseline requires clang and ld.lld 20 or newer.

That caveat is one of the most useful practical details in the project. It means that “a compiler is a compiler” is not an assumption to make here. Toolchain versions can affect code size and layout, and this particular target has little room for variance. For builders troubleshooting an image-size failure, using an older compiler is a clear place to investigate before assuming the hardware or game assets are at fault.

Tests, restoration tools and small setup traps

The project also lists optional and test-related packages. Running tests requires clang’s sanitizer runtime, identified on Ubuntu as libclang-rt-20-dev. Sanitizers are tools used during development to help catch certain classes of program errors. The testing stack additionally calls for mtools and dosfstools, including fsck.fat, while Renode tests require Renode 1.17 and Pillow.

Those details may sound like overkill for putting a game on a meter, but they underline the difference between installing a finished game and building firmware from source. The project includes installation and restoration scripts that use udisks2, and an optional USB test script uses it as well. A restore path is especially significant in the context of a multipurpose electronic instrument: anyone exploring the modification should understand the provided workflow and recovery tooling before changing the device.

One deceptively simple restriction is also called out: the checkout path must not contain spaces. A checkout here means the local folder containing the project files copied from version control. Build scripts sometimes handle spaces in file paths poorly, causing commands to treat one folder name as multiple arguments. The easiest solution is simply to place the project in a plainly named directory with no spaces.

For Ubuntu 24.04 users, the supplied dependency command installs the core packages except Renode. It includes make, clang-20, lld-20, llvm-20, the clang runtime package, Python 3, Git, certificate support, mtools, dosfstools and python3-pil, while setting the LLVM 20 binary directory in PATH. Builders should read that as a known starting configuration, not as proof that every Linux distribution will package the same components under identical names.

Why this particular port stands out

DOOM adaptations often earn attention simply because the game engine has travelled so widely, from unexpectedly tiny gadgets to household equipment. This one has a stronger hook than a bare novelty boot because its host device has a sharply defined non-gaming identity. A multimeter is associated with diagnosis, repair and measurement; watching it load an episode-based first-person shooter creates a contrast that is instantly understandable even to people who have never compiled firmware.

It also demonstrates a useful hierarchy of accomplishment. Running a game at all is the first hurdle. Building a version that is in colour, supports a complete episode route, includes save slots and reaches intermissions and a finale is a more meaningful measure of integration. Adding a drone-controller option makes the setup stranger, but also expands it from a screen experiment into something intended to be played.

For players, the FNIRSI DMC-100 is not suddenly a sensible replacement for a PC, console or purpose-built handheld. Its screen and intended controls remain those of a measuring instrument, and the build process demands familiarity with command-line development tools. But that is not the point. The port turns an inexpensive technical object into a compact demonstration of software portability, hardware knowledge and the enduring appeal of making old game technology appear somewhere it has no business being.

For tinkerers with the right equipment and confidence, the project lays out a concrete route: obtain the DMC-100, connect it over USB-C, prepare a compatible build environment, respect the compiler-version constraint, and use the project’s installation and restoration utilities. For everyone else, it remains a delightful reminder that a little screen, a capable chip and a determined developer can turn a circuit-measuring tool into a tiny window onto Freedoom’s first episode.