whatisgithub

What is lat?

liushuyu/lat — explained in plain English

Analysis updated 2026-07-08 · repo last pushed 2025-04-22

C++Audience · ops devopsComplexity · 4/5StaleSetup · hard

In one sentence

LATX is a fast translation tool that lets standard x86 Intel/AMD applications run on Loongson LoongArch processors, using deep optimizations on top of QEMU for better performance than generic emulators.

Mindmap

mindmap
  root((repo))
    What it does
      Runs x86 apps on Loongson
      Better than generic emulators
      Pre-compiles code ahead of time
    How it works
      Built on QEMU 6
      Library passthrough
      LoongArch hardware extensions
    Tech stack
      C++
      QEMU
    Use cases
      Run legacy x86 business apps
      Broaden app compatibility
    Audience
      Loongson server admins
      Linux distro maintainers
Click or tap to explore — scroll the page freely

Code map

Detail Auto

An interactive map of this repo's files and how they connect — its source is parsed live in your browser. Click Visualize to build it.

filefunction / class

What do people build with it?

USE CASE 1

Run legacy x86 business applications on Loongson-based servers.

USE CASE 2

Expand app compatibility for a Linux distribution running on LoongArch hardware.

USE CASE 3

Migrate existing Intel/AMD software to domestic Loongson machines without rewriting it.

What is it built with?

C++QEMULoongArch

How does it compare?

liushuyu/latdaviddrysdale/pkcs11testdeftruth/mnn
LanguageC++C++C++
Last pushed2025-04-222023-01-182023-04-29
MaintenanceStaleDormantDormant
Setup difficultyhardmoderatemoderate
Complexity4/54/54/5
Audienceops devopsdeveloperdeveloper

Figures from each repo's GitHub metadata at analysis time.

How do you get it running?

Difficulty · hard Time to first run · 1h+

Requires Loongson LoongArch hardware and a custom build of QEMU 6 from source with C++ toolchain configured for cross-architecture translation.

The explanation does not specify a license for this project.

So what is it?

LATX is a translation tool that lets 32-bit and 64-bit x86 applications run on LoongArch (Loongson) processors. In practical terms, if you have software built for standard Intel or AMD computers and need it to work on a Loongson-based machine, this project makes that possible with better performance than generic emulators provide. At its core, it builds on QEMU 6, an open-source emulator, but applies deep optimizations specific to Loongson's architecture. It translates x86 instructions into native LoongArch instructions using two main techniques: ahead-of-time pre-compilation (which converts code before it runs, reducing overhead) and "library passthrough," a method borrowed from the box64 project that lets translated programs call certain system libraries directly instead of translating every library call. It also takes advantage of LoongArch's hardware extensions, like vector and binary translation instructions, to speed things up further. The primary users are organizations or individuals running Loongson hardware who need access to the existing x86 software ecosystem. For example, a company that has migrated to domestic Loongson servers but still relies on legacy x86 business applications, or a Linux distribution maintainer on LoongArch who wants to offer broader app compatibility. The project entered its release candidate stage in 2024, following several years of development that began in 2021. The project is notable for how heavily it customizes its QEMU foundation rather than using it as-is. The team has invested in instruction-level optimizations like flag reduction, register handling improvements, and semantic-level instruction pattern matching. The codebase organizes translation through two intermediate representations, one for x86 instructions and one for LoongArch, with optimization passes at each layer. The repository itself compresses nearly 2,000 development commits into a single commit for historical clarity, and future plans include supporting more advanced x86 instruction set extensions like AVX and building performance profiling tools.

Copy-paste prompts

Prompt 1
Help me set up LATX to run a 64-bit x86 Linux application on my Loongson LoongArch machine, including the command-line syntax to launch the translated program.
Prompt 2
I have a legacy x86 business app that uses shared system libraries. Walk me through configuring LATX library passthrough so the translated app calls native LoongArch libraries directly for better performance.
Prompt 3
Compare LATX library passthrough and ahead-of-time pre-compilation: when should I rely on each, and what are the performance trade-offs for running x86 binaries on Loongson?
Prompt 4
Guide me through building LATX from source on a LoongArch Linux system, including any QEMU 6 dependencies and configuration flags I need to enable LoongArch hardware vector extensions.

Frequently asked questions

What is lat?

LATX is a fast translation tool that lets standard x86 Intel/AMD applications run on Loongson LoongArch processors, using deep optimizations on top of QEMU for better performance than generic emulators.

What language is lat written in?

Mainly C++. The stack also includes C++, QEMU, LoongArch.

Is lat actively maintained?

Stale — no commits in 1-2 years (last push 2025-04-22).

What license does lat use?

The explanation does not specify a license for this project.

How hard is lat to set up?

Setup difficulty is rated hard, with roughly 1h+ to a first successful run.

Who is lat for?

Mainly ops devops.

Open on GitHub → Ask about another repo

This repo across BitVibe Labs

Verify against the repo before relying on details.