跪拜 Guibai
← Back to the summary

Craft Anything: A Pure-Rust Reverse Engineering Suite That Rebuilds Software from Observation

Recently, the reverse engineering and AI programming circles have seen another extremely eye-catching open-source project: craft-anything.

Its positioning is hardcore: it helps engineers thoroughly understand the underlying structure and runtime logic of any website, application, or software they have in hand, and then directly rebuild their own native version based on that understanding.

You just hand it the target and set the tech stack you want.

Then all you do is wait.

image.png

Remember REA (Reverse Everything), which flooded the web a while back? If REA kicked off the trend of reverse engineering for everyone, then craft-anything is like its pure Rust, engineering-grade evolution.

The project's popularity spiked as soon as it was open sourced. The GitHub star count broke through 35K stars in no time, and the entire engine is written in pure Rust, with very low memory usage and smooth cross-platform performance.

image.png

This post talks about craft-anything, what makes it powerful, and how to get started with it.

How is it different from traditional reverse engineering tools?

When people mention reverse engineering, many immediately think of opening Ghidra or IDA Pro and grinding through screens full of assembly instructions and decompiled pseudocode for days.

craft-anything approaches from a completely different angle—it doesn't just stare at individual code points, but stands from the global perspective of observation and forensics → topology mapping → native reconstruction, turning the entire process into an automated pipeline.

You can give it tasks in very natural language, for example:

After receiving the task, craft-anything doesn't let the large model guess and fill in code based on assumptions. Instead, it strictly follows the four steps designed by the developers: Study (observation & forensics) → Build (hands-on construction) → Check (comparison & validation) → Ready / Refine (polish and iterate).

image.png

Specifically, it has three advantages behind it:

First, it comes with 320+ built-in tools.

craft-anything wraps more than 320 specialized analysis and detection tools in pure Rust, covering website DOM and visual measurement, Electron, Apple apps, Android, .NET, Java, databases, firmware, and even game assets. Moreover, each of these 320+ tools works both as a standalone CLI command and as a standard MCP tool, so they can be directly fed to coding agents like Claude Code for scheduling.

Second, Clean-Room mode is the default, while Deep (deep mode) is also retained.

This design is quite clever and directly addresses the issue that REA was prone to crossing red lines:

Third, once it understands, it builds it for you.

Traditional tools stop at producing an analysis report, but craft-anything organizes scattered page information, module relationships, and interaction event flows into a structured evidence chain during the Study phase, then hands it directly to a coding agent to produce runnable skeletons and complete projects. Finally, it automatically runs Check (for example, comparing multi-resolution rendering results and verifying functional behavior), and if there's a deviation, it automatically Refines. This compresses work that used to take days of analysis + replication down to minutes.

It's worth mentioning that craft-anything isn't an isolated toy. Behind it lies a whole pure Rust open-source creative and office software suite (The Craft App Suite) being pushed by ArtCraft (storytold).

image.png

These people have big ambitions, essentially providing near drop-in replacements for everyday commercial creative software using a native high-performance architecture...

And Craft Anything is the most special of the whole ecosystem: a meta tool. The previous dozen or so are official efforts to redo common software for you; Craft Anything open-sources the engine that understands software and rebuilds it from scratch, letting anyone go and craft anything themselves.

How to use it

Below is how to get craft-anything running.

It offers three forms: a desktop GUI, a command-line tool (craft-anything-cli), and an MCP Server. It supports macOS, Windows, Linux, and FreeBSD. Choose whichever you prefer.

1. Environment preparation

2. Download installer or compile from source

If you just want a quick experience, the easiest way is to download the prebuilt package for your platform from GitHub Releases (the latest is v0.6.1)—macOS users can grab the universal .dmg or the CLI .zip (both signed and notarized). Windows / Linux / FreeBSD also have ready-made installers.

If you want to compile from source, clone the repo and run these commands:

git clone https://github.com/storytold/craft-anything.git
cd craft-anything

# Option A: directly compile and launch the desktop GUI
cargo run --release -p craft-anything

# Option B: install the command-line tool globally
cargo install --path apps/craft-anything-cli

3. Verify and get hands-on

After installation, run the health-check command first to confirm the Rust environment, decompilation extensions, and connected coding agent are ready:

craft-anything-cli doctor

Once health checks pass, you can start rebuilding any project directly.

For example, list how many built-in tools it has from the command line:

craft-anything-cli commands

Directly issue a rebuild / modification command to a target address:

craft-anything-cli rebuild https://example.com "Replicate this page in a clean modern style, and change the top navigation to dark blue"

If you prefer to drive it within your usual AI assistant (Claude Code, Cursor, etc.), you can start it as an MCP Server:

craft-anything-cli mcp

Or even lazier, just hand the repo to your coding agent:

Check my local Rust environment and compile and install craft-anything (https://github.com/storytold/craft-anything). After it's done, run craft-anything-cli doctor to confirm the configuration is correct.

It just works.

I personally tested the official craft-anything-cli doctor and commands on a Mac:

image.png

If you open the desktop version, by default you'll enter a very intuitive simple mode. Pick the target, choose Clean-Room or Deep, fill in the requirements, and hit Start:

image.png

If you switch to Advanced in the top-right, the left side has a function list, the middle shows pseudo-C / disassembly / hex / call graphs, and the right side is an evidence ledger. Combined with the agent console at the bottom, it's basically a traditional reverse engineering IDE welded together with an AI assistant:

image.png

Real feel

If I compare it to REA from a while back, my impression is:

REA is more like a scalpel—good at digging into someone else's app internals and explaining them to you. craft-anything is more like building an entire automated reconstruction factory for you—using pure Rust to lay a foundation of 320+ probing tools, saving resources, being cross-platform, and clearly separating Clean-Room clean-room replication from Deep deep dissection.

That said, in practice, a few details are worth noting:

  1. The compilation barrier is a bit higher than Node toolkits: It requires a fairly new version of Rust (1.97+), and the first cargo compilation takes a little while, but it's stable once running.
  2. Note the difference between rule-based isolation and kernel sandbox: The official docs themselves say that the default Clean-Room mode is mainly rule-level tool interception (to prevent the agent from peeking at source code). If you really want to run untrusted, high-risk binaries, it's safer to put them in a VM or a separate sandbox.
  3. If architecture visualization matters to you: craft-anything leans toward "forensics → write code → validate". If you want to draw the extracted business flows and module topology as pretty interactive diagrams, you can still use a tool like archify alongside it. One handles disassembly and reconstruction, the other beautifully visualizes the logic—together the experience is complete.

Summary

Whether you're learning the design approach of excellent open-source projects, doing private interface compatibility and protocol alignment for an old system, or seeing a stunning product interaction and wanting to rewrite it with your own tech stack, it can compress what used to take days of analysis and implementation down to minutes.

The open-source repository is here. If you're interested, you can go poke at it:

As people used to joke: before, if there was no source code published, it wasn't open source. Now with craft-anything, as long as it can run and be observed, almost any software can be crafted anew in your own way.