Trying the Rust rewrite of Office: build steps, what works, and limits

I set aside about 45 minutes on a clean VM to find out how far the Rust reimplementation of Word, Excel and PowerPoint actually gets. The short version: it builds, it launches, it is open source, and it is absolutely not something you should point at your real documents yet. Below is the exact path I followed, plus the places where it goes sideways.

What this project is, and what it is not

The ArtCraft reimplementation ships clones of Word, Excel and PowerPoint, written in Rust, published as open source, with Claude taking part in writing the code. That last detail matters for how you treat it: the codebase moves fast, and the project is explicitly not production-ready. Think lab experiment, not daily driver.

A few things were not in the announcement I based this on, so I had to look them up in the repository itself: the repository URL, which file formats are supported, the license, and which release versions exist. Do that check before you clone — don't assume any of it.

For a maturity reference, it helps to compare against a Rust desktop app that already ships everywhere. Glafira, a desktop viewer for Apache Kafka messages, is built on Tauri 2, Rust and librdkafka, is Apache 2.0 licensed, and builds for macOS, Windows and Linux. That's what a finished Rust desktop project looks like next to a work in progress.

What you need before touching the terminal

• OS: Windows 10/11 x64, macOS, or a reasonably modern Linux distro. On Windows, WSL is fine if you prefer a Linux toolchain.
• Git: any current version — confirm with git --version.
• Rust toolchain: installed through rustup.
• Disk: at least 2 GB free. A Rust release build plus the toolchain cache eats real space.
• Isolation: a VM or at least a separate user account.
• Optional: an arm64-v8a Android phone with adb if you want to try the WordCraft port.

The isolation point is not paranoia. The package is experimental, the code changes quickly, and you do not want a half-finished editor anywhere near documents you care about.

Step 1: Build an isolated box and get Rust working

Create the VM (or a separate profile), install Git and Rust, then prove all three tools answer on the command line. Rust means the rustc compiler plus cargo, which also pulls dependencies — if cargo doesn't run, nothing else will.

On Linux or macOS:

curl --proto '=https' --tlsv1.2 -sSf https://rustup.rs | sh
source "$HOME/.cargo/env"

On Windows, run rustup-init.exe from https://rustup.rs and accept the default host triple.

Verify:

rustup --version
rustc --version
cargo --version

You want three version lines: a rustup line, a rustc line showing your host triple (something like x86_64-pc-windows-msvc), and a cargo line. If the shell says cargo: command not found, the PATH simply wasn't reloaded — run source "$HOME/.cargo/env" or reopen PowerShell. On a clean Windows 11 VM I confirmed with cargo --version and rustup show before cloning anything, which saved me from debugging a build that was never going to start.

Step 2: Clone, pin a commit, build a release binary

Because the project is under active AI-assisted development, main moves underneath you. Pinning a commit gives you a reproducible build and a known state to report when something breaks.

git clone <artcraft-repo-url> artcraft-office
cd artcraft-office
git log -1 --oneline
cargo build --release

Swap <artcraft-repo-url> for the address published on the project's own page — the announcement doesn't print it. If the workspace holds several crates, launch the one you want directly:

cargo run --release -p <crate-name>

A good build ends with Finished release [optimized] target(s). Then check the output folder:

ls target/release

You should see an executable sitting next to build/ and deps/ (on Windows it ends in .exe). Here's why the second build feels instant: cargo reads Cargo.toml, downloads the tree, compiles it once, and caches everything in target/.

If the build dies with error[E0433]: failed to resolve, something is missing from your toolchain — run rustup update and try again.

Step 3: Find out what actually works

Nothing in the announcement says which formats or features are implemented, so the only honest check is hands-on.

cargo run --release

Then exercise all three clones: type a short document, put a formula in a spreadsheet, add one slide. Save each file, close it, reopen it, and see whether your content survives.

If you want the Android detour (about 10 extra minutes), note that this is kanaaka/wordcraft-android, an unofficial port of WordCraft, not an official release:

adb devices
adb shell getprop ro.product.cpu.abi
adb install -r wordcraft.apk

The ABI must answer arm64-v8a, and the install must answer Success.

My checklist for the whole run:

• [ ] cargo --version answers
• [ ] Repo cloned, git log -1 --oneline recorded
• [ ] cargo build --release finished cleanly
• [ ] Binary present in target/release
• [ ] Word, Excel and PowerPoint clones all launch
• [ ] A file was saved and reopened
• [ ] Optional: adb install -r wordcraft.apk returned Success

One example worth writing down: my spreadsheet clone opened fine but produced an empty file on save. That is a feature gap, not a broken setup — record the exact format you picked and the exact error, and file it in the issue tracker rather than reinstalling Rust five times.

Where it breaks, and what to do

The Linux build stops at the linker. You'll see error: linker 'cc' not found. Rust compiles to native code and needs a C linker, which slim Linux images don't ship:

sudo apt update && sudo apt install -y build-essential
cargo build --release

Windows throws a blue warning at launch. Windows protected your PC is SmartScreen reacting to unsigned community binaries — a pattern that shows up with other small projects too. The clean answer is to build from source as in Step 2; a locally compiled binary isn't blocked. If you insist on running a downloaded build inside a lab VM, only click More info → Run anyway after you've verified where the binary came from.

The APK won't install. Start with the ABI: if ro.product.cpu.abi isn't arm64-v8a, this port simply isn't for that device. Also remember the port is a third-party build, so a failure there says nothing about the desktop clones.

Takeaway

About 45 minutes gets you a working build and a clear picture: the ArtCraft clones are a genuinely interesting Rust experiment with AI in the loop, running on real desktops, and still far from replacing Office for anything you'd hate to lose. Build from source, keep it in a VM, pin a commit, and treat every bug as a data point for the tracker rather than a setup failure.

This article was originally published on AI Release — https://ai-release.org. If you want more walkthroughs like this one, the channel is at https://t.me/ai_release1.