Translate arXiv Papers to Chinese with a Single Line of Code

Long-time readers might know that I am a steadfast "old-school programming enthusiast"—to this day, I still don't use IDEs or code completion; all I need from an editor is syntax highlighting. Even the blog posts on Scientific Space are hand-typed by me in HTML source code (partly due to historical reasons), and the entire codebase for Cool Papers, from front-end to back-end, was also hand-coded by me.

But even an "old fogy" like me has to admit: AI Agents have an unparalleled advantage for certain tasks—tasks where if you tried to write them by hand, you wouldn't even know where to start. This article introduces a classic example: translating arXiv papers with a single line of code.

The Method First #

First, deploy kimi-cli locally and configure it to use kimi-k2.5. You also need to install a LaTeX compilation environment (I use MacTeX). Finally, download the source code of a paper from arXiv, extract it, enter the source directory, and execute:

kimi --print --prompt "The directory you are in contains the LaTeX source code of an English paper. You need to translate the paper into a Chinese version. Requirement: Translate all English text into Chinese, keep formulas unchanged, translate only necessary captions for tables and figures, translate only necessary comments in code blocks and algorithm blocks, and do not translate names of people. Save the new translated source code into a new directory named 'paper_cn' within the current directory. Ensure the source code remains compilable. After translating, double-check to see if any sections or files were missed. Finally, recompile the translated result into a PDF using xelatex and return the path of the generated PDF. If there is a lot of content to translate, you should open multiple subagents for parallel translation."

Then, you just wait for the paper translation to complete. During this process, Kimi will automatically analyze the directory structure and find the files to be translated. Once finished, it will attempt to compile and further adjust the translation based on compilation error messages until it successfully produces a PDF. If you want to save yourself the trouble of even downloading the source code, you can try:

kimi --print --prompt "Download the source code for the paper with arXiv ID 2502.16982, extract it, and translate it into a Chinese version. Requirement: Translate all English text into Chinese, keep formulas unchanged, translate only necessary captions for tables and figures, translate only necessary comments in code blocks and algorithm blocks, and do not translate names of people. Save the new translated source code into a new directory named 'paper_cn' within the extracted directory. Ensure the source code remains compilable. After translating, double-check to see if any sections or files were missed. Finally, recompile the translated result into a PDF using xelatex and return the path of the generated PDF. If there is a lot of content to translate, you should open multiple subagents for parallel translation."

Using kimi-cli as an example isn't entirely to advertise it; rather, it’s the only one I’ve used, and that was "incidentally" for work testing rather than actively seeking AI Agent assistance—which further proves my "dinosaur" nature. If you have other AI agents you prefer, feel free to try them out yourself.

Comparison of Results #

Among existing paper translation websites, I believe the best one is "Hallucination Translation (hjfy.top)." Below are the translation results for two papers by Kimi and hjfy respectively:

1. kda_Chinese_version_kimi.pdf;

2. kda_Chinese_version_hjfy.pdf;

3. moonlight_Chinese_version_kimi.pdf;

4. moonlight_Chinese_version_hjfy.pdf.

You can compare them yourself:

A Few More Thoughts #

Regarding the principle of Hallucination Translation, the author shared his insights in his Zhihu article "Consuming 300 million tokens, I translated 10,000 arXiv papers with large models." Actually, the simple idea is one most people could guess: start from the LaTeX source code (provided for basically all arXiv papers) and extract the paragraphs that need translation to translate them one by one.

However, when it comes to practice, you experience that "not knowing where to start" feeling because LaTeX is a syntax with extremely high freedom. It is not just a document format; it has essentially become a programming tool. In this context, trying to manually decompose "extraction-translation" into a finite number of steps is extremely difficult. As the author mentioned, he still spends every day fixing bad cases where translation fails; it is a long-term, tedious, and endless job.

And these tasks that "are not easily manually decomposed into enumerable steps" are exactly what AI Agents excel at! The AI will automatically search for and identify the files to be translated, then translate them one by one. More brilliantly, it will automatically attempt to compile and adjust the document itself based on error messages until compilation passes. If one were to write manual rules, the step of handling compilation errors alone would be an endless task; its intrinsic difficulty might not be less than rewriting a LaTeX compiler, and the hardships involved are imaginable.

Besides automation, another benefit of using kimi-cli is the quality of translation. Compared to translating paragraph by paragraph or even sentence by sentence, kimi-cli maintains global contextual information, resulting in significantly better overall translation quality. Of course, there are issues, namely the common ailment of large models—hallucinations. In this case, it might manifest as missing or incorrect translations. In an interactive environment, one can repeatedly ask Kimi to check for omissions until satisfied, but there may be no easy fix for mistranslations. Additionally, there is the issue of speed; going "all-in" with kimi-cli can be a bit slow.

Summary #

This article provides a basic usage case for using kimi-cli to translate arXiv papers. We also welcome users to share more refined use cases.