Holani

ATARI LYNX EMULATOR CORE

Holani

Holani is a cycle-stepped Atari Lynx emulator implemented as a library with an available libretro core (holani-retro). It aims for closer-to-hardware Lynx timing and is written in Rust under the GPL-3.0 license.

Jump to download ↓Jump to setup guide ↓

Holani emulator screenshot.

Atari LynxPRIMARY SYSTEM

History documentedPROJECT BEGAN

Open sourcePROJECT MODEL

WHY IT MATTERS

Why Holani exists

Holani was created to provide a cycle-stepped, accuracy-oriented implementation of the Atari Lynx CPU and hardware subsystems. The project exposes multiple frontends (including a libretro core) so the core emulator can be used inside RetroArch and other libretro frontends or built standalone for development and debugging.

BEST FOR

Where Holani is best used

Holani is best used as a libretro core within RetroArch (or other libretro frontends) when the user wants an accuracy-focused Lynx experience, or by developers needing a library-style Lynx implementation (there are GTK, minimal CLI, and debugger frontends in the repository).

The people behind Holani

History & status

Holani is published by the developer LLeny and the source code is available on GitHub. The project is distributed under the GNU GPL v3. Holani is structured as a library with multiple frontends: holani-retro (libretro core), holani-gtk (GTK frontend), holani-min (command-line frontend), and holani-debug (debugger). The libretro documentation lists Holani as an available Lynx core and documents supported features and requirements; the GitHub repository contains the emulator sources and README. The core is actively represented in libretro core lists and community platform indexes, and the libretro docs list a last documentation update (site footer) through 2025, indicating recent maintenance of core metadata. Practical usage inside RetroArch depends on obtaining the holani core via RetroArch's core downloader or building the holani-retro target from source.

What Holani supports

RetroArch-compatible frontends (holani-retro core)
Platforms supported by RetroArch (Windows, Linux, macOS, Android, Lakka) — when running via RetroArch
Standalone frontends in the repository (holani-gtk, holani-min) — Linux/macOS/Windows where Rust toolchain and dependencies build
Libretro features: save states, screenshots, rewind, netplay (state-based), core options

Download and availability

OFFICIAL DOWNLOADS

Get Holani

Official distribution paths: use RetroArch's Core Downloader to install the Holani libretro core (holani-retro) or download/build from the official GitHub repository. The libretro documentation links the official GitHub repo and the core info file. The Holani repo includes multiple frontends and the library source.

Get Holani ↗

DOCUMENTATION

Official documentation

Read the official configuration, compatibility, and troubleshooting material before changing advanced options.

Read official documentation ↗

Broken or missing download? Emulator projects move and official links sometimes change. Please contact Retro Replay so the source can be verified and updated.

Holani setup guide

Setup note: Practical setup notes — two common approaches: (A) run holani-retro inside RetroArch (recommended for most users), or (B) build the holani frontends from source for development or standalone use. The Holani libretro page documents required BIOS and supported content file extensions.

A. Install and run Holani inside RetroArch: 1) Install RetroArch for your platform (Windows/Linux/macOS/Android/Lakka) from RetroArch's official distribution. 2) Open RetroArch and use Online Updater -> Core Updater to download the Atari Lynx (Holani) core if available. 3) Place the required Lynx boot image file named lynxboot.img in RetroArch's system directory (RetroArch -> Settings -> Directory -> System/BIOS directory). The libretro docs list lynxboot.img as required and record the MD5 checksum fcd403db69f54290b51035d82f835e7b. 4) Load Lynx ROM files with extensions .lnx or .o through RetroArch: Main Menu -> Load Content, then select the holani core when prompted. 5) Configure input and core options in RetroArch as needed (controller mapping, save state slots, core-specific options). Note: Holani supports saves, states, screenshots, rewind, and state-based netplay as per the libretro core documentation.
B. Build holani from source (for developers or advanced users): 1) Get the Holani source from the official GitHub repository (LLeny/holani). 2) Install the Rust toolchain (rustup/cargo) for your platform. 3) Build the desired frontend or target: the repository provides multiple targets including holani-retro (libretro core), holani-gtk (GTK frontend), holani-min (minimal CLI), and holani-debug. 4) If building the libretro core, produce the libretro-compatible dynamic library (follow the repository's README/build instructions in the source). 5) Copy the built core into your libretro frontend's cores directory or use RetroArch's core integration mechanisms. 6) Place lynxboot.img in the frontend/system directory (see step A). 7) Launch the core and load content files (.lnx or .o).
Practical tips and cautions: Holani's repository embeds some free boot ROMs distributed under their own terms; do not expect commercial BIOS or games to be included. The lynxboot.img file the core expects is listed in libretro docs with an MD5; sources for legally redistributable firmware should be confirmed by the user. Use the libretro core download path when possible to avoid manual builds. For advanced timing or debugging, use the holani-debug frontend included in the repo. If a core isn't listed in RetroArch's online updater for your platform, building holani-retro locally or using platform-specific core bundles (Lakka/RetroArch builds) may be required.
Where to put BIOS and ROMs: Place lynxboot.img in the frontend's system/BIOS directory exactly with that filename. Store Lynx game images (.lnx, .o) in a content directory you prefer; point RetroArch or your frontend to that directory when loading content.
Compatibility and features: According to the libretro core documentation, Holani supports core-level features such as save states, screenshots, rewind, and state-based netplay. The core lists a 16,000 Hz sample rate and dynamic FPS handling in its feature table. Controller mappings use RetroPad/joypad layouts; consult the core's input table in the libretro docs for button mapping notes.
If something goes wrong: Check the libretro docs for the Holani core for BIOS and feature requirements, open an issue on the Holani GitHub repository for build/runtime bugs, and verify that the lynxboot.img is present in the frontend system folder and matches the expected MD5 if you experience boot or BIOS errors.

Software reminder: Holani is open-source under GPL-3.0. Commercial game ROMs, proprietary firmware, BIOS, or other copyrighted materials are not included and must be provided by the user where legal.

Sources and further reading

Detailed guides and tutorials

Explore step-by-step guides for Holani as they are published.

Use Holani on Android

An Android ARM64 Libretro build exists for Holani. Run the core through RetroArch for Android; the standalone desktop download and Android core may have different menus and features.

Emulates: Atari Lynx.

Verified Android core build ↗ · Browse all Android emulators →