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.

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.

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:
Website and frontend application 1:1 disassembly and replication:
"Analyze the page layout, colors, fonts, interaction state flow, and core business logic of this target website (https://example.com), and build a clean, maintainable native version from scratch using modern React + Tailwind, with automatic verification of fidelity across different screen widths."
Desktop client and packaged artifact architecture analysis:
"Observe the structure and runtime behavior of this local desktop application package, map out its module division, local data storage methods, and core interaction chains, and output a clearly structured modular specification and skeleton code."
Legacy systems and native binary deep analysis:
"Enable deep analysis mode. Combine symbol resolution and decompilation tools to inspect the internal module dependencies and core state transition logic of this binary, produce a complete business interaction description, and rewrite an independent module in Rust."
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).

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:
- Clean-Room mode (default on): Only observes externally visible user information—screenshots, DOM structures, layout dimensions, colors, fonts, visible text, menus, and interaction flows—and directly blocks tools that read the original software's source code and internal files. Without looking at a single line of the other party's source code, it can still replicate the interaction and logic.
- Deep mode (opt-in): If you're analyzing a legacy system from your own team, or authorized private software, you can manually switch to Deep mode. In this mode, the engine opens up low-level file analysis, executable format parsing for ELF / Mach-O / PE, symbol decoding, and supports integration with local decompilers like Ghidra for deep dissection (for runtime isolation, it uses
bwrapon Linux and Job Objects on Windows to manage child processes).
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).

These people have big ambitions, essentially providing near drop-in replacements for everyday commercial creative software using a native high-performance architecture...
- Graphic design and document publishing:
PhotoCraft(support for layers, masks, text, and real PSD file editing, against Photoshop),VectorCraft(vector illustration),LightCraft(photo library and RAW post-processing),DesignCraft(layout and publishing),FigCraft(interface design and prototyping, against Figma),PdfCraft(PDF reading, organizing, and protection). - Audio/video and motion effects:
FilmCraft(video editing, color grading, and audio),EffectCraft(motion graphics and visual effects),SoundCraft(audio recording and editing). - 3D materials and CAD engineering:
CADCraft(CAD-assisted design),TextureCraft(3D texture painting),MaterialCraft(node-based procedural materials), plus the community-launched parametric 3D CAD appSolidCraft. - Everyday office and data:
WordCraft(document processing),DeckCraft(slide presentations),GridCraft(spreadsheets and data).
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
Rust toolchain: Requires Rust 1.97 or higher (it's recommended to run
rustup updatefirst)System dependencies (only for building the desktop version on Linux): Debian / Ubuntu users need to install window and graphics development packages:
sudo apt-get install build-essential libxkbcommon-dev libxkbcommon-x11-0 libwayland-dev libx11-dev libxrandr-dev libxi-dev libgl1-mesa-dev libgtk-3-dev
AI coding agent: Prepare and log in to a supported agent (e.g., Claude Code) locally
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:

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:

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:

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:
- The compilation barrier is a bit higher than Node toolkits: It requires a fairly new version of Rust (1.97+), and the first
cargocompilation takes a little while, but it's stable once running. - 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.
- If architecture visualization matters to you:
craft-anythingleans 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 likearchifyalongside 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:
- GitHub:
https://github.com/storytold/craft-anything
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.