REMEND

REMEND

Recovers math equations from compiled binary code with a small neural decompiler, and ships the datasets and trained models from its paper. For reverse engineers and researchers.

Made by udiboy1209 on Hugging Face. These notes are Mindket's, written from its model page and model card; the model's own files and license are on Hugging Face.

About

What it is: REMEND is a neural decompiler that turns compiled code for math equations back into the equations themselves. This repository holds the synthetic datasets, the datasets built from open-source programs and the trained models from the paper. Older tools either miss the meaning of the code or need slow dynamic analysis, and REMEND aims to recover data flow and order of operations.

Who it suits: It suits people who study binaries that implement formulas, and researchers who build or compare neural decompilers. The record lists English.

Industry | Who uses it | How they use it | Example
Security research | Reverse engineers | Recover the formula inside a compiled function | Turn a disassembled routine back into an equation
Embedded systems | Firmware engineers | Read numeric routines in binaries when source is missing | Check what a compiled calculation does
Academia | Machine learning researchers | Train or compare neural decompilers on the released datasets | Retrain a model with fairseq-train

People who need whole programs decompiled into full source code can skip it, since REMEND targets math equations.

Where to use it:

• Python with the fairseq library, on Windows, macOS or Linux
• A shell that can run the repository's scripts, which compile sources into ELF files
• A machine for training, if you retrain with the card's command

Use case | Who | What they get back
Try the trained models | Researchers | Generated equations for disassembled functions
Train new models | ML engineers | Models trained on the synthetic dataset with fairseq
Compare related work | Paper authors | Scripts that evaluate BTC, SLaDE and Nova

How to set it up: You need a few things first.

• Python and pip
• The fairseq library, used for training and generating
• Disk space for the dataset archives, and for the large FAIR dataset if you rebuild the synthetic data

1. Install the Hugging Face hub tool with pip.
2. Download the repository, which holds dataset.zip, tokenized.zip and the trained models.
3. If you only plan to train new models on the synthetic data, unpack tokenized.zip and nothing else.
4. Extract dataset.zip if you want to tokenize it differently or change the data first.

pip install -U huggingface_hub
hf download udiboy1209/REMEND

To rebuild the synthetic dataset, download the FAIR prim_fwd archive from the Deep Learning for Symbolic Math paper, then run these steps.

tar xvf prim_fwd.tar.gz
./compile.sh
./combine.sh
./tokenize.sh

How to use it: To test on open-source programs, you run three scripts in order. The dataset lands in a dataset folder and the results in a generated folder.

make.sh
python3 collect_dataset.py
generate.sh

To run a trained model on a tokenized dataset, use fairseq-generate.

fairseq-generate <tokenized-dataset> --task translation --arch transformer \
    --max-source-positions 1024 --max-target-positions 1024 \
    --path <checkpoint> --results-path <out-dir> --gen-subset <train/test/valid> --beam 1

Tool | What it does
dataset.zip | Holds the compiled equations and assembly
tokenized.zip | Holds the tokenized assembly, already prepared with fairseq-preprocess
make.sh | Compiles the open-source programs into ELF and assembly files
collect_dataset.py | Disassembles the ELF functions for REMEND to process
generate.sh | Runs REMEND, generates equations and checks them for correctness
fairseq-generate | Runs a trained model and writes its translations

Example: You compile the open-source programs with make.sh, disassemble them with collect_dataset.py, then run generate.sh. REMEND writes an equation for each function and scores it for correctness, and the results appear in text files under the generated folder, one set per architecture.

For newcomers and experts: Decompiling means turning machine code back into something readable. REMEND focuses on formulas. A first small step is to download the repository and look inside tokenized.zip, which holds assembly already prepared for the model.

The model is a small transformer encoder-decoder, up to 12 million parameters, paired with algorithmic processing for symbolic reasoning. In its tests a single model scored 89.8 to 92.4 percent, covering three CPU instruction sets, three compiler optimization levels and two languages. On code from open-source programs it reports 8 percent higher accuracy than other neural decompilers, at about 0.132 seconds per function.

Compiled function becomes assembly
Assembly is split into tokens
Encoder-decoder transformer writes an equation
Algorithmic processing adds symbolic reasoning
Equation is checked for correctness

To train a model, the card gives one fairseq command, run with different parameters for each model.

fairseq-train <tokenized-dataset> --task translation --arch transformer \
    --optimizer adam --weight-decay 0.001 --lr 0.0005 --lr-scheduler inverse_sqrt \
    --max-source-positions 1024 --max-target-positions 1024 \
    --encoder-attention-heads 8 --decoder-attention-heads 8 --encoder-embed-dim 384 --decoder-embed-dim 128 \
    --encoder-ffn-embed-dim 1536 --decoder-ffn-embed-dim 512 --decoder-output-dim 128 --dropout 0.05 \
    --max-tokens 20000 --max-update 100000 \
    --no-epoch-checkpoints --keep-best-checkpoints 3 \
    --save-dir <save-dir> --log-file <save-dir>/training.log

Good to know:

• License: MIT.
• Cost to run: no API key or paid service named. You supply the compute, and rebuilding the synthetic data needs a large download.
• Data it reaches: the dataset archives in the repository, the compiled ELF and assembly files the scripts make, and result files written to your folders.
• Not for: whole-program decompilation, since it targets math equations. The related-work evaluation scripts each need their own setup first.

Title: Accuracy range reported across settings
Lowest: 89.8%
Highest: 92.4%

On Hugging Face, 13 November 2026

• Task: translation
• Library: fairseq
• Downloads in the last 30 days: 0
• Likes: 5
• License: mit
• Languages: en
• Tags: fairseq, code, decompiler, symbolic-math, neural-decompiler, translation

Links

• Model: https://huggingface.co/udiboy1209/REMEND
• Files: https://huggingface.co/udiboy1209/REMEND/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download udiboy1209/REMEND

Then follow the usage in its model card. Nothing in this kit runs by itself.