642d5a256791
ka.tsv
# ka: original Georgian UI translations. Licensed MIT OR Apache-2.0.
# UTF-8: English source<TAB>translation. Keep placeholders and escapes intact.
Default (its own settings) แแแแฃแแแกแฎแแแแ (แกแแแฃแแแ แ แแแ แแแแขแ แแแ)
OpenCode default OpenCode-แแก แแแแฃแแแกแฎแแแแ
Model default แแแแแแแก แแแแฃแแแกแฎแแแแ
About 60 GB, an Epic Games account, and Xcode. แแแแฎแแแแแแ 60 GB, Epic Games-แแก แแแแแ แแจแ แแ Xcode.
About Craft Anything Craft Anything-แแก แจแแกแแฎแแ
Add another แแแแแ แแ แแแก แแแแแขแแแ
Add it again, to choose another account's folder for it. แฎแแแแฎแแ แแแแแแขแแ, แ แแ แแแกแแแแก แกแฎแแ แแแแแ แแจแแก แกแแฅแแฆแแแแ แแแ แฉแแแ.
Add Unreal's Linux C++ toolchain Unreal-แแก Linux C++ แฎแแแกแแฌแงแแแ แแแแ แแแแก แแแแแขแแแ
Another model แกแฎแแ แแแแแแ
Bring all to front แงแแแแแก แฌแแแ แแแแแแ แแแแแขแแแ
Choose your project's folderโฆ แแฅแแแแ แแ แแแฅแขแแก แกแแฅแแฆแแแแแก แแ แฉแแแโฆ
Claude Code folder (CLAUDE_CONFIG_DIR) Claude Code-แแก แกแแฅแแฆแแแแ (CLAUDE_CONFIG_DIR)
Close window แคแแแฏแ แแก แแแฎแฃแ แแ
Command palette แแ แซแแแแแแแแก แแแแแขแ แ
Context window แแแแขแแฅแกแขแแก แคแแแฏแแ แ
Copy the message แจแแขแงแแแแแแแแก แแแแแ แแแ
Copy the version แแแ แกแแแก แแแแแ แแแ
Craft Anything on GitHub Craft Anything GitHub-แแ
Default แแแแฃแแแกแฎแแแแ
Drag to give the plan more or less room; double-click to reset แแแแแแแ แแแ, แ แแ แแแแแแก แแแขแ แแ แแแแแแแ แแแแแแ แแแฃแแแแ; แแ แแแแ แแแฌแแแแฃแแแแแ โ แฉแแแแงแ แ
File แคแแแแ
Fold a project's plan แแ แแแฅแขแแก แแแแแแก แฉแแแแชแแ
Fold the plan แแแแแแก แฉแแแแชแแ
Full screen แกแ แฃแแ แแแ แแแ
Help แแแฎแแแ แแแ
Hide Craft Anything Craft Anything-แแก แแแแแแแ
Hide others แกแฎแแแแแก แแแแแแแ
Its own sign-in, settings and conversations: another folder is another account. Empty: its usual folder. แกแแแฃแแแ แ แจแแกแแแ, แแแ แแแแขแ แแแ แแ แกแแฃแแ แแแ: แกแฎแแ แกแแฅแแฆแแแแ แกแฎแแ แแแแแ แแจแแ. แชแแ แแแแ: แแแกแ แฉแแแฃแแ แกแแฅแแฆแแแแ.
Load model options แแแแแแแก แแแ แแแแขแ แแแแก แฉแแขแแแ แแแ
No chat models are visible in {agent}. Check its setup, then reload. {agent}-แจแ แฉแแขแแก แแแแแแแแ แแ แฉแแแก. แจแแแแแฌแแแ แแแกแ แแแงแแแแแ, แจแแแแแ แฎแแแแฎแแ แฉแแขแแแ แแแ.
Nothing of this kind was found. แแ แขแแแแก แแ แแคแแ แ แแแแซแแแแ.
Pick its folder, say what you want, then press Start. แแแ แฉแแแ แแแกแ แกแแฅแแฆแแแแ, แแฅแแแ, แ แ แแแแแแ, แจแแแแแ แแแแญแแ แแ โแแแฌแงแแแแกโ.
Pick your project's folder แแแ แฉแแแ แแฅแแแแ แแ แแแฅแขแแก แกแแฅแแฆแแแแ
Pick your project's folder first. แฏแแ แแแ แฉแแแ แแฅแแแแ แแ แแแฅแขแแก แกแแฅแแฆแแแแ.
Quit Craft Anything Craft Anything-แแแแ แแแกแแแ
Report a problemโฆ แแ แแแแแแแก แจแแขแงแแแแแแแโฆ
Run Engine/Build/BatchFiles/Linux/SetupToolchain.sh in the engine folder to install its bundled Clang toolchain. If you built Unreal from source, Setup.sh downloads the native toolchain instead. A system Clang may not match the engine's version. แซแ แแแแก แกแแฅแแฆแแแแแจแ แแแฃแจแแแ Engine/Build/BatchFiles/Linux/SetupToolchain.sh, แ แแ แแแกแแแ แแ แแแ แแแฌแแแแแฃแแ Clang แฎแแแกแแฌแงแแแ แแแแ แแแ แแแแแแกแขแแแแ แแ. แแฃ Unreal แกแแฌแงแแกแ แแแแแแแ แแแฌแงแแแ, Setup.sh แแแแก แแแชแแแแ แแแขแแฃแ แฎแแแกแแฌแงแแแ แแแแ แแแก แฉแแแแขแแแ แแแแก. แกแแกแขแแแแก Clang แจแแแซแแแแ แซแ แแแแก แแแ แกแแแก แแ แจแแแกแแแแแแแแแแก.
Services แกแแ แแแกแแแ
Set an AI's folder AI-แแก แกแแฅแแฆแแแแแก แแแแแแแแ
Set model options แแแแแแแก แแแ แแแแขแ แแแแก แแแงแแแแแ
Show all แงแแแแแก แฉแแแแแแ
That folder is empty. Pick the folder your project's files are in. แแก แกแแฅแแฆแแแแ แชแแ แแแแแ. แแแ แฉแแแ แกแแฅแแฆแแแแ, แกแแแแช แแฅแแแแ แแ แแแฅแขแแก แคแแแแแแแ.
The Claude desktop app is installed, but building needs Claude Code, its separate command-line tool. Install Claude Code, sign in to it once in a terminal, then look again. Claude-แแก แกแแแแแแแ แแแแแแแชแแ แแแแแกแขแแแแ แแแฃแแแ, แแแแ แแ แแกแแฌแงแแแแ แกแแญแแ แแ Claude Code โ แแแกแ แชแแแแ แแ แซแแแแแแก แกแขแ แแฅแแแแก แฎแแแกแแฌแงแ. แแแแแแกแขแแแแ แแ Claude Code, แแ แแฎแแ แจแแแแ แแแกแจแ แขแแ แแแแแแจแ แแ แจแแแแแ แฎแแแแฎแแ แแแซแแแแแ.
The saved model is no longer visible. Choose another model or the {agent} default. แจแแแแฎแฃแแ แแแแแแ แแฆแแ แฉแแแก. แแแ แฉแแแ แกแฎแแ แแแแแแ แแ {agent}-แแก แแแแฃแแแกแฎแแแแ.
Thinking depth แคแแฅแ แแก แกแแฆแ แแ
OpenCode model OpenCode-แแก แแแแแแ
Remote program แแแกแขแแแชแแฃแ แ แแ แแแ แแแ
Reload models แแแแแแแแแก แฎแแแแฎแแ แฉแแขแแแ แแแ
Apply แแแแแงแแแแแ
OpenCode has no visible chat models. Connect a provider in OpenCode, then reload. OpenCode-แก แฉแแขแแกแแแแก แฎแแแฃแแ แแแแแแแแ แแ แแฅแแก. แแแแแแแจแแ แแ แแแแฌแแแแแแแ OpenCode-แจแ, แจแแแแแ แฎแแแแฎแแ แฉแแขแแแ แแแ.
The saved model is no longer visible. Choose another model or the OpenCode default. แจแแแแฎแฃแแ แแแแแแ แแฆแแ แฉแแแก. แแแ แฉแแแ แกแฎแแ แแแแแแ แแ OpenCode-แแก แแแแฃแแแกแฎแแแแ.
The saved thinking depth is unavailable for this model. Choose its default or an offered depth. แจแแแแฎแฃแแ แคแแฅแ แแก แกแแฆแ แแ แแ แแแแแแแกแแแแก แแแฃแฌแแแแแแแแ. แแแ แฉแแแ แแแกแ แแแแฃแแแกแฎแแแแ แแ แจแแแแแแแแแแแฃแแ แกแแฆแ แแ.
List an agent's models แแแแแขแแก แแแแแแแแแก แกแแ
Choose an agent's model and thinking แแแแแขแแก แแแแแแแกแ แแ แคแแฅแ แแก แแ แฉแแแ
GB GB
and {n} more แแ แแแแแ {n}
{ascii} {ascii}
ยท ${c:.2} ยท ${c:.2}
ยท ssh {h} ยท ssh {h}
(1 picture attached) (แแแแแแ แแแฃแแแ 1 แกแฃแ แแแ)
({n} pictures attached) (แแแแแแ แแแฃแแ แกแฃแ แแแ: {n})
, ${c:.4} , ${c:.4}
.NET application graph .NET แแแแก แแ แแคแ
.NET apps .NET แแแแแ
.NET assembly overview .NET แแกแแแแแแแก แแแแแฎแแแแ
.NET native calls .NET-แแแแ แแแขแแฃแ แ แแแแแก แแแแแซแแฎแแแแแ
.NET types and methods .NET แขแแแแแ แแ แแแแแแแแ
/btw {} /btw {}
0xโฆ or number 0xโฆ แแ แ แแชแฎแแ
A .NET program (C#, F# or VB) .NET แแ แแแ แแแ (C#, F# แแ VB)
A DOS program DOS แแ แแแ แแแ
A Java program Java แแ แแแ แแแ
A Linux (or Unix) program Linux (แแ Unix) แแ แแแ แแแ
A Mac or iPhone program Mac-แแก แแ iPhone-แแก แแ แแแ แแแ
A SQLite database (how an app stores its data) SQLite แแแแแชแแแแ แแแแ (แ แแแแ แแแแฎแแแก แแแ แแแแแก แแแแแชแแแแแก)
A WebAssembly module (code that runs in a browser) WebAssembly แแแแฃแแ (แแแแ, แ แแแแแแช แแ แแฃแแแ แจแ แแฃแจแแแแก)
A Windows program Windows แแ แแแ แแแ
A ZIP archive ZIP แแ แฅแแแ
A bundle of ready-made code that many programs share. แแแ แแแแแก แแแแ แแแ, แ แแแแแกแแช แแแแ แ แแ แแแ แแแ แแแแแ แแแก.
A coding agent such as Claude Code builds it, and an AI answers your questions in plain words. Change this any time in Settings โ AI. แแแก แแฌแงแแแก แแ แแแ แแแแ แแแแก แแแแแขแ, แแแแแแแแแ Claude Code, แแฅแแแแก แแแแฎแแแแก แแ AI แแแ แขแแแ แกแแขแงแแแแแ แแแกแฃแฎแแแก. แแก แแแแแกแแแแ แแ แแก แจแแแแซแแแแ แจแแชแแแแแ แแฅ: แแแ แแแแขแ แแแ โ AI.
A command's output shows here when it finishes. แแ แซแแแแแแก แแแแแแแขแแแ แแฅ แแแแแฉแแแแแ, แ แแชแ แแก แแแกแ แฃแแแแแ.
A copy to try something else from here. แแกแแ, แ แแ แแฅแแแแ แกแฎแแ แ แแ แกแชแแแแ.
A file of machine code that a computer can run directly, like an .exe or an app. แแแแฅแแแฃแ แ แแแแแก แคแแแแ, แ แแแแแก แแแ แแแแแ แแแจแแแแแช แแแแแแฃแขแแ แก แจแแฃแซแแแ, แแแแแแแแแ .exe แแ แแแ.
A file that a computer can run as a program. แคแแแแ, แ แแแแแก แแ แแแ แแแแ แแแจแแแแแช แแแแแแฃแขแแ แก แจแแฃแซแแแ.
A file that links packed web code back to the original, readable source files. แคแแแแ, แ แแแแแแช แจแแคแฃแแฃแ แแแแแแแก แแแแแแแแ แแแ, แฌแแแแแฎแแแ แฌแงแแ แ แคแแแแแแแแ แแแแแจแแ แแแก.
A file we don't recognise yet แคแแแแ, แ แแแแแกแแช แฏแแ แแแ แแชแแแแ
A first look at a file you're unsure about, without running it. แแแ แแแแ แจแแฎแแแแ แคแแแแแ, แ แแแแแจแแช แแแ แฌแแฃแแแแฃแแ แแ แฎแแ แ, แแแกแ แแแจแแแแแก แแแ แแจแ.
A folder แกแแฅแแฆแแแแ
A folder has no bytes of its own แกแแฅแแฆแแแแแก แกแแแฃแแแ แ แแแแขแแแ แแ แแฅแแก
A free reverse-engineering tool from the NSA. Deep mode uses it for extra detail; Clean room mode never does. NSA-แแก แฃแคแแกแ แฃแแฃแแแแแแแ แแแก แฎแแแกแแฌแงแ. แฆแ แแ แ แแแแแ แแแก แแแแแขแแแแแ แแแขแแแแแแกแแแแก แแงแแแแแก; แกแฃแคแแ แแแแฎแแก แ แแแแแ โ แแ แแกแแแแก.
A frozen copy (recommended) แแแงแแแฃแแ แแกแแ (แ แแแแแแแแแแฃแแ)
A frozen copy takes {size}. That's a lot of space: a light copy takes {light}. แแแงแแแฃแแ แแกแแ {size}-แก แแแแแแแก. แแก แแแแ แ แแแแแแแ: แแกแฃแแฃแฅแ แแกแแ {light}-แก แแแแแแแก.
A frozen copy takes {size}; a light copy takes {light}. แแแงแแแฃแแ แแกแแ {size}-แก แแแแแแแก; แแกแฃแแฃแฅแ แแกแแ โ {light}-แก.
A game แแแแแจแ
A game's files แแแแแจแแก แคแแแแแแ
A light copy แแกแฃแแฃแฅแ แแกแแ
A locked room for running a program so it can't touch the rest of your computer. แฉแแแแขแแแ แแแแฎแ แแ แแแ แแแแก แแแกแแจแแแแแ, แ แแ แแแ แแฅแแแแ แแแแแแฃแขแแ แแก แแแแแ แฉแแ แแแฌแแแก แแแ แจแแแฎแแก.
A map of which functions call which other functions. แ แฃแแ แแแแกแ, แ แแแแแ แคแฃแแฅแชแแ แ แแแแ แคแฃแแฅแชแแแแก แแซแแฎแแแก.
A name the program's author gave to a function or variable that survived in the file. แกแแฎแแแ, แ แแแแแแช แแ แแแ แแแแก แแแขแแ แแ แคแฃแแฅแชแแแก แแ แชแแแแแก แแแแ แฅแแ แแ แคแแแแจแ แจแแแแ แฉแ.
A named piece of a program that does one job, like "add two numbers" or "save the file". แแ แแแ แแแแก แแแกแแฎแแแแแฃแแ แแแฌแแแ, แ แแแแแแช แแ แ แกแแฅแแแก แแแแแแแก, แแแแแแแแแ โแแ แ แ แแชแฎแแแก แจแแแ แแแโ แแ โแคแแแแแก แจแแแแฎแแโ.
A number that says where something is in a program's memory, like a house number. แ แแชแฎแแ, แ แแแแแแช แแแแฃแแแแแ, แกแแ แแ แแก แ แแฆแแช แแ แแแ แแแแก แแแฎแกแแแ แแแแจแ, แกแแฎแแแก แแแแ แแก แแกแแแแกแแ.
A piece of text stored inside a program, like a message, a web address or a file name. แแ แแแ แแแแก แจแแแแแ แจแแแแฎแฃแแ แขแแฅแกแขแแก แแแฌแแแ, แแแแแแแแแ แจแแขแงแแแแแแแ, แแแแแแกแแแแ แแ แแ แคแแแแแก แกแแฎแแแ.
A program, an app bundle, an APK, a JavaScript bundle, a folderโฆ or drop it on the window. แแ แแแ แแแ, แแแแก แแแแแขแ, APK, JavaScript-แแก แแแแแขแ, แกแแฅแแฆแแแแโฆ แแ แฉแแแแแแ แคแแแฏแแ แแแ.
A recording of network traffic แฅแกแแแฃแ แ แขแ แแคแแแแก แฉแแแแฌแแ แ
A region of a program as it sits in memory while running. แแ แแแ แแแแก แ แแแแแแ แแกแ, แ แแแแ แช แแก แแฃแจแแแแแกแแก แแแฎแกแแแ แแแแจแ แแแแก.
A region of a program file with one purpose: code, text, pictures, settings. แแ แแแ แแแแก แคแแแแแก แ แแแแแแ แแ แแ แแแแแจแแฃแแแแแ: แแแแ, แขแแฅแกแขแ, แกแฃแ แแแแแ, แแแ แแแแขแ แแแ.
A rule of thumb. Usually right, sometimes wrong, so we label the result as a best guess. แแแแแชแแแแแแแ แแแแแ แแแฎแแแ แฌแแกแ. แฉแแแฃแแแแ แแ แกแฌแแ แแ, แแแแฏแแ โ แแ แ, แแแแขแแ แจแแแแแก แกแแฃแแแแแกแ แแแ แแฃแแแ แแแแจแแแแ.
A saved, checkable record of something we found, with how sure we are and where we found it. แฉแแแ แแแแ แแแแแแแแก แจแแแแฎแฃแแ, แแแแแแแฌแแแแแแ แฉแแแแฌแแ แ, แแแแก แแแแแแแแแ, แ แแแแแแแ แแแ แฌแแฃแแแแฃแแ แแแ แ แแ แกแแ แแแแแแแ.
A script or web page แกแแ แแแขแ แแ แแแแแแแ แแ
A set of commands a program offers to other programs. แแ แซแแแแแแแแก แแแแ แแแ, แ แแแแแกแแช แแ แแแ แแแ แกแฎแแ แแ แแแ แแแแแก แกแแแแแแแแก.
A simple snake game แแแ แขแแแ โแแแแแแกโ แแแแแจแ
A small download (under 200 MB). Free, no account needed. แแชแแ แ แฉแแแแกแแขแแแ แแ (200 MB-แแแ). แฃแคแแกแแ, แแแแแ แแจแ แกแแญแแ แ แแ แแ แแก.
A small file that lists what an app is called, what it needs and what it's allowed to do. แแแขแแ แ แคแแแแ, แกแแแแช แฉแแแแฌแแ แแแแ, แ แ แฐแฅแแแ แแแก, แ แ แกแญแแ แแแแ แแ แ แแกแ แแแแแแแแแก แฃแคแแแแ แแฅแแก.
A smart contract (EVM bytecode) แญแแแแแแ แแแแขแ แแฅแขแ (EVM แแแแขแแแแ)
A way of writing bytes as two-character codes (00 to FF). The rawest view of a file. แแแแขแแแแก แแ แกแแแแแแแแแแ แแแแแแแ แฉแแฌแแ แแก แฎแแ แฎแ (00-แแแ FF-แแแ). แคแแแแแก แงแแแแแแ แแแแแ แฎแแแ.
A way to build desktop apps out of web pages. The app is basically a website with its own browser. แแแแแแแ แแแแแกแแแ แแแกแแขแแแแก แแแแแแก แจแแฅแแแแก แฎแแ แฎแ. แแกแแแ แแแ, แแ แกแแแแแแ, แแแแกแแแขแแ แกแแแฃแแแ แ แแ แแฃแแแ แแ.
A website แแแแกแแแขแ
A website for my bakery แแแแกแแแขแ แฉแแแ แกแแชแฎแแแแกแแแแก
AI AI
AI cost AI-แแก แฆแแ แแแฃแแแแ
AI cost (estimate) AI-แแก แฆแแ แแแฃแแแแ (แจแแคแแกแแแ)
AI cost (part estimate) AI-แแก แฆแแ แแแฃแแแแ (แแแฌแแแแแ แแแ แจแแคแแกแแแ)
AI model file AI แแแแแแแก แคแแแแ
AI name AI-แแก แกแแฎแแแ
AI use this session AI-แแก แแแแแงแแแแแ แแ แกแแกแแแจแ
API boundary API-แแก แกแแแฆแแแ แ
API key API แแแกแแฆแแแ
API key (stored in your system keychain) API แแแกแแฆแแแ (แแแแฎแแแ แแฅแแแแ แกแแกแขแแแแก แแแกแแฆแแแแแแก แกแแชแแแจแ)
API key, if it needs one API แแแกแแฆแแแ, แแฃ แกแญแแ แแแแ
About 10 GB. Free for personal use with a Unity account. แแแแฎแแแแแแ 10 GB. แแแ แแแ แแแแแงแแแแแแกแแแแก แฃแคแแกแแ Unity-แแก แแแแแ แแจแแ.
About 60 GB, an Epic Games account, and Visual Studio's C++ tools. แแแแฎแแแแแแ 60 GB, Epic Games-แแก แแแแแ แแจแ แแ Visual Studio-แก C++ แฎแแแกแแฌแงแแแแ.
Add แแแแแขแแแ
Add Visual Studio's C++ tools Visual Studio-แก C++ แฎแแแกแแฌแงแแแแแก แแแแแขแแแ
Add a brain โแขแแแแแกโ แแแแแขแแแ
Add a fal.ai key fal.ai แแแกแแฆแแแแก แแแแแขแแแ
Add a folderโฆ แกแแฅแแฆแแแแแก แแแแแขแแแโฆ
Add a plugin แแแแแแแแก แแแแแขแแแ
Add an AI brain and I'll read this evidence for you, answer follow-up questions and point at the proof. แแแแแแขแแ AI โแขแแแแโ แแ แแ แแขแแแชแแแฃแแแแแแก แแฅแแแแแแแก แฌแแแแแแแฎแแ, แแแแแขแแแแ แแแแฎแแแแก แแฃแแแกแฃแฎแแ แแ แแแกแขแฃแ แแ แแแแแแแแแแ.
Add an AI by its address AI-แแก แแแแแขแแแ แแแกแแแแ แแแ
Add more info. The builder reads it at its next step. แแแแแแขแแ แแแขแ แแแคแแ แแแชแแ. แจแแแฅแแแแแ แแแก แจแแแแแ แแแแแฏแแ แฌแแแแแแฎแแแก.
Add pictures แกแฃแ แแแแแแก แแแแแขแแแ
Add pictures of the original แแ แแแแแแแแก แกแฃแ แแแแแแก แแแแแขแแแ
Add pictures of the original (optional: screenshots help it look right) แแ แแแแแแแแก แกแฃแ แแแแแแก แแแแแขแแแ (แแ แแกแแแแแแแแฃแแ: แแแ แแแแก แแแแแแญแแแแ แกแฌแแ แ แแแ แแก แแแฆแฌแแแแจแ แแฎแแแ แแแ)
Add to a running build แแแแแแแแ แ แแฌแงแแแแกแแแแก แแแแแขแแแ
Added แแแแแขแแแฃแแแ
Added {n} picture(s). The builder uses them from your next change. แแแแแขแแแฃแแแ แกแฃแ แแแ: {n}. แจแแแฅแแแแแ แแแ แแฅแแแแ แจแแแแแแ แชแแแแแแแแแแ แแแแแแงแแแแแก.
Address to file offset แแแกแแแแ แแแแแ แคแแแแแก แฌแแแแชแแแแแแแแ
Adds its decompiler to Deep mode. Craft Anything can download and set it up for you. แแแแแก แแแแแแแแแแขแแ แก แฆแ แแ แ แแแแแก แฃแแแขแแแก. Craft Anything-แก แจแแฃแซแแแ แแแกแ แฉแแแแขแแแ แแแ แแ แแฅแแแแแแแก แแแงแแแแแ.
Advanced แแแแแขแแแแแ
After installing one, look for it again. แแ แ-แแ แแแก แแแแแกแขแแแแ แแแแก แจแแแแแ แฎแแแแฎแแ แแแซแแแแแ.
Agent แแแแแขแ
Allow generated assets แแแแแ แแ แแแฃแแ แ แแกแฃแ แกแแแแก แแแจแแแแ
Allow once แแ แแฎแแ แแแจแแแแ
Allowed for this project แแแจแแแแฃแแแ แแ แแ แแแฅแขแแกแแแแก
Allowed for this project. แแแจแแแแฃแแแ แแ แแ แแแฅแขแแกแแแแก.
Allowed in แแแจแแแแฃแแแ:
Allowed once แแแจแแแแฃแแแ แแ แแฎแแ
Allowed once. แแแจแแแแฃแแแ แแ แแฎแแ.
Also list projects from แแ แแแฅแขแแแแก แฉแแแแแแ แแแ แแแแ แแฅแแแแ:
Always for this project แงแแแแแแแแก แแ แแ แแแฅแขแแกแแแแก
An Android app Android แแแ
An Android app package: the file you install on a phone. Android แแแแก แแแแแขแ: แคแแแแ, แ แแแแแกแแช แขแแแแคแแแแ แแแแกแขแแแแ แแแ.
An Apple settings file (plist) Apple-แแก แแแ แแแแขแ แแแแก แคแแแแ (plist)
An app แแแ
An app or a file แแแ แแ แคแแแแ
Analyse a JavaScript app JavaScript แแแแก แแแแแแแ
Analyse a page's JavaScript แแแแ แแแก JavaScript-แแก แแแแแแแ
Android app code (DEX) Android แแแแก แแแแ (DEX)
Android app components Android แแแแก แแแแแแแแแขแแแ
Android app package Android แแแแก แแแแแขแ
Android apps Android แแแแแ
Android class Android แแแแกแ
Android method bytecode Android แแแแแแแก แแแแขแแแแ
Android resources Android แ แแกแฃแ แกแแแ
Annotate function แคแฃแแฅแชแแแก แแแแขแแ แแแ
Another build is working, so this one waits its turn. แกแฎแแ แแฌแงแแแ แแแแแแแแ แแแแก, แแแแขแแ แแก แแแแแก แ แแแก แแแแแแแ.
Answer a project's question แแ แแแฅแขแแก แแแแฎแแแแ แแแกแฃแฎแ
Answer any of them in a message below. แฃแแแกแฃแฎแแ แ แแแแแแแ แแแแแแแก แฅแแแแแ แจแแขแงแแแแแแแแ.
Answered by {name} แฃแแแกแฃแฎแ: {name}
Answers come from {brain}. To build, set up a coding agent in Settings โ AI. แแแกแฃแฎแแแ แแแแแก {brain}-แแกแแแ. แแกแแฌแงแแแแ แแแแงแแแแ แแ แแแ แแแแ แแแแก แแแแแขแ แแฅ: แแแ แแแแขแ แแแ โ AI.
App แแแ
App details on device แแแแก แแแขแแแแแ แแแฌแงแแแแแแแแแ
Apple apps Apple-แแก แแแแแ
Approve an agent action แแแแแขแแก แแแฅแแแแแแแก แแแแแกแขแฃแ แแแ
Apps and games: keep refining until they look this alike to your pictures. Off, the likeness is only reported. แแแแแ แแ แแแแแจแแแ: แแแฎแแแฌแแก แแแแ แซแแแแแ, แกแแแแ แแฅแแแแก แกแฃแ แแแแแก แแแแแแแ แแ แแแแแกแแแแกแแแ. แแแแแ แแแแกแแก แแกแแแแกแแแ แแฎแแแแ แแแแแ แแจแจแ แฉแแแก.
Architectures แแ แฅแแขแแฅแขแฃแ แแแ
Archive แแ แฅแแแ
Archives แแ แฅแแแแแ
Ask a question แแแแฎแแแก แแแกแแ
Ask about a build แแฌแงแแแแก แจแแกแแฎแแ แแแแฎแแ
Ask about the build แแฌแงแแแแก แจแแกแแฎแแ แแแแฎแแ
Ask about the build, e.g. "where are the latest files?" Nothing changes and no build starts. แแแแแฎแแ แแฌแงแแแแก แจแแกแแฎแแ, แแแ. โแกแแ แแ แแก แฃแแฎแแแกแ แคแแแแแแ?โ แแ แแคแแ แ แแชแแแแแ แแ แแฌแงแแแ แแ แแฌแงแแแ.
Ask about this game แแ แแแแแจแแก แจแแกแแฎแแ แแแแฎแแ
Ask anything, e.g. "What does this program do?" แแแแแฎแแ แแแแแกแแแแ แ แ แแ, แแแ. โแ แแก แแแแแแแก แแก แแ แแแ แแแ?โ
Ask before running anything แแแแแกแแแแ แ แ แแแแก แแแจแแแแแแแ แแแแฎแแ
Ask each time แงแแแแ แฏแแ แแ แแแแฎแแ
Ask first แฏแแ แแแแฎแแ
Ask for a change แชแแแแแแแแก แแแแฎแแแแ
Ask for a change, e.g. "bigger buttons" or "add a dark mode" แแแแแฎแแแแ แชแแแแแแแ, แแแ. โแฃแคแ แ แแแแ แฆแแแแแแแโ แแ โแแแแแ แ แแแแแแก แแแแแขแแแโ
Ask for a change, e.g. "make it faster" or "add a high-score table" แแแแแฎแแแแ แชแแแแแแแ, แแแ. โแแแฎแแแ แฃแคแ แ แกแฌแ แแคแโ แแ โแ แแแแ แแแแแก แชแฎแ แแแแก แแแแแขแแแโ
Ask for a change, e.g. "make the header blue" or "add a contact form" แแแแแฎแแแแ แชแแแแแแแ, แแแ. โแแแแ แแแแ แแแฎแแแ แแฃแ แฏแโ แแ โแกแแแแแขแแฅแขแ แคแแ แแแก แแแแแขแแแโ
Ask in your own words. Every answer shows how sure we are, and the proof. แแแแแฎแแ แกแแแฃแแแ แ แกแแขแงแแแแแ. แงแแแแแ แแแกแฃแฎแ แแฉแแแแแแก, แ แแแแแแแ แแแ แฌแแฃแแแแฃแแ แแแ แ, แแ แแแกแขแฃแ แก.
Ask me แแแแแฎแแ
Ask the agent about this แแแแแขแแกแแแแก แแแแก แจแแกแแฎแแ แแแแฎแแ
Ask the agent about this target. It cites evidence for every claim. แฐแแแแฎแแ แแแแแขแก แแ แกแแแแแแแก แจแแกแแฎแแ. แแก แงแแแแ แแขแแแชแแแแก แแขแแแชแแแฃแแแแแ แแแงแแ แแแก.
Ask the agentโฆ แแแแแขแแกแแแแก แแแแฎแแโฆ
Ask the person แแแแแแแแแกแแแแก แแแแฎแแ
Ask: "How does the % key work?" แแแแแฎแแ: โแ แแแแ แแฃแจแแแแก % แฆแแแแแ?โ
Ask: "Is it safe to run?" แแแแแฎแแ: โแฃแกแแคแ แแฎแแ แแแกแ แแแจแแแแ?โ
Ask: "What does it send over the internet?" แแแแแฎแแ: โแ แแก แแแแแแแแก แแก แแแขแแ แแแขแแ?โ
Asking for its modelsโฆ แแแกแ แแแแแแแแแก แแแแฎแแแแโฆ
Asset catalog แ แแกแฃแ แกแแแแก แแแขแแแแแ
At most this many rounds of fixes after the first build. แจแแกแฌแแ แแแแก แ แแฃแแแแแแก แแแฅแกแแแแแฃแ แ แ แแแแแแแแ แแแ แแแแ แแฌแงแแแแก แจแแแแแ.
Attach pictures แกแฃแ แแแแแแก แแแแแแ แแแ
Attach pictures (or drop or paste them here) แกแฃแ แแแแแแก แแแแแแ แแแ (แแ แฉแแแแแแ แแ แฉแแกแแแ แแกแแแ แแฅ)
Auto mode แแแขแแ แแแแแ
Automatic แแแขแแแแขแฃแ แ
Automatic ({name}) แแแขแแแแขแฃแ แ ({name})
Back แฃแแแ
Best guess แกแแฃแแแแแกแ แแแ แแฃแแ
Best guess: a reasonable reading, but not proven. แกแแฃแแแแแกแ แแแ แแฃแแ: แแแแแแ แฃแแ แฌแแแแแฎแแ, แแแแ แแ แแแฃแแขแแแชแแแแแ.
Binary layout แแแแแ แฃแแ แกแขแ แฃแฅแขแฃแ แ
Blocked แแแแแแแแแแ
Bookmark แกแแแแจแแ
Budget for a new project แแแฃแฏแแขแ แแฎแแแ แแ แแแฅแขแแกแแแแก
Bug report แแแแแ แแจแ แจแแชแแแแแก แจแแกแแฎแแ
Build แแฌแงแแแ
Build a rebuild ledger แฎแแแแฎแแแ แแฌแงแแแแก แแฃแ แแแแแก แจแแแแแแ
Build a stand-in backend แจแแแชแแแแแ แแแฅแแแแแก แแฌแงแแแ
Build with แแกแแฌแงแแแแ:
Build with this แแแแ แแฌแงแแแ
Build with {name} แแฌแงแแแ {name}-แแ
Build with {name} instead แแฌแงแแแ {name}-แแ, แแแชแแแแ แแแแกแ
Build without it แแฌแงแแแ แแแก แแแ แแจแ
Builder's questions: แแแฌแงแแแแก แแแแฎแแแแ:
Building แแฌแงแแแ แแแแแแแแ แแแแก
Building needs a coding agent on this computer (Claude Code, Codex or Gemini CLI: install one and sign in to it once in its own window), or an AI with an API key. Craft Anything never sees your account. แแกแแฌแงแแแแ แกแแญแแ แแ แแ แแแ แแแแ แแแแก แแแแแขแ แแ แแแแแแฃแขแแ แแ (Claude Code, Codex แแ Gemini CLI: แแแแแแกแขแแแแ แแ แแ แ-แแ แแ แแ แแ แแฎแแ แจแแแแ แแแกแจแ แแแก แกแแแฃแแแ แคแแแฏแแ แแจแ) แแ AI API แแแกแแฆแแแแ. Craft Anything แแฅแแแแก แแแแแ แแจแก แแแ แแกแแแแก แฎแแแแแก.
Building needs a coding agent such as Claude Code, or an AI with an API key. แแกแแฌแงแแแแ แกแแญแแ แแ แแ แแแ แแแแ แแแแก แแแแแขแ, แแแแแแแแแ Claude Code, แแ AI API แแแกแแฆแแแแ.
Builds แแฌแงแแแแแ
Builds and answers may use it again. แแฌแงแแแแแแ แแ แแแกแฃแฎแแแแ แจแแแซแแแแ แแก แฎแแแแฎแแ แแแแแแงแแแแ.
Builds at once แแ แแแ แแฃแแ แแฌแงแแแแแ
Builds keep going without stopping to ask you before an action. The builder still never deletes outside its project, changes system settings or publishes anything, and stays within each project's asset budget. แแฌแงแแแแแ แแ แซแแแแแแ แแกแ, แ แแ แแแฅแแแแแแแก แฌแแ แแฅแแแแก แจแแกแแแแแฎแแ แแ แฉแแ แแแแ. แจแแแฅแแแแแ แแแแแช แแ แแกแแแแก แจแแแก แ แแแแก แแแแแกแ แแ แแแฅแขแแก แแแ แแ, แแ แชแแแแก แกแแกแขแแแแก แแแ แแแแขแ แแแก, แแ แแคแแ แก แแฅแแแงแแแแก แแ แงแแแแแ แแ แแแฅแขแแก แ แแกแฃแ แกแแแแก แแแฃแฏแแขแจแ แ แฉแแแ.
Builds use this one. Click to choose automatically again. แแฌแงแแแแแ แแแแก แแงแแแแแก. แแแฌแแแแแ, แ แแ แแกแแ แแแขแแแแขแฃแ แแ แแแ แฉแแก.
Built by แแฌแงแแแก:
Built with แแฌแงแแแแแแ:
Built with {stack}, as you asked, so no game engine is needed. แแฌแงแแแแแแ {stack}-แแ, แ แแแแ แช แแแฎแแแแ, แแแแขแแ แกแแแแแแจแ แซแ แแแ แกแแญแแ แ แแ แแ แแก.
Call graph แแแแแซแแฎแแแแแแก แแ แแคแ
Call path แแแแแซแแฎแแแแก แแแ
Call the build done แแฌแงแแแแก แแแกแ แฃแแแแฃแแแ แแแแแชแฎแแแแแ
Called done. A new message carries on from here. แแแกแ แฃแแแแฃแแแ แแแแแชแฎแแแแ. แแฎแแแ แจแแขแงแแแแแแแ แแฅแแแแ แแแแแ แซแแแแแก.
Cancel แแแฃแฅแแแแ
Cancel: don't use this folder แแแฃแฅแแแแ: แแ แกแแฅแแฆแแแแแก แแ แแแงแแแแแ
Capture a website for rebuilding แแแแกแแแขแแก แแแแแฆแแแ แฎแแแแฎแแ แแกแแฌแงแแแแ
Capture inventories แแแแแแขแแ แแแแก แแแแแฆแแแ
Capture menus, dialogs and tabs แแแแแฃแแแแก, แแแแแแแแแแกแ แแ แฉแแแแ แแแแแก แแแแแฆแแแ
Change แจแแชแแแ
Change a setting แแแ แแแแขแ แแก แจแแชแแแ
Change an AI's model AI-แแก แแแแแแแก แจแแชแแแ
Change how hard an AI thinks AI-แแก แคแแฅแ แแก แแแขแแแกแแแแแแก แจแแชแแแ
Change it แจแแชแแแ
Changeโฆ แจแแชแแแโฆ
Check แจแแแแฌแแแแ
Check .NET native calls .NET-แแแแ แแแขแแฃแ แ แแแแแซแแฎแแแแแแก แจแแแแฌแแแแ
Check a rebuild claim แฎแแแแฎแแแ แแฌแงแแแแก แจแแกแแฎแแ แแขแแแชแแแแก แจแแแแฌแแแแ
Check a scripted web session แกแแ แแแขแแ แฉแแฌแแ แแแ แแแแกแแกแแแก แจแแแแฌแแแแ
Check an answer แแแกแฃแฎแแก แจแแแแฌแแแแ
Check decompiled C# แแแแแแแแแแ แแแฃแแ C#-แแก แจแแแแฌแแแแ
Check my build แฉแแแ แแฌแงแแแแก แจแแแแฌแแแแ
Check the JEB connection JEB-แแแ แแแแจแแ แแก แจแแแแฌแแแแ
Check the asset keys แ แแกแฃแ แกแแแแก แแแกแแฆแแแแแแก แจแแแแฌแแแแ
Check the setup แแแงแแแแแแก แจแแแแฌแแแแ
Check {n} แจแแแแฌแแแแ {n}
Check {n}: about {s}% like the original แจแแแแฌแแแแ {n}: แแ แแแแแแแก แแแแฎแแแแแแ {s}%-แแ แฐแแแแก
Checked against Godot's official checksums before it's used. แแแแแงแแแแแแแแ แแแฌแแแแแ Godot-แแก แแคแแชแแแแฃแ แ แกแแแแแขแ แแแ แฏแแแแแแ.
Checking แจแแแแฌแแแแ
Choose a file แคแแแแแก แแ แฉแแแ
Choose a folderโฆ แกแแฅแแฆแแแแแก แแ แฉแแแโฆ
Choose a function, string or section to see it here. แแแ แฉแแแ แคแฃแแฅแชแแ, แกแขแ แแฅแแแ แแ แกแแฅแชแแ, แ แแ แแฅ แแแฎแแ.
Choose an AI's job AI-แแก แแแแแแแแแก แแ แฉแแแ
Choose the folder Ghidra is installed in. แแแ แฉแแแ แกแแฅแแฆแแแแ, แกแแแแช Ghidra แแแงแแแแแฃแแแ.
Choose what the builder's questions get แแ แฉแแแ, แ แ แแแแฆแแ แจแแแฅแแแแแแก แแแแฎแแแแแ
Choose what to recreate, say what you want, then press Start. แแแ แฉแแแ, แ แแกแ แฎแแแแฎแแ แจแแฅแแแ แแกแฃแ แ, แแฅแแแ, แ แ แแแแแแ, แจแแแแแ แแแแญแแ แแ โแแแฌแงแแแแกโ.
Chooseโฆ แแ แฉแแแโฆ
Classes แแแแกแแแ
Clean room แกแฃแคแแ แแแแฎแ
Clean room / Deep แกแฃแคแแ แแแแฎแ / แฆแ แแ
Clean room never reads the original's code, files or page source. Deep mode reads them with every tool Craft Anything has. แกแฃแคแแ แแแแฎแ แแ แแแแแแแแก แแแแก, แคแแแแแแก แแ แแแแ แแแก แฌแงแแ แแก แแ แแกแแแแก แแแแฎแฃแแแแก. แฆแ แแ แ แแแแแ แแแ Craft Anything-แแก แงแแแแ แฎแแแกแแฌแงแแแ แแแแฎแฃแแแแก.
Clean room never reads the original's code, files or page source: it works from what you can see. Deep reads them with every tool, and with Ghidra when it's installed. Every finding records which was used. แกแฃแคแแ แแแแฎแ แแ แแแแแแแแก แแแแก, แคแแแแแแก แแ แแแแ แแแก แฌแงแแ แแก แแ แแกแแแแก แแแแฎแฃแแแแก: แแก แแฃแจแแแแก แแแแ, แ แแกแแช แแฅแแแ แฎแแแแแ. แฆแ แแ แแแ แงแแแแ แฎแแแกแแฌแงแแแ แแแแฎแฃแแแแก, แแ Ghidra-แแแช, แแฃ แแก แแแงแแแแแฃแแแ. แงแแแแแ แแแแแแแ แแฆแ แแชแฎแแแก, แ แแแแแ แแแแแแงแแแแแแแ.
Clean room on แกแฃแคแแ แแแแฎแ แฉแแ แแฃแแแ
Clean room or Deep แกแฃแคแแ แแแแฎแ แแฃ แฆแ แแ
Clean room: nothing inside the original is read. We work from what you can see: pictures, the page as a visitor sees it, and watching it run. แกแฃแคแแ แแแแฎแ: แแ แแแแแแแแก แจแแแแแ แแ แแคแแ แ แแแแแฎแแแ. แแแฃแจแแแแ แแแแ, แ แแกแแช แแฅแแแ แฎแแแแแ: แกแฃแ แแแแแแ, แแแแ แแแ แแกแ, แ แแแแ แช แแแก แแแแแขแแ แ แฎแแแแแก, แแ แแแกแ แแฃแจแแแแแก แแแแแแ แแแแแ.
Clear finished แแแกแ แฃแแแแฃแแแแแก แแแกแฃแคแแแแแแ
Close แแแฎแฃแ แแ
Close a Frida session Frida-แก แกแแกแแแก แแแฎแฃแ แแ
Close a GDB session GDB-แแก แกแแกแแแก แแแฎแฃแ แแ
Close a Rizin debug session Rizin-แแก แแแแแ แแแแก แกแแกแแแก แแแฎแฃแ แแ
Close a pinned build แแแแแแ แแแฃแแ แแฌแงแแแแก แแแฎแฃแ แแ
Close it แแแฎแฃแ แแ
Close it first. แฏแแ แแแฎแฃแ แแ.
Close the website แแแแกแแแขแแก แแแฎแฃแ แแ
Code reconstructed from a program that looks like the C language. Close to what the program does, but not its original source. แแ แแแ แแแแแแ แแฆแแแแแแแ แแแแ, แ แแแแแแช C แแแแก แฐแแแแก. แแฎแแแกแแ แแแแกแแแ, แ แแกแแช แแ แแแ แแแ แแแแแแแก, แแแแ แแ แแแกแ แแแแแแแแ แแแแ แฌแงแแ แ แแแแ แแ แแ แแก.
Code signature แแแแแก แฎแแแแแฌแแ แ
Coding agent app แแ แแแ แแแแ แแแแก แแแแแขแแก แแแ
Command palette (Ctrl/โ K) แแ แซแแแแแแแแก แแแแแขแ แ (Ctrl/โ K)
Commands: แแ แซแแแแแแแ:
Compare WebAssembly interfaces WebAssembly แแแขแแ แคแแแกแแแแก แจแแแแ แแแ
Compare module exports แแแแฃแแแแแก แแฅแกแแแ แขแแแแก แจแแแแ แแแ
Compare two .NET builds แแ แ .NET แแฌแงแแแแก แจแแแแ แแแ
Compare two app versions แแแแก แแ แ แแแ แกแแแก แจแแแแ แแแ
Compare two artifacts แแ แ แแ แขแแคแแฅแขแแก แจแแแแ แแแ
Compare two evidence bundles แแขแแแชแแแฃแแแแแแแก แแ แ แแแแ แแแแก แจแแแแ แแแ
Compare two functions แแ แ แคแฃแแฅแชแแแก แจแแแแ แแแ
Compare two page captures แแแแ แแแก แแ แ แแแแแแญแแแก แจแแแแ แแแ
Compare two runs แแ แ แแแจแแแแแก แจแแแแ แแแ
Compare two screenshots แแแ แแแแก แแ แ แแแแแแญแแแก แจแแแแ แแแ
Comparing and rebuilding แจแแแแ แแแ แแ แฎแแแแฎแแแ แแฌแงแแแ
Compiled Python file แแแแแแแแ แแแฃแแ Python แคแแแแ
Connect แแแแแแจแแ แแแ
Connect agent apps แแแแแขแแก แแแแแแก แแแแแแจแแ แแแ
Connect to a browser แแ แแฃแแแ แแแ แแแแแแจแแ แแแ
Connect {name} {name}-แแก แแแแแแจแแ แแแ
Connected devices แแแแแแจแแ แแแฃแแ แแแฌแงแแแแแแแแแ
Connected phone แแแแแแจแแ แแแฃแแ แขแแแแคแแแ
Continue แแแแ แซแแแแแ
Contradicted แฃแแ แงแแคแแแแ
Control-flow graph: a map of every path a function can take, like a flowchart. แแแ แแแแก แแแแแแแก แแ แแคแ: แ แฃแแ แงแแแแ แแแแกแ, แ แแแแแแแช แคแฃแแฅแชแแ แจแแแซแแแแ แฌแแแแแแก, แแแแ-แกแฅแแแแก แแกแแแแกแแ.
Copies share the files it saves beside itself. แแกแแแแ แแแแแ แแแแ แคแแแแแแก, แ แแแแแแกแแช แแก แแแแแก แแแแ แแแ แแแแฎแแแก.
Copy a file off the phone แขแแแแคแแแแแแ แคแแแแแก แแแแแ แแแ
Copy a file to the phone แขแแแแคแแแแ แคแแแแแก แแแแแ แแแ
Copy an app off the phone แขแแแแคแแแแแแ แแแแก แแแแแ แแแ
Copy the command แแ แซแแแแแแก แแแแแ แแแ
Copy the evidence id แแขแแแชแแแฃแแแแแก id-แแก แแแแแ แแแ
Couldn't add the pictures: แกแฃแ แแแแแแก แแแแแขแแแ แแแ แแแฎแแ แฎแแ:
Couldn't answer: แแแกแฃแฎแ แแแ แแแฎแแ แฎแแ:
Couldn't attach the pictures: แกแฃแ แแแแแแก แแแแแแ แแแ แแแ แแแฎแแ แฎแแ:
Couldn't look through that folder. แแ แกแแฅแแฆแแแแแก แแแแแแแแแ แแแ แแแ แแแฎแแ แฎแแ.
Couldn't open it. แแแฎแกแแ แแแ แแแฎแแ แฎแแ.
Couldn't open the folder. แกแแฅแแฆแแแแแก แแแฎแกแแ แแแ แแแฎแแ แฎแแ.
Couldn't open {}: {} {}-แแก แแแฎแกแแ แแแ แแแฎแแ แฎแแ: {}
Couldn't save your settings. แแแ แแแแขแ แแแแก แจแแแแฎแแ แแแ แแแฎแแ แฎแแ.
Couldn't start a worker thread: {e} แกแแแฃแจแแ แแแแแแแก แแแจแแแแ แแแ แแแฎแแ แฎแแ: {e}
Couldn't start it. แแแจแแแแ แแแ แแแฎแแ แฎแแ.
Coverage unknown แแแคแแ แแ แฃแชแแแแแ
Craft Anything Craft Anything
Craft Anything can't build with {engine}, so Unity is the closest match. Craft Anything-แก {engine}-แแ แแฌแงแแแ แแ แจแแฃแซแแแ, แแแแขแแ แงแแแแแแ แแฎแแแก Unity-แ.
Craft Anything or the computer closed while it was working. Everything so far is kept; Continue picks up where it stopped. Craft Anything แแ แแแแแแฃแขแแ แ แแฃแจแแแแแกแแก แแแแฎแฃแ แ. แแฅแแแแ แแแแแแแแฃแแ แงแแแแแคแแ แ แจแแแแฎแฃแแแ; โแแแแ แซแแแแแโ แแฅแแแแ แแแแแแ แซแแแก, แกแแแแช แจแแฉแแ แแ.
Craft Anything reads its code and files with every tool it has. For your private use. Craft Anything แแแก แแแแกแ แแ แคแแแแแแก แงแแแแ แแ แกแแแฃแแ แฎแแแกแแฌแงแแแ แแแแฎแฃแแแแก. แแฅแแแแ แแแ แแแ แแแแแงแแแแแแกแแแแก.
Craft Anything reads the original's code, files and page source with every tool it has, and with Ghidra when it's installed. Craft Anything แแ แแแแแแแแก แแแแก, แคแแแแแแกแ แแ แแแแ แแแก แฌแงแแ แแก แงแแแแ แแ แกแแแฃแแ แฎแแแกแแฌแงแแแ แแแแฎแฃแแแแก, แแ Ghidra-แแแช, แแฃ แแก แแแงแแแแแฃแแแ.
Craft Anything report.md Craft Anything report.md
Craft Anything's records, checks and anything it built in app/ are deleted. Your own files in the folder stay as they are. Craft Anything-แแก แฉแแแแฌแแ แแแ, แจแแแแฌแแแแแแ แแ แงแแแแแคแแ แ, แ แแช แแแ app/-แจแ แแแฌแงแ, แฌแแแจแแแ. แแฅแแแแ แกแแแฃแแแ แ แคแแแแแแ แกแแฅแแฆแแแแแจแ แฃแชแแแแแแ แ แฉแแแ.
Crash dump แแแแ แแแก แแแแแ
Create the project แแ แแแฅแขแแก แจแแฅแแแ
Critical แแ แแขแแแฃแแ
Cross-reference: a place in the program that uses or calls the thing you're looking at. แฏแแแ แแแแแ แแแแแ แแแ: แแแแแแ แแ แแแ แแแแจแ, แ แแแแแแช แแงแแแแแก แแ แแซแแฎแแแก แแแแก, แ แแกแแช แฃแงแฃแ แแแ.
Cross-references แฏแแแ แแแแแ แแแแแ แแแแแ
Cross-references: the places in the program that use or call the thing you're looking at. แฏแแแ แแแแแ แแแแแ แแแแแ: แแแแแแแแ แแ แแแ แแแแจแ, แ แแแแแแแช แแงแแแแแก แแ แแซแแฎแแแก แแแแก, แ แแกแแช แฃแงแฃแ แแแ.
Current document แแแแแแแแ แ แแแแฃแแแแขแ
Cursor address แแฃแ แกแแ แแก แแแกแแแแ แแ
Cursor function แแฃแ แกแแ แแก แคแฃแแฅแชแแ
Custom แแแ แแแแฃแแ
Cutter command Cutter-แแก แแ แซแแแแแ
DOS load image DOS-แแก แฉแแขแแแ แแแแก แแแแแแญแแ
Databases แแแแแชแแแแ แแแแแแ
Decide yourself แแแแแ แแแแแฌแงแแแขแแ
Decode a radio recording แ แแแแแฉแแแแฌแแ แแก แแแแแแแ แแแ
Decompile แแแแแแแแแแ แแแ
Decompile Java with Vineflower Java-แก แแแแแแแแแแ แแแ Vineflower-แแ
Decompile many แแ แแแแแก แแแแแแแแแแ แแแ
Decompile with JEB แแแแแแแแแแ แแแ JEB-แแ
Deep แฆแ แแ
Deep mode now decompiles with Ghidra. The first look at a large program can take several minutes. แฆแ แแ แ แแแแแ แแฎแแ Ghidra-แแ แแแแแแแแแแ แแแก. แแแแ แแ แแแ แแแแก แแแ แแแ แแแแแแแแแ แแแแก แจแแแซแแแแ แ แแแแแแแแ แฌแฃแแ แแแกแญแแ แแแก.
Deep mode on แฆแ แแ แ แแแแแ แฉแแ แแฃแแแ
Deep: we read its code, files and page source with every tool we have, and with Ghidra when it's installed. Click to switch. แฆแ แแ: แแแก แแแแก, แคแแแแแแกแ แแ แแแแ แแแก แฌแงแแ แแก แงแแแแ แแ แกแแแฃแแ แฎแแแกแแฌแงแแแ แแแแแฎแฃแแแแ, แแ Ghidra-แแแช, แแฃ แแก แแแงแแแแแฃแแแ. แแแฌแแแแแ แแแแแกแแ แแแแแ.
Delete a project แแ แแแฅแขแแก แฌแแจแแ
Delete it แฌแแจแแ
Delete the project แแ แแแฅแขแแก แฌแแจแแ
Delete {name}? แฌแแแจแแแแ {name}?
Deleted. แฌแแแจแแแ.
Deleted. Your own files are still in the folder. แฌแแแจแแแ. แแฅแแแแ แกแแแฃแแแ แ แคแแแแแแ แแกแแ แกแแฅแแฆแแแแแจแแ.
Deleteโฆ แฌแแจแแโฆ
Deliberately scrambled to make it hard to read, without changing what it does. แแแแแ แแฎ แแ แแฃแแแ, แ แแ แซแแแแแ แฌแแกแแแแแฎแ แแงแแก, แแกแ, แ แแ แแแกแ แแแฅแแแแแแ แแ แจแแชแแแแแ.
Demangle Swift symbols Swift-แแก แกแแแแแแแแแแก แแแแแแแแแ แแแ
Details แแแขแแแแแ
Details about the selected item appear here. แแแแแจแแฃแแ แแแแแแแขแแก แแแขแแแแแ แแฅ แแแแแฉแแแแแ.
Detect แแแแชแแแแ
Device details แแแฌแงแแแแแแแแก แแแขแแแแแ
Device features แแแฌแงแแแแแแแแก แจแแกแแซแแแแแแแแแ
Device folder แแแฌแงแแแแแแแแก แกแแฅแแฆแแแแ
Device log แแแฌแงแแแแแแแแก แแฃแ แแแแ
Disassemble sBPF code sBPF แแแแแก แแแแแกแแแแแแ แแแ
Disassembly แแแแแกแแแแแแ แแแ
Disconnect agent apps แแแแแขแแก แแแแแแก แแแแแจแแ
Dismiss แแแแแแแ
Dispatch metadata แแแกแแแฉแแ แแแแชแแแก แแแขแแแแแแชแแแแแ
Display info แแแ แแแแก แแแคแแ แแแชแแ
Do you have permission? แแแฅแแ แแแแแ แแแ?
Does it talk to the internet? แแแขแแ แแแขแก แฃแแแแจแแ แแแแ?
Does it track me? แแแแแแแแแแแแแก?
Don't allow แแ แแแจแแแแ
Don't ask again (you can change this in Settings) แแฆแแ แแแแแฎแแ (แแแแก แจแแชแแแ แแแ แแแแขแ แแแจแ แจแแแแซแแแแ)
Done แแแแแแ
Download แฉแแแแขแแแ แแแ
Download Godot {v} Godot {v}-แแก แฉแแแแขแแแ แแแ
Download Unity Hub Unity Hub-แแก แฉแแแแขแแแ แแแ
Download and use Ghidra Ghidra-แก แฉแแแแขแแแ แแแ แแ แแแแแงแแแแแ
Download it from unity.com and install it. แฉแแแแขแแแ แแแ unity.com-แแแแ แแ แแแแแแกแขแแแแ แแ.
Download it from unrealengine.com and install it. แฉแแแแขแแแ แแแ unrealengine.com-แแแแ แแ แแแแแแกแขแแแแ แแ.
Download the Epic Games Launcher Epic Games Launcher-แแก แฉแแแแขแแแ แแแ
Downloads keep going in the background. แฉแแแแขแแแ แแแแแ แคแแแฃแ แ แแแแแจแ แแ แซแแแแแแ.
Drive an app's screen แแแแก แแแ แแแแก แแแ แแแ
Drop a calculator app (or any small program) on the window. แฉแแแแแแ แแแแแฃแแแขแแ แแก แแแ (แแ แแแแแกแแแแ แ แแแขแแ แ แแ แแแ แแแ) แคแแแฏแแ แแแ.
Drop a file or app anywhere in this window. แฉแแแแแแ แคแแแแ แแ แแแ แแ แคแแแฏแ แแก แแแแแกแแแแ แแแแแแแก.
Drop the file on the window. We only read it; nothing runs. แฉแแแแแแ แคแแแแ แคแแแฏแแ แแแ. แแแก แแฎแแแแ แแแแแฎแฃแแแแ; แแ แแคแแ แ แแจแแแแ.
Drop to attach แฉแแแแแแ แแแกแแแแแ แแแแแ
Drop to open it แฉแแแแแแ แแแกแแฎแกแแแแแ
Duplicate แแฃแแแแ แแแ
Duplicate a project แแ แแแฅแขแแก แแฃแแแแ แแแ
Duplicate the project แแ แแแฅแขแแก แแฃแแแแ แแแ
Each answer says how sure we are: Seen it, Worked it out or Best guess. แงแแแแแ แแแกแฃแฎแ แแแแแแก, แ แแแแแแแ แแแ แฌแแฃแแแแฃแแ แแแ แ: โแแแแฎแแโ, โแแแแแ แแแแแโ แแ โแกแแฃแแแแแกแ แแแ แแฃแแโ.
Edit a project file แแ แแแฅแขแแก แคแแแแแก แ แแแแฅแขแแ แแแ
Edit them in place แแแแแแแ แ แแแแฅแขแแ แแแ
Effort: แซแแแแกแฎแแแแ:
Electron and JavaScript Electron แแ JavaScript
Electron fuses Electron-แแก แคแแฃแแแแ
Engines แซแ แแแแแ
Engines and settings แซแ แแแแแ แแ แแแ แแแแขแ แแแ
Enter a full web address, like example.com or https://example.com/page. แจแแแงแแแแแ แกแ แฃแแ แแแแแแกแแแแ แแ, แแแแแแแแแ example.com แแ https://example.com/page.
Enter to send ยท Shift+Enter for a new line Enter โ แแแแแแแแ ยท Shift+Enter โ แแฎแแแ แกแขแ แแฅแแแ
Epic's own installer. It only opens if Epic's signature checks out. Epic-แแก แกแแแฃแแแ แ แแแกแขแแแแขแแ แ. แแก แแฎแแแแ แแแจแแ แแฎแกแแแแ, แแฃ Epic-แแก แฎแแแแแฌแแ แ แจแแแแฌแแแแแก แแแแแแแก.
Essentials แซแแ แแแแแ
Every build of this project. แแ แแ แแแฅแขแแก แงแแแแ แแฌแงแแแ.
Every finding is saved here with how sure we are. แงแแแแแ แแแแแแแ แแฅ แแแแฎแแแ แแแแก แแแแแแแแแ, แ แแแแแแแ แแแ แฌแแฃแแแแฃแแ แแแ แ.
Every tool as well: a workbench with functions, bytes, references and evidence. แแ แงแแแแ แฎแแแกแแฌแงแแช: แกแแแฃแจแแ แแแแแแ แคแฃแแฅแชแแแแแ, แแแแขแแแแ, แแแแแ แแแแแแแ แแ แแขแแแชแแแฃแแแแแแแ.
Everything found so far, as a Markdown file. แแฅแแแแ แแแแแแแ แงแแแแแคแแ แ Markdown แคแแแแแก แกแแฎแแ.
Everything so far is kept. Continue picks up where it stopped. แแฅแแแแ แแแแแแแแฃแแ แงแแแแแคแแ แ แจแแแแฎแฃแแแ. โแแแแ แซแแแแแโ แแฅแแแแ แแแแแแ แซแแแก, แกแแแแช แจแแฉแแ แแ.
Evidence แแขแแแชแแแฃแแแแแแ
Evidence ledger แแขแแแชแแแฃแแแแแแแก แแฃแ แแแแ
Evidence so far แแฅแแแแ แจแแแ แแแแแฃแแ แแขแแแชแแแฃแแแแแแ
Explain a function แคแฃแแฅแชแแแก แแฎแกแแ
Explain like I'm new แแฎแกแแ แแแแฌแงแแแแกแแแแก
Export a report แแแแแ แแจแแก แแฅแกแแแ แขแแ แแแ
Export a report (Markdown) แแแแแ แแจแแก แแฅแกแแแ แขแแ แแแ (Markdown)
Export captured scripts แฉแแฌแแ แแแ แกแแ แแแขแแแแก แแฅแกแแแ แขแแ แแแ
Export evidence แแขแแแชแแแฃแแแแแแแก แแฅแกแแแ แขแแ แแแ
Export report แแแแแ แแจแแก แแฅแกแแแ แขแแ แแแ
Extract an archive แแ แฅแแแแก แแแแแ แฅแแแแแ
Extract firmware แฉแแจแแแแแฃแแ แแ แแแ แแแแก แแแแฆแแแ
Extract with this แแแแ แแแแฆแแแ
Extracts แแแแแแฆแแแ
File formats แคแแแแแก แคแแ แแแขแแแ
Files packed inside a file แคแแแแแก แจแแแแแ แจแแคแฃแแฃแแ แคแแแแแแ
Filter แคแแแขแ แ
Filter by name แกแแฎแแแแ แคแแแขแ แ
Filter the files แคแแแแแแแก แคแแแขแ แ
Filterโฆ แคแแแขแ แโฆ
Find Android classes Android แแแแกแแแแก แซแแแแ
Find Java classes Java แแแแกแแแแก แซแแแแ
Find a call path แแแแแซแแฎแแแแก แแแแก แซแแแแ
Find a game's files แแแแแจแแก แคแแแแแแแก แซแแแแ
Find an app แแแแก แซแแแแ
Find in-page MCP tools แแแแ แแแ แฉแแจแแแแแฃแแ MCP แฎแแแกแแฌแงแแแแแก แซแแแแ
Find it automatically แแแขแแแแขแฃแ แแ แแแซแแแแ
Find out how any software works, then craft your own. แแแแแแ, แ แแแแ แแฃแจแแแแก แแแแแกแแแแ แ แแ แแแ แแแ, แแ แจแแฅแแแแแ แกแแแฃแแแ แ.
Find the original source line แกแแฌแงแแกแ แฌแงแแ แ แกแขแ แแฅแแแแก แซแแแแ
Firmware regions แฉแแจแแแแแฃแแ แแ แแแ แแแแก แ แแแแแแแแ
Fold the sidebar แแแแ แแแแ แแแแแแแก แแแแชแแ
Folders of projects, and projects started in a folder you picked. Removing one only takes it off the list. แแ แแแฅแขแแแแก แกแแฅแแฆแแแแแแแ แแ แแฅแแแ แแแแ แแ แฉแแฃแ แกแแฅแแฆแแแแแจแ แแแฌแงแแแฃแแ แแ แแแฅแขแแแ. แแแแจแแ แแแก แแฎแแแแ แกแแแแแ แแจแแ แแแก.
Follow the installer that opened. Come back here when it's done. แแแฐแงแแแแ แแแฎแกแแแ แแแกแขแแแแขแแ แก. แแแแ แฃแแแแ แแฅ, แ แแชแ แแแกแ แฃแแแแแ.
Follow the steps on rustup.rs, then come back here. แแแฐแงแแแแ แแแแแฏแแแก rustup.rs-แแ, แจแแแแแ แแแแ แฃแแแแ แแฅ.
For everything you make, like the switch in the title bar. แงแแแแแคแ แแกแแแแก, แ แแกแแช แฅแแแแ, แกแแแแฃแ แแก แแแแแก แแแแแแ แแแแแแก แแกแแแแกแแ.
For example: a website for my bakery แแแแแแแแแ: แแแแกแแแขแ แฉแแแ แกแแชแฎแแแแกแแแแก
For example: recreate this website แแแแแแแแแ: แแ แแแแกแแแขแแก แฎแแแแฎแแ แจแแฅแแแ
For example: the same app, but simpler แแแแแแแแแ: แแแแแ แแแ, แแฆแแแ แฃแคแ แ แแแ แขแแแ
For example: the same game, with a high-score table แแแแแแแแแ: แแแแแ แแแแแจแ, แ แแแแ แแแแแก แชแฎแ แแแแ
Force-stop an app แแแแก แแซแฃแแแแแแ แจแแฉแแ แแแ
Forget the key แแแกแแฆแแแแก แแแแแฌแงแแแ
Found on this computer แแแแแแแแ แแ แแแแแแฃแขแแ แแ
Found {} AI option(s) on this computer แแ แแแแแแฃแขแแ แแ แแแแแแแ AI แแแ แแแแขแ: {}
Frida devices Frida-แก แแแฌแงแแแแแแแแแ
Frida instrumentation Frida-แก แแแกแขแ แฃแแแแขแแชแแ
Frida processes Frida-แก แแ แแชแแกแแแ
Frida session status Frida-แก แกแแกแแแก แแแแแแแ แแแแ
From แกแแแแแ
Frozen copy แแแงแแแฃแแ แแกแแ
Function address แคแฃแแฅแชแแแก แแแกแแแแ แแ
Function assembly แคแฃแแฅแชแแแก แแกแแแแแแ แ
Function dossier แคแฃแแฅแชแแแก แแแกแแ
Function info แคแฃแแฅแชแแแก แแแคแแ แแแชแแ
Function instructions แคแฃแแฅแชแแแก แแแกแขแ แฃแฅแชแแแแ
Function references แคแฃแแฅแชแแแก แแแแแ แแแแแ
Functions แคแฃแแฅแชแแแแ
GDB command GDB-แแก แแ แซแแแแแ
GDB session status GDB-แแก แกแแกแแแก แแแแแแแ แแแแ
Game assets แแแแแจแแก แ แแกแฃแ แกแแแ
Game engines แกแแแแแแจแ แซแ แแแแแ
Game files แแแแแจแแก แคแแแแแแ
General แแแแแแ
Generate a 3D model 3D แแแแแแแก แแแแแ แแ แแแ
Generate a picture แกแฃแ แแแแก แแแแแ แแ แแแ
Generate custom pictures and models แกแแแฃแแแ แ แกแฃแ แแแแแแกแ แแ แแแแแแแแแก แแแแแ แแ แแแ
Generated art (games) แแแแแ แแ แแแฃแแ แแ แแคแแแ (แแแแแจแแแ)
Generated assets แแแแแ แแ แแแฃแแ แ แแกแฃแ แกแแแ
Generated pictures and 3D models are made with fal.ai. แแแแแ แแ แแแฃแแ แกแฃแ แแแแแ แแ 3D แแแแแแแแ fal.ai-แแ แแฅแแแแแ.
Get Ghidra Ghidra-แก แแแฆแแแ
Get Ghidra for Deep mode Ghidra-แก แแแฆแแแ แฆแ แแ แ แแแแแแกแแแแก
Get Unity Hub Unity Hub-แแก แแแฆแแแ
Get a key at {name} แแแกแแฆแแแแก แแแฆแแแ แแฅ: {name}
Get the Epic Games Launcher Epic Games Launcher-แแก แแแฆแแแ
Get {name} {name}-แแก แแแฆแแแ
Getting Ghidra Ghidra-แก แแแฆแแแ
Getting Godot Godot-แแก แแแฆแแแ
Getting Unity Hub Unity Hub-แแก แแแฆแแแ
Getting the Epic Games Launcher Epic Games Launcher-แแก แแแฆแแแ
Ghidra Ghidra
Ghidra folder Ghidra-แก แกแแฅแแฆแแแแ
Ghidra is ready Ghidra แแแแแแ
Ghidra is ready. Deep mode uses it from now on. Ghidra แแแแแแ. แฆแ แแ แ แแแแแ แแแก แแแแแ แแแแ แแงแแแแแก.
Ghidra isn't installed, so the built-in decompiler stands in. Get it in Settings โ Engines. Ghidra แแแงแแแแแฃแแ แแ แแ แแก, แแแแขแแ แแแก แแแชแแแแ แฉแแจแแแแแฃแแ แแแแแแแแแแขแแ แ แแฃแจแแแแก. แแแแฆแแ แแก แแฅ: แแแ แแแแขแ แแแ โ แซแ แแแแแ.
Ghidra isn't on this computer yet, so the built-in decompiler stands in. Ghidra แแ แแแแแแฃแขแแ แแ แฏแแ แแ แแ แแก, แแแแขแแ แแแก แแแชแแแแ แฉแแจแแแแแฃแแ แแแแแแแแแแขแแ แ แแฃแจแแแแก.
Ghidra will use half of this computer's memory (up to {gb} GB). Ghidra แแ แแแแแแฃแขแแ แแก แแแฎแกแแแ แแแแก แแแฎแแแแ แก แแแแแแงแแแแแก ({gb} GB-แแแ).
Ghidra will use up to {gb} GB of memory. Ghidra แแแฎแกแแแ แแแแแแ {gb} GB-แแแ แแแแแแงแแแแแก.
Ghidra, a free reverse-engineering tool from the NSA, gives Deep mode richer decompiled code and types. Ghidra, NSA-แแก แฃแคแแกแ แฃแแฃแแแแแแแ แแแก แฎแแแกแแฌแงแ, แฆแ แแ แ แแแแแก แฃแคแ แ แแแแแแ แแแแแแแแแแ แแแฃแ แแแแกแ แแ แขแแแแแก แแซแแแแก.
Go home แแแแแแ แแ แแแแแกแแแ
Go program details Go แแ แแแ แแแแก แแแขแแแแแ
Go to address แแแกแแแแ แแแ แแแแแกแแแ
Go to offset (0xโฆ) แฌแแแแชแแแแแแแ แแแแแกแแแ (0xโฆ)
Go to the project แแ แแแฅแขแแ แแแแแกแแแ
Good enough แกแแแแแ แแกแแ แแแ แแ
Got it แแแกแแแแแแ
Graph แแ แแคแ
Half of this computer's memory, up to {gb} GB. แแ แแแแแแฃแขแแ แแก แแแฎแกแแแ แแแแก แแแฎแแแแ แ, {gb} GB-แแแ.
Here's a first look: แแ, แแแ แแแแ แจแแฎแแแแ:
Here's what I found on that page: แแ, แ แ แแแแแแ แแ แแแแ แแแ:
Hex Hex
Hide pinned builds แแแแแแ แแแฃแแ แแฌแงแแแแแแก แแแแแแแ
Hide the answer แแแกแฃแฎแแก แแแแแแแ
Hide the console แแแแกแแแแก แแแแแแแ
High แแแฆแแแ
Home แแแแแแ แ
How alike a rebuild must look to the original before refining stops. แ แแแแแแแ แฃแแแ แฐแแแแแแก แฎแแแแฎแแแ แแฌแงแแแ แแ แแแแแแแก, แกแแแแ แแแฎแแแฌแ แจแแฉแแ แแแแ.
How closely may Craft Anything look at it? แ แแแแแแแ แแฎแแแแแ แจแแฃแซแแแ Craft Anything-แก แแแกแ แจแแกแฌแแแแ?
How complete is the rebuild แ แแแแแแแ แกแ แฃแแแ แฎแแแแฎแแแ แแฌแงแแแ
How do I open an app? แ แแแแ แแแแฎแกแแ แแแ?
How do the window and the page talk to each other? แ แแแแ แฃแ แแแแ แแแแแ แคแแแฏแแ แ แแ แแแแ แแ?
How does the % key work? แ แแแแ แแฃแจแแแแก % แฆแแแแแ?
How is this app built? แ แแแแ แแ แแก แแก แแแ แแฌแงแแแแแ?
How is this app put together? แ แแแแ แแ แแก แแก แแแ แจแแแแแแแแ?
How many projects may build at the same time. More wait their turn. แ แแแแแแ แแ แแแฅแขแ แจแแแซแแแแ แแแฌแงแแก แแ แแแ แแฃแแแ. แแแแแ แฉแแแแแ แแแแแก แ แแแก แแแแแแแ.
How should the builder use them? แ แแแแ แแแแแแงแแแแก แแกแแแ แจแแแฅแแแแแแ?
I have Ghidra Ghidra แแแฅแแก
I have permission แแแแแ แแแ แแแฅแแก
I want to make things work together แแแแแ, แ แแ แ แแฆแแชแแแ แแ แแแ แแแฃแจแแแแแก
I'm checking whether it's safe แแแแแฌแแแ, แฃแกแแคแ แแฎแแ แแฃ แแ แ
I'm keeping old software alive แซแแแ แแ แแแ แแแแแก แกแแชแแชแฎแแแก แแฃแฎแแแแ แซแแแแแ
I'm learning how things work แแกแฌแแแแแ, แ แแแแ แแฃแจแแแแก แ แแฆแแชแแแ
I'm new to this แแแแจแ แแฎแแแ แแแ
ILSpy decompile ILSpy-แแ แแแแแแแแแแ แแแ
Ideas: แแแแแแ:
Identify a Flutter build Flutter-แแก แแฌแงแแแแก แแแแชแแแแ
Import a source folder แฌแงแแ แ แกแแฅแแฆแแแแแก แแแแแ แขแ
Import evidence แแขแแแชแแแฃแแแแแแแก แแแแแ แขแ
Imports / Exports แแแแแ แขแแแ / แแฅแกแแแ แขแแแ
In Deep mode this one takes a game's own files out after the study. Click to stop. แฆแ แแ แ แแแแแจแ แแก แแแ แแแแขแ แจแแกแฌแแแแแก แจแแแแแ แแแแแจแแก แกแแแฃแแแ แคแแแแแแก แแฆแแแก. แแแฌแแแแแ แจแแกแแฉแแ แแแแแ.
In Unity Hub: sign in (or make a free account) and accept the free Personal licence. Then open Installs, press Install Editor and choose the recommended version. About 10 GB. Unity Hub-แจแ: แจแแแแ แกแแกแขแแแแจแ (แแ แจแแฅแแแแแ แฃแคแแกแ แแแแแ แแจแ) แแ แแแแฆแแ แฃแคแแกแ Personal แแแชแแแแแ. แจแแแแแ แแแฎแกแแแแ Installs, แแแแญแแ แแ Install Editor-แก แแ แแแ แฉแแแ แ แแแแแแแแแแฃแแ แแแ แกแแ. แแแแฎแแแแแแ 10 GB.
In the launcher: sign in, open Unreal Engine, then Library, and press + next to Engine Versions to install one. About 60 GB. แแแฃแแฉแแ แจแ: แจแแแแ แกแแกแขแแแแจแ, แแแฎแกแแแแ Unreal Engine, แจแแแแแ Library, แแ แแ แแแก แแแกแแแแกแขแแแแ แแแแแ แแแแญแแ แแ +-แก Engine Versions-แแก แแแแ แแแ. แแแแฎแแแแแแ 60 GB.
In use แแแแแแงแแแแแ
Inside แจแแแแแแกแ:
Inspect a Dart AOT snapshot Dart AOT แกแแแแจแแขแแก แจแแกแฌแแแแ
Inspect a network recording แฅแกแแแแก แฉแแแแฌแแ แแก แจแแกแฌแแแแ
Inspect a web page แแแแแแแ แแแก แจแแกแฌแแแแ
Inspect an Electron page Electron แแแแ แแแก แจแแกแฌแแแแ
Inspect data แแแแแชแแแแแแก แจแแกแฌแแแแ
Inspect instruction แแแกแขแ แฃแฅแชแแแก แจแแกแฌแแแแ
Inspector แแแกแแแฅแขแแ แ
Install Rust Rust-แแก แแแแแกแขแแแแ แแแ
Install Unity Hub Unity Hub-แแก แแแแแกแขแแแแ แแแ
Install Visual Studio Community (free) and tick "Game development with C++". แแแแแแกแขแแแแ แแ Visual Studio Community (แฃแคแแกแแ) แแ แแแแแจแแแ โGame development with C++โ.
Install Xcode Xcode-แแก แแแแแกแขแแแแ แแแ
Install an app แแแแก แแแแแกแขแแแแ แแแ
Install an engine แซแ แแแแก แแแแแกแขแแแแ แแแ
Install the launcher แแแฃแแฉแแ แแก แแแแแกแขแแแแ แแแ
Installed แแแแแกแขแแแแ แแแฃแแแ
Installed apps แแแแแกแขแแแแ แแแฃแแ แแแแแ
Inter-process communication: how two parts of an app (or two apps) send messages to each other. แแ แแชแแกแแแจแแ แแกแ แแแแฃแแแแแชแแ: แ แแแแ แฃแแแแแแแแ แแ แแแแแแแก แจแแขแงแแแแแแแแแก แแแแก แแ แ แแแฌแแแ (แแ แแ แ แแแ).
Interface Builder documents Interface Builder-แแก แแแแฃแแแแขแแแ
Interrupted แจแแฌแงแแแขแแแแ
Inventory an archive or app bundle แแ แฅแแแแก แแ แแแแก แแแแแขแแก แแแแแแขแแ แแแแชแแ
Investigating แแแแแซแแแแ แแแแแแแแ แแแแก
Investigation so far แแฅแแแแ แฉแแขแแ แแแฃแแ แแแแแซแแแแ
Is Apktool available? แฎแแแแแกแแฌแแแแแแ Apktool?
Is adb available? แฎแแแแแกแแฌแแแแแแ adb?
Is an asset key set up? แแแงแแแแแฃแแแ แ แแกแฃแ แกแแแแก แแแกแแฆแแแ?
Is anything in here a program? แแ แแก แแฅ แ แแแ, แ แแช แแ แแแ แแแแ?
Is anything sensitive saved in plain text? แแแแฎแแแ แ แแแ แแแ แซแแแแแแ แ แฆแแ แขแแฅแกแขแแ?
Is it safe to look inside programs? แฃแกแแคแ แแฎแแ แแ แแแ แแแแแแก แจแแแแแ แฉแแฎแแแแ?
Is it safe to run? แฃแกแแคแ แแฎแแ แแแกแ แแแจแแแแ?
Is there any readable text inside? แแ แแก แจแแแแแ แฌแแแแแฎแแแแ แขแแฅแกแขแ?
Is this file safe to open? แฃแกแแคแ แแฎแแ แแ แคแแแแแก แแแฎแกแแ?
It closed straight away. แแแจแแแแ แแแแฎแฃแ แ.
It closed straight away. It said: แแแจแแแแ แแแแฎแฃแ แ. แแแ แแฅแแ:
It isn't on this computer yet. Craft Anything can download Ghidra {version} and the Java runtime it needs (about {mb} MB), check both against their publishers' checksums, and set them up in its own folder. Nothing else on your computer changes. แแก แแ แแแแแแฃแขแแ แแ แฏแแ แแ แแ แแก. Craft Anything-แก แจแแฃแซแแแ แฉแแแแขแแแ แแแก Ghidra {version} แแ แแแกแแแแก แกแแญแแ แ Java-แก แแแจแแแแแก แแแ แแแ (แแแแฎแแแแแแ {mb} MB), แแ แแแ แแแแแแชแแแแแแแก แกแแแแแขแ แแแ แฏแแแแแแ แจแแแแแฌแแแก แแ แกแแแฃแแแ แกแแฅแแฆแแแแแจแ แแแแงแแแแก. แแฅแแแแก แแแแแแฃแขแแ แแ แกแฎแแ แแ แแคแแ แ แจแแแชแแแแแ.
It isn't on this computer yet. Install Ghidra {version} from its release page, then choose its folder. แแก แแ แแแแแแฃแขแแ แแ แฏแแ แแ แแ แแก. แแแแแแกแขแแแแ แแ Ghidra {version} แแแกแ แแแแแจแแแแแก แแแแ แแแแแ, แจแแแแแ แแแ แฉแแแ แแแกแ แกแแฅแแฆแแแแ.
It's already open. แฃแแแ แแแฎแกแแแแแ.
It's already open. Right-click it to open another copy. แฃแแแ แแแฎแกแแแแแ. แแแแ แ แแกแแแก แแแกแแฎแกแแแแแ แแแกแแ แแแ แฏแแแแ แฆแแแแแแ แแแฌแแแแแ.
It's done แแแแแแ
It's mine, or I'm allowed to look แฉแแแแ, แแ แแแฎแแแก แฃแคแแแแ แแแฅแแก
Its copy is deleted, with anything it saved there. The project itself stays as it is. แแแกแ แแกแแ แฌแแแจแแแ แแ แงแแแแแคแแ แแแ แแ แแแ, แ แแช แแฅ แจแแแแแฎแ. แแแแแ แแ แแแฅแขแ แฃแชแแแแแแ แ แฉแแแ.
Its folder is deleted with everything in it: what was built, the checks and the conversation. แแแกแ แกแแฅแแฆแแแแ แฌแแแจแแแ แแแแแ แจแแแแแแกแแ: แ แแช แแแฌแงแ, แจแแแแฌแแแแแแ แแ แกแแฃแแแ แ.
Its own code แแแกแ แกแแแฃแแแ แ แแแแ
Java archive overview Java แแ แฅแแแแก แแแแแฎแแแแ
Java class Java แแแแกแ
Java method bytecode and pseudo-Java Java แแแแแแแก แแแแขแแแแ แแ แคแกแแแแ-Java
Java program code (one class) Java แแ แแแ แแแแก แแแแ (แแ แแ แแแแกแ)
Java programs Java แแ แแแ แแแแแ
Java runtime Java-แก แแแจแแแแแก แแแ แแแ
Jobs แแแแแแแแแแ
Jobs ({n_jobs}) แแแแแแแแแแ ({n_jobs})
Jobs ({n}) แแแแแแแแแแ ({n})
Just a question: nothing was changed. Answered by แแฎแแแแ แแแแฎแแ: แแ แแคแแ แ แจแแชแแแแแ. แฃแแแกแฃแฎแ:
Just ask แฃแแ แแแแ แแแแแฎแแ
Just look inside แแฎแแแแ แจแแแแแ แฉแแฎแแแแ
Keep going without asking แแแแ แซแแแแแ แแแแฎแแแก แแแ แแจแ
Keep it แแแขแแแแแ
Keep it in the sidebar to open any time, whatever later builds change. แแแขแแแแ แแแแ แแแ แแแแแแแ, แ แแ แแแแแกแแแแ แแ แแก แแแฎแกแแแ, แ แแช แแ แฃแแแ แจแแชแแแแแก แจแแแแแแแแ แแฌแงแแแแแแ.
Keep the build as it is and stop offering to carry on. แแฌแงแแแแก แแกแ แแแขแแแแแ, แ แแแแ แช แแ แแก, แแ แแแแ แซแแแแแแก แจแแแแแแแแแแก แจแแฌแงแแแขแ.
Keep this version in the sidebar to open any time. แแ แแแ แกแแแก แแแแ แแแ แแแแแแแ แแแขแแแแแ, แ แแ แแแแแกแแแแ แแ แแก แแแแฎแกแแแก.
Keeps this version exactly as it is now. Later builds can't change or break it, and anything it saves stays with the copy. แแแแฎแแแก แแ แแแ แกแแแก แแฃแกแขแแ แแกแ, แ แแแแ แแช แแฎแแแ. แจแแแแแแแ แแฌแงแแแแแ แแแก แแแ แจแแชแแแแก แแ แแแ แแแแคแฃแญแแแก, แฎแแแ แงแแแแแคแแ แ, แ แแกแแช แแก แแแแฎแแแก, แแกแแแแ แ แฉแแแ.
Key saved แแแกแแฆแแแ แจแแแแฎแฃแแแ
Keyed archive แแแกแแฆแแแแแแ แแ แฅแแแ
Kind แกแแฎแแแแ
Language แแแ
Last: {what} แแแแ: {what}
Launch an app แแแแก แแแจแแแแ
Leave a few GB for the rest of your computer. แแแขแแแแ แ แแแแแแแแ GB แแฅแแแแ แแแแแแฃแขแแ แแก แแแแแ แฉแแแ แแแฌแแแแกแแแแก.
Leave a path empty to use the managed install. We never need environment variables. แแแ แแฃแแ แแแกแขแแแแชแแแก แแแแแกแแงแแแแแแแ แแแแแแ แชแแ แแแแ แแแขแแแแ. แแแ แแแแก แชแแแแแแแ แแ แแกแแแแก แแแญแแ แแแแ.
Leave empty to use the one Craft Anything sets up. แแแขแแแแ แชแแ แแแแ, แ แแ Craft Anything-แแก แแแแ แแแงแแแแแฃแแ แแแแแแงแแแแก.
Let a project generate assets แแ แแแฅแขแแกแแแแก แ แแกแฃแ แกแแแแก แแแแแ แแ แแแแก แแแจแแแแ
Let's go แแแแแฌแงแแ
Lets the builder make realistic 3D models and textures for games, {model} a model, with a {budget} budget per project. แจแแแฅแแแแแก แกแแจแฃแแแแแแก แแซแแแแก, แแแแแจแแแแกแแแแก แจแแฅแแแแก แ แแแแแกแขแฃแ แ 3D แแแแแแแแ แแ แขแแฅแกแขแฃแ แแแ, {model} แแแแ แแแแแแแ, แแ แแแฅแขแแ {budget} แแแฃแฏแแขแแ.
Library resolution แแแแแแแแแแแแแก แแแ แแแแแ
Light copy: shares big files with the project แแกแฃแแฃแฅแ แแกแแ: แแแ แคแแแแแแก แแ แแแฅแขแแแ แแแแแ แแแก
Likeness แแกแแแแกแแแ
Line up code and behaviour แแแแแกแ แแ แฅแชแแแแก แจแแฏแแ แแแ
Line up source with the bundle แฌแงแแ แแก แแแแแขแแแ แจแแฏแแ แแแ
List Electron pages Electron แแแแ แแแแแก แกแแ
List JEB units JEB แแ แแแฃแแแแแก แกแแ
List JS runtime targets JS แแแจแแแแแก แแแ แแแแก แกแแแแแแแแแแก แกแแ
List a Unity assets file Unity แ แแกแฃแ แกแแแแก แคแแแแแก แจแแแแแแกแแก แกแแ
List a Unity bundle Unity แแแแแขแแก แจแแแแแแกแแก แกแแ
List a game's archives แแแแแจแแก แแ แฅแแแแแแก แกแแ
List a node's event listeners แแแแแซแแก แแแแแแแแแแก แแกแแแแแแแแแก แกแแ
List an AI's models AI-แแก แแแแแแแแแก แกแแ
List an Unreal IoStore container Unreal IoStore แแแแขแแแแแ แแก แจแแแแแแกแแก แกแแ
List an Unreal pak Unreal pak-แแก แจแแแแแแกแแก แกแแ
List bookmarks แกแแแแจแแแแแแก แกแแ
List browser pages แแ แแฃแแแ แแก แแแแ แแแแแก แกแแ
List documents แแแแฃแแแแขแแแแก แกแแ
List engines แซแ แแแแแแก แกแแ
List functions แคแฃแแฅแชแแแแแก แกแแ
List names แกแแฎแแแแแแก แกแแ
List open targets แฆแแ แกแแแแแแแแแแก แกแแ
List pinned builds แแแแแแ แแแฃแแ แแฌแงแแแแแแก แกแแ
List plugins แแแแแแแแแแก แกแแ
List project files แแ แแแฅแขแแก แคแแแแแแแก แกแแ
List projects แแ แแแฅแขแแแแก แกแแ
List questions about a build แแฌแงแแแแก แจแแกแแฎแแ แแแแฎแแแแแก แกแแ
List radio decoders แ แแแแแแแแแแแ แแแแก แกแแ
List segments แกแแแแแแขแแแแก แกแแ
List shared Cutter sessions Cutter-แแก แกแแแ แแ แกแแกแแแแแก แกแแ
List strings แกแขแ แแฅแแแแแแก แกแแ
Live: the project's latest build แชแแชแฎแแแ: แแ แแแฅแขแแก แฃแแฎแแแกแ แแฌแงแแแ
Load a picture แกแฃแ แแแแก แฉแแขแแแ แแแ
Load a screenshot แแแ แแแแก แแแแแแญแแแก แฉแแขแแแ แแแ
Loadingโฆ แแขแแแ แแแแโฆ
Log แแฃแ แแแแ
Look again แฎแแแแฎแแ แซแแแแ
Look at a game แแแแแจแแก แจแแกแฌแแแแ
Look at a website แแแแกแแแขแแก แจแแกแฌแแแแ
Look at the game แแแแแจแแก แจแแกแฌแแแแ
Look for AI on this computer AI-แแก แซแแแแ แแ แแแแแแฃแขแแ แแ
Look for game engines แกแแแแแแจแ แซแ แแแแแแก แซแแแแ
Look for projects again แแ แแแฅแขแแแแก แฎแแแแฎแแ แซแแแแ
Looked at everything แงแแแแแคแแ แ แจแแกแฌแแแแแแแ
Looked at part of it แจแแกแฌแแแแแแแ แแแฌแแแ
Looked at {a} of {b} แจแแกแฌแแแแแแแ {a} / {b}
Looking for AI on this computerโฆ แแ แแแแแแฃแขแแ แแ AI-แแก แซแแแแโฆ
Looking for game engines on this computerโฆ แแ แแแแแแฃแขแแ แแ แกแแแแแแจแ แซแ แแแแแแก แซแแแแโฆ
Looking for the game's filesโฆ แแแแแจแแก แคแแแแแแแก แซแแแแโฆ
Looking inside needs Deep mode แจแแแแแ แฉแแฎแแแแแก แฆแ แแ แ แแแแแ แกแญแแ แแแแ
Looking inside software you own or are allowed to examine is normal and often protected (learning, compatibility, security). Saying why helps you keep to it; it stays on this computer. แแ แแ แแแ แแแแก แจแแแแแ แฉแแฎแแแแ, แ แแแแแแช แแฅแแแ แแแแฃแแแแแ แแ แ แแแแแก แจแแกแฌแแแแแก แฃแคแแแแแช แแแฅแแ, แฉแแแฃแแแแ แแแแ แแ แฎแจแแ แแ แแแชแฃแแแช (แกแฌแแแแ, แแแแกแแแแแแแ, แฃแกแแคแ แแฎแแแแ). แแแแแแแก แแฅแแ แแแแก แแแชแแแจแ แแแฎแแแ แแแแ; แแก แแ แแแแแแฃแขแแ แแ แ แฉแแแ.
Looking on this computerโฆ แแ แแแแแแฃแขแแ แแ แซแแแแโฆ
Low แแแแแแ
Mach-O structure Mach-O แกแขแ แฃแฅแขแฃแ แ
Made a copy: {name} แจแแแฅแแแ แแกแแ: {name}
Made with fal.ai and paid from your account: {model} a 3D model, {picture} a picture. Off, the game is built without them. แแฅแแแแแ fal.ai-แแ แแ แแฎแแแแ แแฅแแแแ แแแแแ แแจแแแแ: {model} โ 3D แแแแแแ, {picture} โ แกแฃแ แแแ. แแแแแ แแแแกแแก แแแแแจแ แแแ แแแ แแจแ แแแฌแงแแแ.
Made with {engine} แจแแฅแแแแแแ {engine}-แแ
Made without looking inside the original. แจแแฅแแแแแแ แแ แแแแแแแแก แจแแแแแ แฉแแฎแแแแแก แแแ แแจแ.
Make a game that plays like this แแแแแจแแก แจแแฅแแแ, แ แแแแแแช แแกแ แแแแแจแแแแ
Make a simpler version of this game แแ แแแแแจแแก แแแแแ แขแแแแแฃแแ แแแ แกแแแก แจแแฅแแแ
Make my own version แฉแแแ แแแ แกแแแก แจแแฅแแแ
Make my own version of this app แแ แแแแก แฉแแแ แแแ แกแแแก แจแแฅแแแ
Making my own thing talk to something else. แฉแแแ แจแแฅแแแแแแก แ แแฆแแช แกแฎแแแกแแแ แแแแแแจแแ แแแ.
Many source files packed into one big file so an app or web page loads faster. แแแแ แ แฌแงแแ แ แคแแแแ, แแ แ แแแ แคแแแแจแ แจแแคแฃแแฃแแ, แ แแ แแแ แแ แแแแแแแ แแ แฃแคแ แ แกแฌแ แแคแแ แฉแแแขแแแ แแแก.
Map a HarmonyOS app HarmonyOS แแแแก แ แฃแแแก แจแแแแแแ
Map a page's module graph แแแแ แแแก แแแแฃแแแแแก แแ แแคแแก แ แฃแแแก แจแแแแแแ
Map an Android app Android แแแแก แ แฃแแแก แจแแแแแแ
Map an Apple app Apple-แแก แแแแก แ แฃแแแก แจแแแแแแ
Markdown Markdown
Match functions between two builds แคแฃแแฅแชแแแแแก แจแแกแแแแแแกแแแ แแ แแฌแงแแแแก แจแแ แแก
Match my pictures แฉแแแก แกแฃแ แแแแแแแ แแแแแฎแแแแ
Match static code to what ran แกแขแแขแแแฃแ แ แแแแแก แจแแฏแแ แแแ แแแแกแแแ, แ แแช แจแแกแ แฃแแแ
Maximise แแแจแแ
May I run "{title}"? แจแแแซแแแแ แแแแฃแจแแ โ{title}โ?
May I {action}? แจแแแซแแแแ {action}?
Measure which code ran แจแแกแ แฃแแแแฃแแ แแแแแก แแแแแแแ
Medium แกแแจแฃแแแ
Memory for Ghidra แแแฎแกแแแ แแแ Ghidra-แกแแแแก
Minimise แฉแแแแชแแ
Mode แ แแแแแ
Model แแแแแแ
Model: {model} แแแแแแ: {model}
Modules แแแแฃแแแแ
More detail แแแขแ แแแขแแแ
More makes a big program's first look faster. แแแขแ แแฉแฅแแ แแแก แแแแ แแ แแแ แแแแก แแแ แแแ แแแแแแแแแ แแแแก.
More memory makes Ghidra's first look at a big program faster; leave some for the rest of the computer. Used from the next time Ghidra starts. แแแขแ แแแฎแกแแแ แแแ แแฉแฅแแ แแแก แแแแ แแ แแแ แแแแก แแแ แแแ แแแแแแแแแ แแแแก Ghidra-แจแ; แแแขแแแแ แแแฌแแแ แแแแแแฃแขแแ แแก แแแแแ แฉแแแ แแแฌแแแแกแแแแก. แแแแแแงแแแแแ Ghidra-แก แจแแแแแแ แแแจแแแแแแแ.
Name (optional) แกแแฎแแแ (แแ แแกแแแแแแแแฃแแ)
Name an address แแแกแแแแ แแแกแแแแก แกแแฎแแแแก แแแ แฅแแแแ
Name at address แกแแฎแแแ แแแกแแแแ แแแ
Name many addresses แแ แแแแแ แแแกแแแแ แแแกแแแแก แกแแฎแแแแก แแแ แฅแแแแ
Names the program's author gave to functions or variables that survived in the file. แกแแฎแแแแแ, แ แแแแแแแช แแ แแแ แแแแก แแแขแแ แแ แคแฃแแฅแชแแแแก แแ แชแแแแแแแก แแแแ แฅแแ แแ แคแแแแจแ แจแแแแ แฉแ.
Needs a fal.ai key. Until then the game is built without them. แกแแญแแ แแ fal.ai แแแกแแฆแแแ. แแแแแแแ แแแแแจแ แแแ แแแ แแจแ แแแฌแงแแแ.
Needs you แแฅแแแ แแแแแแแแแ
Network แฅแกแแแ
New แแฎแแแ
New project แแฎแแแ แแ แแแฅแขแ
New projects go in แแฎแแแ แแ แแแฅแขแแแแก แแแแแแ:
Next address แจแแแแแแ แแแกแแแแ แแ
No AI (built-in engines only) AI-แแก แแแ แแจแ (แแฎแแแแ แฉแแจแแแแแฃแแ แซแ แแแแแ)
No AI brain is set up, so answers come straight from the built-in engines. Add one any time for plain-words explanations. AI โแขแแแแโ แแแงแแแแแฃแแ แแ แแ แแก, แแแแขแแ แแแกแฃแฎแแแ แแแ แแแแแ แฉแแจแแแแแฃแแ แซแ แแแแแแแแ แแแแแก. แแแ แขแแแ แกแแขแงแแแแแ แแฎแกแแแกแแแแก แแแแแกแแแแ แแ แแก แแแแแแขแแ.
No AI for now แฏแแ แฏแแ แแแแ AI-แแก แแแ แแจแ
No AI is set up yet. The built-in engines still work; an AI adds plain-words answers. AI แฏแแ แแแงแแแแแฃแแ แแ แแ แแก. แฉแแจแแแแแฃแแ แซแ แแแแแ แแแแแช แแฃแจแแแแก; AI แแแ แขแแแ แกแแขแงแแแแแ แแแกแฃแฎแแแก แแแแขแแแก.
No Unreal or Unity archives were found. Pick the folder the game is installed in. Unreal-แแก แแ Unity-แแก แแ แฅแแแแแ แแแ แแแแซแแแแ. แแแ แฉแแแ แกแแฅแแฆแแแแ, แกแแแแช แแแแแจแแ แแแแแกแขแแแแ แแแฃแแ.
No coding agent was found on this computer yet. แแ แแแแแแฃแขแแ แแ แแ แแแ แแแแ แแแแก แแแแแขแ แฏแแ แแแ แแแแซแแแแ.
No evidence yet แแขแแแชแแแฃแแแแแแ แฏแแ แแ แแ แแก
No game files here แแฅ แแแแแจแแก แคแแแแแแ แแ แแ แแก
No jobs yet. Long tasks show their progress here, and you can cancel them. แแแแแแแแแแ แฏแแ แแ แแ แแก. แฎแแแแ แซแแแแ แแแแชแแแแแ แแฅ แแแแแแแ แแ แแแ แแกแก แแฉแแแแแแก แแ แแแแ แแแฃแฅแแแแ แจแแแแซแแแแ.
No matches แแแแแฎแแแแ แแ แแ แแก
No open questions แแแกแฃแฎแแแฃแชแแแแแ แแแแฎแแแแ แแ แแ แแก
No plugins yet. แแแแแแแแแ แฏแแ แแ แแ แแก.
No result yet แจแแแแแ แฏแแ แแ แแ แแก
No targets แกแแแแแแแแแ แแ แแ แแก
No tool named {tool} แฎแแแกแแฌแงแ แกแแฎแแแแ {tool} แแ แแ แกแแแแแก
None แแ แชแแ แแ
None yet. Screenshots help it look right. แฏแแ แแ แชแแ แแ. แแแ แแแแก แแแแแแญแแแแ แกแฌแแ แ แแแ แแก แแแฆแฌแแแแจแ แแฎแแแ แแแ.
Not allowed แแแ แซแแแฃแแแ
Not allowed. แแแ แซแแแฃแแแ.
Not available yet แฏแแ แฎแแแแแกแแฌแแแแแ แแ แแ แแก
Not compared yet: {what} แฏแแ แจแแฃแแแ แแแแแแ: {what}
Not installed แแ แแ แแก แแแแแกแขแแแแ แแแฃแแ
Not now แแฎแแ แแ แ
Nothing allowed yet. แฏแแ แแ แแคแแ แแ แแแจแแแแฃแแ.
Nothing can build yet: install Claude Code (and sign in to it once), or add an AI with an API key below. แฏแแ แแแ แแคแแ แ แแแฌแงแแแ: แแแแแแกแขแแแแ แแ Claude Code (แแ แแ แแฎแแ แจแแแแ แแแกแจแ) แแ แฅแแแแแ แแแแแแขแแ AI API แแแกแแฆแแแแ.
Nothing found แแแ แแคแแ แ แแแแซแแแแ
Nothing found yet. We look for API keys, local model servers (Ollama, LM Studio) and agent apps you already have. One on another port or computer can be added by its address below. แฏแแ แแแ แแคแแ แ แแแแซแแแแ. แแแซแแแ API แแแกแแฆแแแแแก, แแแแแแแแแก แแแแแแฃแ แกแแ แแแ แแแก (Ollama, LM Studio) แแ แแแแแขแแก แแแแแก, แ แแแแแแแช แฃแแแ แแแฅแแ. แกแฎแแ แแแ แขแแ แแ แแแแแแฃแขแแ แแ แแ แกแแแฃแแแก แแแแแขแแแ แฅแแแแแ แแแกแ แแแกแแแแ แแแ แจแแแซแแแแ.
Nothing inside it is read. แจแแแแแ แแ แแคแแ แ แแแแแฎแแแ.
Nothing inside it is read; Craft Anything works from what you can see. Your version gets its own art. แจแแแแแ แแ แแคแแ แ แแแแแฎแแแ; Craft Anything แแฃแจแแแแก แแแแ, แ แแกแแช แแฅแแแ แฎแแแแแ. แแฅแแแแ แแแ แกแแ แกแแแฃแแแ แแ แแคแแแแก แแแแฆแแแก.
Nothing inside the original is read: not its code, files or page source. Craft Anything works from what you can see: pictures, the page as a visitor sees it, and watching it run. แแ แแแแแแแแก แจแแแแแ แแ แแคแแ แ แแแแแฎแแแ: แแ แช แแแกแ แแแแ, แแ แช แคแแแแแแ, แแ แช แแแแ แแแก แฌแงแแ แ. Craft Anything แแฃแจแแแแก แแแแ, แ แแกแแช แแฅแแแ แฎแแแแแ: แกแฃแ แแแแแแ, แแแแ แแแ แแกแ, แ แแแแ แช แแแก แแแแแขแแ แ แฎแแแแแก, แแ แแแกแ แแฃแจแแแแแก แแแแแแ แแแแแ.
Nothing made yet. What you make shows up here. แฏแแ แแ แแคแแ แ แจแแฅแแแแแ. แ แแกแแช แจแแฅแแแแ, แแฅ แแแแแฉแแแแแ.
Nothing matches the filter. แคแแแขแ แก แแ แแคแแ แ แจแแแกแแแแแแแ.
Nothing matches. แแแแแฎแแแแ แแ แแ แแก.
Nothing new for {time}. Long steps can be quiet; if it stays like this, press Pause. {time} แแแแแแแแแแแจแ แแฎแแแ แแ แแคแแ แแ. แฎแแแแ แซแแแแ แแแแแฏแแแ แจแแแซแแแแ แฉแฃแแแ แแแแแแแแ แแแแแแก; แแฃ แแกแ แแแ แฉแแแ, แแแแญแแ แแ โแแแฃแแแกโ.
Nothing open แแ แแคแแ แแ แแแฎแกแแแแ
Nothing open yet แฏแแ แแ แแคแแ แแ แแแฎแกแแแแ
Nothing selected แแ แแคแแ แแ แแแแแจแแฃแแ
Nothing to show แกแแฉแแแแแแแแ แแ แแคแแ แแ
Nothing uses it until it's on again; it keeps its key. แกแแแแ แฎแแแแฎแแ แแ แฉแแแ แแแแแ, แแแก แแ แแคแแ แ แแงแแแแแก; แแแกแแฆแแแ แแแแฎแแแ.
Nothing โ start fresh แแ แแคแแ แ โ แแแแแแแ แแแฌแงแแแ
Now แแฎแแ
Now: {what} ({time}) แแฎแแ: {what} ({time})
Objective-C classes Objective-C แแแแกแแแ
Objective-C protocols Objective-C แแ แแขแแแแแแแ
Observe a JS runtime JS แแแจแแแแแก แแแ แแแแแ แแแแแแ แแแแ
Of this, {cost} was charged to an API key. แแฅแแแแ {cost} API แแแกแแฆแแแแ แแแแ แแชแฎแ.
Off แแแแแ แแฃแแ
Ollama or LM Studio on another computer, or any service that speaks the OpenAI API. Ollama แแ LM Studio แกแฎแแ แแแแแแฃแขแแ แแ, แแ แแแแแกแแแแ แ แกแแ แแแกแ, แ แแแแแแช OpenAI API-แแ แกแแฃแแ แแแก.
On แฉแแ แแฃแแ
One line, in plain words. It stays on this computer and is never sent anywhere. แแ แแ แกแขแ แแฅแแแ, แแแ แขแแแ แกแแขแงแแแแแ. แแก แแ แแแแแแฃแขแแ แแ แ แฉแแแ แแ แแ แกแแ แแแแแแแแแ.
One-shot instrumentation แแ แแฏแแ แแแ แแแกแขแ แฃแแแแขแแชแแ
Only for Ghidra. Empty = managed. แแฎแแแแ Ghidra-แกแแแแก. แชแแ แแแแ = แแแ แแฃแแ.
Only its name changes; its folder stays where it is. แแฎแแแแ แกแแฎแแแ แแชแแแแแ; แแแกแ แกแแฅแแฆแแแแ แแแแแก แแแแแแแ แ แฉแแแ.
Only take pictures out of games you made, or whose owner allows it. A game's art is usually protected by copyright and by the game's licence. แกแฃแ แแแแแ แแฎแแแแ แแ แแแแแจแแแแแแ แแแแแฆแแ, แ แแแแแแแช แแฅแแแ แจแแฅแแแแแ แแ แ แแแแแแ แแคแแแแแแแช แแแแก แฃแคแแแแแก แแซแแแแ. แแแแแจแแก แแ แแคแแแ แฉแแแฃแแแแ แแ แแแชแฃแแแ แกแแแแขแแ แ แฃแคแแแแแ แแ แแแแแจแแก แแแชแแแแแแ.
Only the pin goes; the project and its app stay as they are. แแฎแแแแ แแแแแแ แแแ แแฎแกแแแแ; แแ แแแฅแขแ แแ แแแกแ แแแ แฃแชแแแแแแ แ แฉแแแ.
Open แแแฎแกแแ
Open "Show me the proof" to see the exact code we found, and how sure we are. แแแฎแกแแแแ โแแแกแขแฃแ แแก แฉแแแแแแโ, แ แแ แแแฎแแ แแฃแกแขแแ แแก แแแแ, แ แแแแแแช แแแแแแแ, แแ แ แแแแแแแ แแแ แฌแแฃแแแแฃแแ แแแ แ.
Open Ghidra's release page Ghidra-แก แแแแแจแแแแแก แแแแ แแแก แแแฎแกแแ
Open Unity Hub Unity Hub-แแก แแแฎแกแแ
Open a calculator app and find the code behind one button. แแแฎแกแแแแ แแแแแฃแแแขแแ แแก แแแ แแ แแแแแแ แแ แแ แฆแแแแแแก แฃแแแ แแแแแแ แแแแ.
Open a file in JEB แคแแแแแก แแแฎแกแแ JEB-แจแ
Open a file or drop one here. แแแฎแกแแแแ แคแแแแ แแ แฉแแแแแแ แแฅ.
Open a fileโฆ แคแแแแแก แแแฎแกแแโฆ
Open a folder or app bundle แกแแฅแแฆแแแแแก แแ แแแแก แแแแแขแแก แแแฎแกแแ
Open a folder or app bundleโฆ แกแแฅแแฆแแแแแก แแ แแแแก แแแแแขแแก แแแฎแกแแโฆ
Open a folderโฆ แกแแฅแแฆแแแแแก แแแฎแกแแโฆ
Open a pinned build แแแแแแ แแแฃแแ แแฌแงแแแแก แแแฎแกแแ
Open a project's folder แแ แแแฅแขแแก แกแแฅแแฆแแแแแก แแแฎแกแแ
Open a website แแแแกแแแขแแก แแแฎแกแแ
Open an app or file แแแแก แแ แคแแแแแก แแแฎแกแแ
Open an engine's app แซแ แแแแก แแแแก แแแฎแกแแ
Open another copy แกแฎแแ แแกแแแก แแแฎแกแแ
Open another target แกแฎแแ แกแแแแแแแก แแแฎแกแแ
Open files, folders or apps; you can have several open at once. แแแฎแกแแแแ แคแแแแแแ, แกแแฅแแฆแแแแแแแ แแ แแแแแ; แแ แแแ แแฃแแแ แ แแแแแแแแแก แแแฎแกแแ แจแแแแซแแแแ.
Open folder แกแแฅแแฆแแแแแก แแแฎแกแแ
Open in the workbench แกแแแฃแจแแ แแแแแแแแ แแแฎแกแแ
Open it แแแฎแกแแ
Open log แแฃแ แแแแแก แแแฎแกแแ
Open one of the files inside it to see its bytes. แแแฎแกแแแแ แจแแแแแ แแ แกแแแฃแแ แแ แ-แแ แแ แคแแแแ, แ แแ แแแกแ แแแแขแแแ แแแฎแแ.
Open questions แแแกแฃแฎแแแฃแชแแแแแ แแแแฎแแแแ
Open something แ แแแแก แแแฎแกแแ
Open something first: drop a file or app here, or choose "Just look inside" on New project. Then I can look inside it. แฏแแ แ แแแ แแแฎแกแแแแ: แฉแแแแแแ แแฅ แคแแแแ แแ แแแ, แแ โแแฎแแ แแ แแแฅแขแจแโ แแแ แฉแแแ โแแฎแแแแ แจแแแแแ แฉแแฎแแแแโ. แจแแแแแ แจแแแซแแแ แแแก แจแแแแแ แฉแแฎแแแแแก.
Open something to start แแแกแแฌแงแแแแ แ แแแ แแแฎแกแแแแ
Open the Epic Games Launcher Epic Games Launcher-แแก แแแฎแกแแ
Open the app แแแแก แแแฎแกแแ
Open the app you're curious about. แแแฎแกแแแแ แแแ, แ แแแแแแช แแแแแขแแ แแกแแแ.
Open the download page แฉแแแแขแแแ แแแแก แแแแ แแแก แแแฎแกแแ
Open the folder แกแแฅแแฆแแแแแก แแแฎแกแแ
Open the installer app แแแกแขแแแแขแแ แแก แแแแก แแแฎแกแแ
Open the website แแแแกแแแขแแก แแแฎแกแแ
Open {name} {name}-แแก แแแฎแกแแ
Opened {name} แแแแฎแกแแ: {name}
Opened {name}. Taking a first lookโฆ แแแแฎแกแแ: {name}. แแแ แแแแ แแแแแแแแแ แแแโฆ
Opened {} แแแแฎแกแแ: {}
Opening {name}โฆ แแฎแกแแแแ: {name}โฆ
Openโฆ แแแฎแกแแโฆ
Or type your answerโฆ แแ แแแ แแคแแ แแฅแแแแ แแแกแฃแฎแโฆ
Original แแ แแแแแแแ
Other pages of a website studied and compared besides the one you gave. แแแแกแแแขแแก แกแฎแแ แแแแ แแแแ, แจแแกแฌแแแแแแ แแ แจแแแแ แแแฃแแ แแฅแแแ แแแแ แแแแแแแแฃแแแก แแแ แแ.
Overview แแแแแฎแแแแ
Packet capture overview แแแแแขแแแแก แฉแแแแฌแแ แแก แแแแแฎแแแแ
Packet fields แแแแแขแแก แแแแแแ
Page through evidence แแขแแแชแแแฃแแแแแแแก แคแฃแ แชแแแ
Part of the app got stuck, so it was stopped and the rest carried on. Your work is kept. แแแแก แแแฌแแแ แแแแญแแแ, แแแแขแแ แแก แจแแฉแแ แแ, แแแแแ แฉแแแแ แแ แแฃแจแแแแ แแแแแ แซแแแ. แแฅแแแแ แแแแฃแจแแแแ แ แจแแแแฎแฃแแแ.
Part of the app is stuck. Restarting clears it, and your work is kept. แแแแก แแแฌแแแ แแแแญแแแ. แแแแแขแแแ แแแ แแแแก แแแแแแกแฌแแ แแแก, แแฅแแแแ แแแแฃแจแแแแ แ แแ แจแแแแฎแฃแแแ.
Part of this screen hit a bug and was skipped. Your work is safe. แแ แแแ แแแแก แแแฌแแแก แจแแชแแแแ แจแแฎแแแ แแ แแแแแขแแแแแฃแ แแฅแแ. แแฅแแแแ แแแแฃแจแแแแ แ แฃแกแแคแ แแฎแแแแ.
Paste pictures แกแฃแ แแแแแแก แฉแแกแแ
Paste your API key (kept in your system keychain) แฉแแกแแแ แแฅแแแแ API แแแกแแฆแแแ (แแแแฎแแแ แแฅแแแแ แกแแกแขแแแแก แแแกแแฆแแแแแแก แกแแชแแแจแ)
Paste your {name} key แฉแแกแแแ แแฅแแแแ {name} แแแกแแฆแแแ
Path แแแแแแ
Pause แแแฃแแ
Pausingโฆ แแแฃแแแแ แแแงแแแแแโฆ
Pause the build first, then delete the project. แฏแแ แแแแแแฃแแแ แแฌแงแแแ, แจแแแแแ แฌแแจแแแแ แแ แแแฅแขแ.
Pause the build first. แฏแแ แแแแแแฃแแแ แแฌแงแแแ.
Paused แแแแแฃแแแแฃแแแ
Paused. แแแแแฃแแแแฃแแแ.
Pick a folder with projects in it แแแ แฉแแแ แกแแฅแแฆแแแแ, แ แแแแแจแแช แแ แแแฅแขแแแแ
Pick a game's folder แแแ แฉแแแ แแแแแจแแก แกแแฅแแฆแแแแ
Pick another folderโฆ แกแฎแแ แกแแฅแแฆแแแแแก แแ แฉแแแโฆ
Pick another game แกแฎแแ แแแแแจแแก แแ แฉแแแ
Pick something on the left แแแ แฉแแแ แ แแแ แแแ แชแฎแแแ
Pick the app or game folder แแแ แฉแแแ แแแแก แแ แแแแแจแแก แกแแฅแแฆแแแแ
Pick the app, game or file to rebuild แแแ แฉแแแ แแแ, แแแแแจแ แแ แคแแแแ แฎแแแแฎแแ แแกแแฌแงแแแแ
Pick the folder for this project แแแ แฉแแแ แกแแฅแแฆแแแแ แแ แแ แแแฅแขแแกแแแแก
Pick the game's folder แแแ แฉแแแ แแแแแจแแก แกแแฅแแฆแแแแ
Picture a program's window แแ แแแ แแแแก แคแแแฏแ แแก แกแฃแ แแแแก แแแแแฆแแแ
Picture model แกแฃแ แแแแแแก แแแแแแ
Pictures แกแฃแ แแแแแ
Pictures can't be saved from IoStore containers yet; you can see what's inside. IoStore แแแแขแแแแแ แแแแแแ แกแฃแ แแแแแแก แจแแแแฎแแ แฏแแ แจแแฃแซแแแแแแแ; แจแแแแแแกแแก แแแฎแแ แจแแแแซแแแแ.
Pictures of the original แแ แแแแแแแแก แกแฃแ แแแแแ
Pieces of text stored inside a program, like messages, web addresses or file names. แแ แแแ แแแแก แจแแแแแ แจแแแแฎแฃแแ แขแแฅแกแขแแก แแแฌแแแแแ, แแแแแแแแแ แจแแขแงแแแแแแแแแ, แแแแแแกแแแแ แแแแ แแ แคแแแแแแแก แกแแฎแแแแแ.
Pin a build แแฌแงแแแแก แแแแแแ แแแ
Pin a project's build แแ แแแฅแขแแก แแฌแงแแแแก แแแแแแ แแแ
Pin it แแแแแแ แแแ
Pin name แแแแแแ แแแแก แกแแฎแแแ
Pin removed. แแแแแแ แแแ แแแแฎแกแแ.
Pin this build แแ แแฌแงแแแแก แแแแแแ แแแ
Pinned แแแแแแ แแแฃแแแ
Pinned builds แแแแแแ แแแฃแแ แแฌแงแแแแแ
Pinned: {name}. Open it from the sidebar any time. แแแแแแ แแแฃแแแ: {name}. แแแฎแกแแแแ แแแแ แแแแ แแแแแแแแแ แแแแแกแแแแ แแ แแก.
Plain words, big buttons, and I'll explain everything. แแแ แขแแแ แกแแขแงแแแแ, แแแแ แฆแแแแแแแ, แแ แงแแแแแคแแ แก แแแแฎแกแแแ.
Plain words, short sentences, and every technical word explained. แแแ แขแแแ แกแแขแงแแแแ, แแแแแ แฌแแแแแแแแแแแ แแ แงแแแแแ แขแแฅแแแแฃแ แ แกแแขแงแแแก แแฎแกแแ.
Plan แแแแแ
Plan connecting agent apps แแแแแขแแก แแแแแแก แแแแแแจแแ แแแแก แแแแแแแแ
Play a project's result แแ แแแฅแขแแก แจแแแแแแก แแแจแแแแ
Play the game แแแแแจแแก แแแจแแแแ
Plugin added. Read its tools to start using them. แแแแแแแ แแแแแแขแ. แแแกแ แฎแแแกแแฌแงแแแแแก แแแแแกแแงแแแแแแแ แฏแแ แฌแแแแแแฎแแ แแกแแแ.
Plugin arguments แแแแแแแแก แแ แแฃแแแแขแแแ
Plugin command or address แแแแแแแแก แแ แซแแแแแ แแ แแแกแแแแ แแ
Plugin id แแแแแแแแก id
Plugin removed. แแแแแแแ แฌแแแจแแแ.
Plugins แแแแแแแแแ
Plugins add tools Craft Anything offers as its own: MCP servers (a command or an address; read their tools after adding) or WebAssembly components (a .wasm file, which can't touch your files or the network). แแแแแแแแแ แแแแขแแแก แฎแแแกแแฌแงแแแแก, แ แแแแแแกแแช Craft Anything แกแแแฃแแแ แแแแ แแแแแแแแแ: MCP แกแแ แแแ แแแก (แแ แซแแแแแ แแ แแแกแแแแ แแ; แแแแแขแแแแก แจแแแแแ แฌแแแแแแฎแแ แแแแ แฎแแแกแแฌแงแแแแ) แแ WebAssembly แแแแแแแแแขแแแก (.wasm แคแแแแ, แ แแแแแแช แแฅแแแแก แคแแแแแแกแ แแ แฅแกแแแก แแแ แแฎแแแ).
Plugins added here always ask before each call. แแฅ แแแแแขแแแฃแแ แแแแแแแแแ แงแแแแแ แแแแแซแแฎแแแแก แฌแแ แงแแแแแแแแก แแแแฎแฃแแแแก.
Plugins read. Their new tools are offered from the next start. แแแแแแแแแ แฌแแแแแฎแฃแแแ. แแแแ แแฎแแแ แฎแแแกแแฌแงแแแแ แจแแแแแแ แแแจแแแแแแแ แแฅแแแแ แจแแแแแแแแแแแฃแแ.
Preserving software that's no longer supported. แแ แแแ แแแแแแก แจแแแแ แฉแฃแแแแ, แ แแแแแแแช แแฆแแ แแ แแก แแฎแแ แแแญแแ แแแ.
Preview a project's website แแ แแแฅแขแแก แแแแกแแแขแแก แฌแแแแกแฌแแ แ แแแฎแแ
Preview the website แแแแกแแแขแแก แฌแแแแกแฌแแ แ แแแฎแแ
Previous address แฌแแแ แแแกแแแแ แแ
Program: found automatically แแ แแแ แแแ: แแแแแแแแ แแแขแแแแขแฃแ แแ
Program: {path} แแ แแแ แแแ: {path}
Programs (native code) แแ แแแ แแแแแ (แแแขแแฃแ แ แแแแ)
Progress แแ แแแ แแกแ
Project details แแ แแแฅแขแแก แแแขแแแแแ
Project name แแ แแแฅแขแแก แกแแฎแแแ
Projects แแ แแแฅแขแแแ
Projects and builds แแ แแแฅแขแแแ แแ แแฌแงแแแแแ
Property list แแแแกแแแแแแก แกแแ
Pseudo-C แคแกแแแแ-C
Purpose แแแแแจแแฃแแแแ
Raise the asset budget แ แแกแฃแ แกแแแแก แแแฃแฏแแขแแก แแแแ แแ
Raise the budget by {amount} แแแฃแฏแแขแแก แแแแ แแ {amount}-แแ
Raw machine code แแแแแ แแแแฅแแแฃแ แ แแแแ
Read AI settings AI-แแก แแแ แแแแขแ แแแแก แฌแแแแแฎแแ
Read a Unity game's IL2CPP metadata Unity แแแแแจแแก IL2CPP แแแขแแแแแแชแแแแแแก แฌแแแแแฎแแ
Read a game's files แแแแแจแแก แคแแแแแแแก แฌแแแแแฎแแ
Read a project file แแ แแแฅแขแแก แคแแแแแก แฌแแแแแฎแแ
Read a setting แแแ แแแแขแ แแก แฌแแแแแฎแแ
Read a text file แขแแฅแกแขแฃแ แ แคแแแแแก แฌแแแแแฎแแ
Read an app's screen แแแแก แแแ แแแแก แฌแแแแแฎแแ
Read bytes แแแแขแแแแก แฌแแแแแฎแแ
Read comment แแแแแแขแแ แแก แฌแแแแแฎแแ
Read inline comment แฉแแแแแฃแแ แแแแแแขแแ แแก แฌแแแแแฎแแ
Read its tools แแแกแ แฎแแแกแแฌแงแแแแแก แฌแแแแแฎแแ
Read pinned builds แแแแแแ แแแฃแแ แแฌแงแแแแแแก แฌแแแแแฎแแ
Read projects แแ แแแฅแขแแแแก แฌแแแแแฎแแ
Read the journal แแฃแ แแแแแก แฌแแแแแฎแแ
Read the plugin's tools แแแแแแแแก แฎแแแกแแฌแงแแแแแก แฌแแแแแฎแแ
Read the project แแ แแแฅแขแแก แฌแแแแแฎแแ
Reading what's insideโฆ แจแแแแแแกแแก แฌแแแแแฎแแโฆ
Ready แแแแแแ
Ready: {what} is on this computer. แแแแแแ: {what} แแ แแแแแแฃแขแแ แแแ.
Rebuild status แฎแแแแฎแแแ แแฌแงแแแแก แแแแแแแ แแแแ
Record a finding แแแแแแแแก แฉแแฌแแ แ
Record a hypothesis แฐแแแแแแแแก แฉแแฌแแ แ
Record an open question แแแกแฃแฎแแแฃแชแแแแแ แแแแฎแแแก แฉแแฌแแ แ
Recover readable sources แฌแแแแแฎแแแแ แฌแงแแ แแแแแก แแฆแแแแแ
Recreate it with darker colours แฎแแแแฎแแ แจแแฅแแแ แฃแคแ แ แแฃแฅแ แคแแ แแแแ
Recreate just its main feature แแฎแแแแ แแแกแ แแแแแแ แ แคแฃแแฅแชแแแก แฎแแแแฎแแ แจแแฅแแแ
Recreate this website แแ แแแแกแแแขแแก แฎแแแแฎแแ แจแแฅแแแ
Recreated games are built with the original's own engine when it's here (Unity, Unreal or Godot), else Unity, and Rust as the last resort. แฎแแแแฎแแ แจแแฅแแแแแ แแแแแจแแแ แแ แแแแแแแแก แกแแแฃแแแ แ แซแ แแแแ แแแฌแงแแแ, แแฃ แแก แแฅแแ (Unity, Unreal แแ Godot), แแฃ แแ แ โ Unity-แแ, แแแแ แแแแแกแแแแแ แแ Rust-แแ.
References to a name แแแแแ แแแแแ แกแแฎแแแแ
Refining rounds แแแฎแแแฌแแก แ แแฃแแแแแ
Refresh plugins แแแแแแแแแแก แแแแแฎแแแแ
Regions of a program file, each with one purpose: code, text, pictures, settings. แแ แแแ แแแแก แคแแแแแก แ แแแแแแแแ, แแแแแแฃแแ แแ แแ แแแแแจแแฃแแแแแ: แแแแ, แขแแฅแกแขแ, แกแฃแ แแแแแ, แแแ แแแแขแ แแแ.
Reload แฎแแแแฎแแ แฉแแขแแแ แแแ
Remember permission แแแแแ แแแแก แแแแแฎแกแแแ แแแ
Remove แฌแแจแแ
Remove a pin แแแแแแ แแแแก แแแฎแกแแ
Remove a pinned build แแแแแแ แแแฃแแ แแฌแงแแแแก แฌแแจแแ
Remove a plugin แแแแแแแแก แฌแแจแแ
Remove an AI AI-แแก แฌแแจแแ
Remove an app แแแแก แฌแแจแแ
Remove an asset key แ แแกแฃแ แกแแแแก แแแกแแฆแแแแก แฌแแจแแ
Remove bookmark แกแแแแจแแแก แฌแแจแแ
Remove it แฌแแจแแ
Remove it and its key แแแกแ แแ แแแกแ แแแกแแฆแแแแก แฌแแจแแ
Remove {name} {name}-แแก แฌแแจแแ
Remove {name}? แฌแแแจแแแแ {name}?
Removeโฆ แฌแแจแแโฆ
Rename แกแแฎแแแแก แจแแชแแแ
Rename a pinned build แแแแแแ แแแฃแแ แแฌแงแแแแก แกแแฎแแแแก แจแแชแแแ
Rename a project แแ แแแฅแขแแก แกแแฎแแแแก แจแแชแแแ
Rename the pin แแแแแแ แแแแก แกแแฎแแแแก แจแแชแแแ
Rename the project แแ แแแฅแขแแก แกแแฎแแแแก แจแแชแแแ
Renameโฆ แกแแฎแแแแก แจแแชแแแโฆ
Reset แฉแแแแงแ แ
Resolve a call แแแแแซแแฎแแแแก แแแ แแแแแ
Resolved แแแแแฌแงแแแขแแแแ
Resources แ แแกแฃแ แกแแแ
Restart แแแแแขแแแ แแแ
Restore แแฆแแแแแ
Result แจแแแแแ
Resume a Frida session Frida-แก แกแแกแแแก แแแแแฎแแแแ
Rizin command Rizin-แแก แแ แซแแแแแ
Rizin debug command Rizin-แแก แแแแแ แแแแก แแ แซแแแแแ
Rizin debug session status Rizin-แแก แแแแแ แแแแก แกแแกแแแก แแแแแแแ แแแแ
Rough guide: แแแแฎแแแแแแ:
Run แแแจแแแแ
Run a Frida script Frida-แก แกแแ แแแขแแก แแแจแแแแ
Run a build command แแฌแงแแแแก แแ แซแแแแแแก แแแจแแแแ
Run a scripted Electron session Electron-แแก แกแแ แแแขแฃแแ แกแแกแแแก แแแจแแแแ
Run a scripted web session แกแแ แแแขแฃแแ แแแแกแแกแแแก แแแจแแแแ
Run a tool from the command palette (Ctrl/โ K), or pick a finding in the Evidence panel. แแแฃแจแแแ แฎแแแกแแฌแงแ แแ แซแแแแแแแแก แแแแแขแ แแแแ (Ctrl/โ K) แแ แแแ แฉแแแ แแแแแแแ โแแขแแแชแแแฃแแแแแแแกโ แแแแแแจแ.
Run and watch a program แแ แแแ แแแแก แแแจแแแแ แแ แแแแแแ แแแแ
Run to study แแแจแแแแ แจแแกแแกแฌแแแแแ
Running แแฃแจแแแแก
Running processes แแแจแแแแฃแแ แแ แแชแแกแแแ
Running programs แแแจแแแแฃแแ แแ แแแ แแแแแ
Running {id} แแฃแจแแแแก: {id}
Runs its tools without asking แแแแแก แฎแแแกแแฌแงแแแแก แแแแฎแแแก แแแ แแจแ แฃแจแแแแก
Runs the first-run steps next time. แจแแแแแ แฏแแ แแ แแแ แแแแ แแแจแแแแแก แแแแแฏแแแก แจแแแกแ แฃแแแแก.
Rust program details Rust แแ แแแ แแแแก แแแขแแแแแ
SHA-256 SHA-256
SQLite database contents SQLite แแแแแชแแแแ แแแแแก แจแแแแแแกแ
Safety แฃแกแแคแ แแฎแแแแ
Save แจแแแแฎแแ
Save a picture แกแฃแ แแแแก แจแแแแฎแแ
Save a report แแแแแ แแจแแก แจแแแแฎแแ
Save an asset key แ แแกแฃแ แกแแแแก แแแกแแฆแแแแก แจแแแแฎแแ
Save picture แกแฃแ แแแแก แจแแแแฎแแ
Save settings แแแ แแแแขแ แแแแก แจแแแแฎแแ
Save the key แแแกแแฆแแแแก แจแแแแฎแแ
Save the picture แกแฃแ แแแแก แจแแแแฎแแ
Save the report แแแแแ แแจแแก แจแแแแฎแแ
Saved แจแแแแฎแฃแแแ
Saved in แจแแแแฎแฃแแแ:
Saves space: copies the program and code, and shares dependencies and media with the project. A shared file rewritten in place changes here too. แแแแแแก แแแแแแก: แแแแแแ แแแก แแ แแแ แแแแกแ แแ แแแแก, แฎแแแ แแแแแแแแแแฃแแแแแแกแ แแ แแแแแแก แแ แแแฅแขแแแ แแแแแ แแแก. แแแแแแแ แแแแแฌแแ แแแ แกแแแ แแ แคแแแแ แแฅแแช แจแแแชแแแแแ.
Say what you want แแฅแแแ, แ แ แแแแแแ
Say what you want first. แฏแแ แแฅแแแ, แ แ แแแแแแ.
This applies once you choose something to recreate above. แแก แแแฅแแแแแแก, แ แแชแ แแแแแ แแแ แฉแแแ, แ แแกแ แฎแแแแฎแแ แจแแฅแแแ แแกแฃแ แ.
Say what you want to make, or drop an app or file on the window to look inside it. Everything runs in Clean room mode unless you switch on Deep. แแฅแแแ, แ แแกแ แจแแฅแแแ แแกแฃแ แ, แแ แฉแแแแแแ แแแ แแ แคแแแแ แคแแแฏแแ แแแ, แ แแ แแแก แจแแแแแ แฉแแแฎแแแแ. แงแแแแแคแแ แ แกแฃแคแแ แแแแฎแแก แ แแแแแจแ แแฃแจแแแแก, แกแแแแ แฆแ แแ แ แแแแแก แแ แฉแแ แแแแ.
Screenshot แแแ แแแแก แแแแแแญแแ
Screenshot a page แแแแ แแแก แแแ แแแแก แแแแแแญแแ
Screenshots of how it should look. The builder opens each one and matches it. แแแ แแแแก แแแแแแญแแแแ แแแแกแ, แ แแแแ แฃแแแ แแแแแแงแฃแ แแแแแแก. แจแแแฅแแแแแ แแแแแแฃแแก แฎแกแแแก แแ แแแก แแแแฎแแแแ.
Search for bytes แแแแขแแแแก แซแแแแ
Search functions แคแฃแแฅแชแแแแแก แซแแแแ
Search strings แกแขแ แแฅแแแแแแก แซแแแแ
Sections แกแแฅแชแแแแ
Security research on software I'm allowed to examine. แฃแกแแคแ แแฎแแแแแก แแแแแแ แแ แแแ แแแแแ, แ แแแแแก แจแแกแฌแแแแแก แฃแคแแแแแช แแแฅแแก.
See how a page is built: its layout, styles, scripts and the requests it makes. แแแฎแแ, แ แแแแ แแ แแก แแแแแฃแแ แแแแ แแ: แแแกแ แแแแแแแแแ, แกแขแแแแแ, แกแแ แแแขแแแ แแ แแแแฎแแแแแแ, แ แแแแแแกแแช แแแแแแแแก.
See how a program works: what it does, what it talks to, what's inside. แแแฎแแ, แ แแแแ แแฃแจแแแแก แแ แแแ แแแ: แ แแก แแแแแแแก, แ แแก แฃแแแแจแแ แแแแ, แ แ แแ แแก แจแแแแแ.
See what a game packs and save its pictures as PNG files. Only for games you made, or whose owner lets you. แแแฎแแ, แ แแก แจแแแชแแแก แแแแแจแ, แแ แจแแแแแฎแแ แแแกแ แกแฃแ แแแแแ PNG แคแแแแแแแ. แแฎแแแแ แแ แแแแแจแแแแกแแแแก, แ แแแแแแแช แแฅแแแ แจแแฅแแแแแ แแ แ แแแแแแ แแคแแแแแแแช แแแแก แฃแคแแแแแก แแแซแแแแ.
See what a game packs, and save its pictures as PNG files. แแแฎแแ, แ แแก แจแแแชแแแก แแแแแจแ, แแ แจแแแแแฎแแ แแแกแ แกแฃแ แแแแแ PNG แคแแแแแแแ.
See what a stand-in was asked แจแแแชแแแแแแกแแแแก แแแกแแฃแแ แแแแฎแแแแแแแก แแแฎแแ
See which servers an app talks to, and what it says. แแแฎแแ, แ แแแแ แกแแ แแแ แแแก แฃแแแแจแแ แแแแ แแแ แแ แ แแก แแฃแแแแแ แแแ.
Seen it แแแแแฎแแ
Seen it: read directly from the file, page or capture. แแแแฎแแ: แฌแแแแแฎแฃแแแ แแแ แแแแแ แคแแแแแแแ, แแแแ แแแแแ แแ แฉแแแแฌแแ แแแแ.
Selected แแแแแจแแฃแแแ
Selection แแแแแจแแฃแแ
Send แแแแแแแแ
Send (Enter) แแแแแแแแ (Enter)
Send now แแฎแแแแ แแแแแแแแ
Server address แกแแ แแแ แแก แแแกแแแแ แแ
Session status แกแแกแแแก แแแแแแแ แแแแ
Set a project's asset budget แแ แแแฅแขแแก แ แแกแฃแ แกแแแแก แแแฃแฏแแขแแก แแแงแแแแแ
Set an AI's program AI-แแก แแ แแแ แแแแก แแแงแแแแแ
Set one up แแแงแแแแแ
Set up a brainโฆ โแขแแแแแกโ แแแงแแแแแโฆ
Set up a builder แจแแแฅแแแแแแก แแแงแแแแแ
Settings แแแ แแแแขแ แแแ
Show a build's activity แแฌแงแแแแก แแฅแขแแแแแแก แฉแแแแแแ
Show a project แแ แแแฅแขแแก แฉแแแแแแ
Show folder แกแแฅแแฆแแแแแก แฉแแแแแแ
Show me everything แงแแแแแคแ แแก แฉแแแแแแ
Show me the proof แแแกแขแฃแ แแก แฉแแแแแแ
Show pinned builds แแแแแแ แแแฃแแ แแฌแงแแแแแแก แฉแแแแแแ
Show settings แแแ แแแแขแ แแแแก แฉแแแแแแ
Show the answer แแแกแฃแฎแแก แฉแแแแแแ
Show the console แแแแกแแแแก แฉแแแแแแ
Show the folder แกแแฅแแฆแแแแแก แฉแแแแแแ
Show the ones that are met แจแแกแ แฃแแแแฃแแแแแก แฉแแแแแแ
Show the sidebar แแแแ แแแแ แแแแแแแก แฉแแแแแแ
Show the welcome again แแแกแแแแแแแก แฎแแแแฎแแ แฉแแแแแแ
Showing แแแฉแแแแแแแ
Sign in and add the Unity Editor แจแแแแ แกแแกแขแแแแจแ แแ แแแแแแขแแ Unity Editor
Sign in and install Unreal Engine แจแแแแ แกแแกแขแแแแจแ แแ แแแแแแกแขแแแแ แแ Unreal Engine
Simple แแแ แขแแแ
Simple: say what you want and it's handled for you. Advanced: every tool, the evidence and the logs. แแแ แขแแแ: แแฅแแแ, แ แ แแแแแแ, แแ แงแแแแแคแแ แก แแฅแแแ แแแชแแแแ แแแแแแแแแก. แแแแแขแแแแแ: แงแแแแ แฎแแแกแแฌแงแ, แแขแแแชแแแฃแแแแแแ แแ แแฃแ แแแแแแ.
Since Craft Anything opened. Craft Anything-แแก แแแฎแกแแแก แจแแแแแ.
Size แแแแ
Skip setup แแแงแแแแแแก แแแแแขแแแแแ
Smart contract interface แญแแแแแแ แแแแขแ แแฅแขแแก แแแขแแ แคแแแกแ
Software I made, bought, or have permission to examine. แแ แแแ แแแ, แ แแแแแแช แจแแแฅแแแแ, แแแงแแแ แแ แ แแแแแก แจแแกแฌแแแแแก แแแแแ แแแแช แแแฅแแก.
Solana program (sBPF) Solana แแ แแแ แแแ (sBPF)
Some plugins couldn't be read: แแแแแแ แแ แแแแแแแแก แฌแแแแแฎแแ แแแ แแแฎแแ แฎแแ:
Something a program borrows from the operating system or a library, like "open a file". แ แแฆแแช, แ แแกแแช แแ แแแ แแแ แแแแ แแชแแฃแแ แกแแกแขแแแแแแ แแ แแแแแแแแแแแแแ แกแแกแฎแฃแแแแก, แแแแแแแแแ โแคแแแแแก แแแฎแกแแโ.
Something a program or library offers for other programs to use. แ แแฆแแช, แ แแกแแช แแ แแแ แแแ แแ แแแแแแแแแแ แกแฎแแ แแ แแแ แแแแแก แแแแแกแแงแแแแแแแ แกแแแแแแแแก.
Source แฌแงแแ แ
Start แแแฌแงแแแ
Start a Frida session Frida-แก แกแแกแแแก แแแฌแงแแแ
Start a GDB session GDB-แแก แกแแกแแแก แแแฌแงแแแ
Start a Rizin debug session Rizin-แแก แแแแแ แแแแก แกแแกแแแก แแแฌแงแแแ
Start a rebuild แฎแแแแฎแแแ แแฌแงแแแแก แแแฌแงแแแ
Start a stand-in backend แจแแแชแแแแแ แแแฅแแแแแก แแแจแแแแ
Start an activity แแฅแขแแแแแแก แแแจแแแแ
Start building แแฌแงแแแแก แแแฌแงแแแ
Start from them แแแแแ แแแฌแงแแแ
Start it แแแจแแแแ
Start with Simple mode; you can set up AI later in Settings. แแแแฌแงแแ แแแ แขแแแ แ แแแแแแ; AI-แแก แแแงแแแแแ แแแแแแแแแแแ แแแ แแแแขแ แแแจแ แจแแแแซแแแแ.
Startingโฆ แแจแแแแโฆ
Startingโฆ it opens in its own window. แแจแแแแโฆ แแก แกแแแฃแแแ แคแแแฏแแ แแจแ แแแแฎแกแแแแ.
Still working. Bigger jobs can take a few minutes. แฏแแ แแแแแ แแฃแจแแแแก. แแแ แแแแแแแแแแก แจแแแซแแแแ แ แแแแแแแแ แฌแฃแแ แแแกแญแแ แแแก.
Stop แจแแฌแงแแแขแ
Stop a pinned build แแแแแแ แแแฃแแ แแฌแงแแแแก แจแแฌแงแแแขแ
Stop a rebuild แฎแแแแฎแแแ แแฌแงแแแแก แจแแฌแงแแแขแ
Stop a stand-in backend แจแแแชแแแแแ แแแฅแแแแแก แจแแฌแงแแแขแ
Stop generated assets แ แแกแฃแ แกแแแแก แแแแแ แแ แแแแก แจแแฌแงแแแขแ
Stop listing {folder} {folder}-แแก แกแแแจแ แฉแแแแแแแก แจแแฌแงแแแขแ
Stopped here แแฅ แจแแฉแแ แแ
Stops the current step and sends your notes straight away. แแฉแแ แแแก แแแแแแแแ แ แแแแแฏแก แแ แแฅแแแแก แจแแแแจแแแแแก แแแจแแแแ แแแแแแแแก.
Strings แกแขแ แแฅแแแแแ
Studio แกแขแฃแแแ
Studio (dark) แกแขแฃแแแ (แแแแแ)
Studio Light แกแขแฃแแแ (แฆแแ)
Study แจแแกแฌแแแแ
Study apps by running them แแแแแแก แจแแกแฌแแแแ แแแแ แแแจแแแแแ
Studying แจแแกแฌแแแแ แแแแแแแแ แแแแก
Studying software to understand it. แแ แแแ แแแแก แจแแกแฌแแแแ แแแก แแแกแแแแแแ.
Summarise what changed แชแแแแแแแแแแก แจแแฏแแแแแ
Swift types Swift แขแแแแแ
Switch Beginner / Experienced แแแแฌแงแแแ / แแแแแชแแแแ แ แแแแแแก แแแแแ แแแ
Switch Clean room / Deep แกแฃแคแแ แแแแฎแ / แฆแ แแ แ แแแแแแก แแแแแ แแแ
Switch light / dark theme แฆแแ / แแแแแ แแแแแก แแแแแ แแแ
Switch target แกแแแแแแแก แจแแชแแแ
System แกแแกแขแแแ
System services แกแแกแขแแแแก แกแแ แแแกแแแ
Take a texture out of an Unreal game Unreal แแแแแจแแแแ แขแแฅแกแขแฃแ แแก แแแแฆแแแ
Take an asset out of a Unity game Unity แแแแแจแแแแ แ แแกแฃแ แกแแก แแแแฆแแแ
Take back a note แจแแแแจแแแแก แฃแแแ แแแแ แฃแแแแ
Take back: puts it in the box again แฃแแแ แแแแ แฃแแแแ: แแกแแ แแแแจแ แแแ แฃแแแแก
Take files out of an Unreal pak Unreal pak-แแแแ แคแแแแแแแก แแแแฆแแแ
Take out packed files แจแแคแฃแแฃแแ แคแแแแแแแก แแแแฆแแแ
Target แกแแแแแแ
Targets แกแแแแแแแแแ
That folder already has {names}, where Craft Anything keeps its own files. Pick another folder, or move those out first. แแ แกแแฅแแฆแแแแแจแ แฃแแแ แแ แแก {names}, แกแแแแช Craft Anything แกแแแฃแแแ แคแแแแแแก แแแแฎแแแก. แแแ แฉแแแ แกแฎแแ แกแแฅแแฆแแแแ แแ แฏแแ แแกแแแ แแแแแแขแแแแ.
That folder is already a project, so it's open now. แแก แกแแฅแแฆแแแแ แฃแแแ แแ แแแฅแขแแ, แแแแขแแ แแก แแฎแแ แแแฎแกแแแแแ.
The Rust toolchain (rustup.rs). Rust-แแก แฎแแแกแแฌแงแแแ แแแแ แแแ (rustup.rs).
The builder answers its own questions and says what it chose ("I decided: โฆ"), so you can change it. แจแแแฅแแแแแ แแแแแก แแแแฎแแแแก แแแแแ แแแกแฃแฎแแแก แแ แแแแแแก, แ แ แแแ แฉแแ (โแแแแแแฌแงแแแขแ: โฆโ), แ แแ แจแแชแแแ แจแแซแแแ.
The builder makes the game's 3D models and textures from descriptions of original designs, paid from your fal.ai account. Models are low-poly so the game runs fast. A textured model costs {model} and a picture {picture}. Each project has a {budget} budget, and you're asked before it goes over. The key is kept in your system keychain. แจแแแฅแแแแแ แแแแแจแแก 3D แแแแแแแแกแ แแ แขแแฅแกแขแฃแ แแแก แแ แแแแแแแฃแ แ แแแแแแแแแแก แแฆแฌแแ แแแแแแ แฅแแแแก, แแฅแแแแ fal.ai แแแแแ แแจแแก แฎแแ แฏแแ. แแแแแแแแ แแแแแแแแแแแแแฃแ แแ, แ แแ แแแแแจแ แกแฌแ แแคแแ แแฃแจแแแแแแก. แขแแฅแกแขแฃแ แแแแ แแแแแแ แฆแแ แก {model}, แกแฃแ แแแ โ {picture}. แงแแแแ แแ แแแฅแขแก แแฅแแก {budget} แแแฃแฏแแขแ แแ แแแก แแแแแญแแ แแแแแแแ แแแแแฎแแแแ. แแแกแแฆแแแ แแแแฎแแแ แแฅแแแแ แกแแกแขแแแแก แแแกแแฆแแแแแแก แกแแชแแแจแ.
The builder reads them (code, notes, pictures) and builds the app in a new app folder beside them. Your files stay as they are. แจแแแฅแแแแแ แแแ แแแแฎแฃแแแแก (แแแแก, แจแแแแจแแแแแก, แกแฃแ แแแแแก) แแ แแแก แแแ แแแแ แแแ แแฎแแ app แกแแฅแแฆแแแแแจแ แแฌแงแแแก. แแฅแแแแ แคแแแแแแ แฃแชแแแแแแ แ แฉแแแ.
The builder will decide its questions and tell you what it chose. แจแแแฅแแแแแ แแแแแก แแแแฎแแแแก แแแแแ แแแแแฌแงแแแขแก แแ แแแขแงแแแ, แ แ แแแ แฉแแ.
The builder works on these files directly and keeps what works. Craft Anything adds a few records of its own beside them. แจแแแฅแแแแแ แแ แคแแแแแแแ แแแ แแแแแ แแฃแจแแแแก แแ แแแแฎแแแก แแแแก, แ แแช แแฃแจแแแแก. Craft Anything แแแ แแแแ แแแ แ แแแแแแแแ แกแแแฃแแแ แฉแแแแฌแแ แก แแแแขแแแก.
The builder's questions แจแแแฅแแแแแแก แแแแฎแแแแ
The builder's questions come to you as cards, and it waits for your answer. แจแแแฅแแแแแแก แแแแฎแแแแ แแแ แแแแแแ แแแแแแแ แแ แแก แแฅแแแแก แแแกแฃแฎแก แแแแแแแแแ.
The builder's questions will come to you. แจแแแฅแแแแแแก แแแแฎแแแแ แแฅแแแ แแแแแแแ.
The built-in engines still show you everything they find. แฉแแจแแแแแฃแแ แซแ แแแแแ แแแแแช แแแฉแแแแแแ แงแแแแแคแแ แก, แ แแกแแช แแแฃแแแแก.
The clipboard can't be read: แแแชแแแแก แแฃแคแแ แแก แฌแแแแแฎแแ แแแ แแแฎแแ แฎแแ:
The code แแแแ
The code format Android apps use. แแแแแก แคแแ แแแขแ, แ แแแแแกแแช Android แแแแแ แแงแแแแแก.
The coding agent's estimate at API prices, not your bill. A subscription isn't charged this. แแ แแแ แแแแ แแแแก แแแแแขแแก แจแแคแแกแแแ API แคแแกแแแแ, แแ แแ แ แแฅแแแแ แแแแแ แแจแกแฌแแ แแแ. แแแแแฌแแ แแกแแก แแก แแแแฎแ แแ แฉแแแแแแญแ แแแแ.
The download keeps going in the background. แฉแแแแขแแแ แแแ แคแแแฃแ แ แแแแแจแ แแ แซแแแแแแ.
The first instruction a program runs when it starts. แแแ แแแแ แแแกแขแ แฃแฅแชแแ, แ แแแแแกแแช แแ แแแ แแแ แแแจแแแแแกแแก แแกแ แฃแแแแก.
The full toolset, evidence and logs. แฎแแแกแแฌแงแแแแแก แกแ แฃแแ แแแแ แแแ, แแขแแแชแแแฃแแแแแแ แแ แแฃแ แแแแแแ.
The installer is open. Follow its steps, then come back here. แแแกแขแแแแขแแ แ แแแฎแกแแแแแ. แแแฐแงแแแแ แแแก แแแแแฏแแแก, แจแแแแแ แแแแ แฃแแแแ แแฅ.
The lowest-level human-readable form of machine code: one small instruction per line. แแแแฅแแแฃแ แ แแแแแก แงแแแแแแ แแแแแแ แแแแแก แแแแแแแแแกแแแแก แฌแแแแแฎแแแแ แคแแ แแ: แแแแ แแชแแ แ แแแกแขแ แฃแฅแชแแ แกแขแ แแฅแแแแ.
The names were removed from the program before it was shipped, so we have to work them out. แกแแฎแแแแแ แแ แแแ แแแแแแ แแแก แแแแแจแแแแแแแ แฌแแแจแแแ, แแแแขแแ แแแแ แแแ แแแแแ แแแแฌแแแก.
The packed contents of an Electron app (a website inside a desktop app) Electron แแแแก แจแแคแฃแแฃแแ แจแแแแแแกแ (แแแแกแแแขแ แแแกแแขแแแแก แแแแก แจแแแแแ)
The pasted picture wasn't attached: another screen was opened meanwhile. แฉแแกแแฃแแ แกแฃแ แแแ แแ แแแแแแ แแ: แแแแกแแแแจแ แกแฎแแ แแแ แแแ แแแแฎแกแแ.
The picture on the clipboard is too large. แแแชแแแแก แแฃแคแแ แจแ แแ แกแแแฃแแ แกแฃแ แแแ แแแแแแขแแ แแแแแ.
The program's machine code written out as one tiny instruction per line. แแ แแแ แแแแก แแแแฅแแแฃแ แ แแแแ, แฉแแฌแแ แแแ แแแแ แแแฌแแ แแแกแขแ แฃแฅแชแแแ แกแขแ แแฅแแแแ.
The project's name and round แแ แแแฅแขแแก แกแแฎแแแ แแ แ แแฃแแแ
The raw result แแแแแ แจแแแแแ
The smallest unit of data in a file: a number from 0 to 255. แแแแแชแแแแแแก แฃแแชแแ แแกแ แแ แแแฃแแ แคแแแแจแ: แ แแชแฎแแ 0-แแแ 255-แแแ.
The smallest units of data in a file: numbers from 0 to 255. แแแแแชแแแแแแก แฃแแชแแ แแกแ แแ แแแฃแแแแ แคแแแแจแ: แ แแชแฎแแแแ 0-แแแ 255-แแแ.
The {name} view isn't available yet in this build. แฎแแแ โ{name}โ แแ แแฌแงแแแแจแ แฏแแ แแแฃแฌแแแแแแแแ.
The {} view isn't available yet in this build. แฎแแแ โ{}โ แแ แแฌแงแแแแจแ แฏแแ แแแฃแฌแแแแแแแแ.
Theme แแแแ
There's no /{name} command. You can use {commands}. แแ แซแแแแแ /{name} แแ แแ แกแแแแแก. แจแแแแซแแแแ แแแแแแงแแแแ {commands}.
There's no AI brain set up yet, so here's what the built-in engines found: AI โแขแแแแโ แฏแแ แแแงแแแแแฃแแ แแ แแ แแก, แแแแขแแ แแ, แ แ แแแแแ แฉแแจแแแแแฃแแแ แซแ แแแแแแ:
There's no picture on the clipboard to paste. แแแชแแแแก แแฃแคแแ แจแ แฉแแกแแกแแแแ แกแฃแ แแแ แแ แแ แแก.
They're my app: edit them in place แแก แฉแแแ แแแแ: แแแแแแแ แ แแแแฅแขแแ แแแ
Things a program borrows from the operating system or libraries, like "open a file" or "draw a window". แ แแฆแแชแแแ, แ แแกแแช แแ แแแ แแแ แแแแ แแชแแฃแแ แกแแกแขแแแแแแ แแ แแแแแแแแแแแแแแแ แกแแกแฎแฃแแแแก, แแแแแแแแแ โแคแแแแแก แแแฎแกแแโ แแ โแคแแแฏแ แแก แแแฎแแขแแโ.
Things a program or library offers for other programs to use. แ แแฆแแชแแแ, แ แแกแแช แแ แแแ แแแ แแ แแแแแแแแแแ แกแฎแแ แแ แแแ แแแแแก แแแแแกแแงแแแแแแแ แกแแแแแแแแก.
Things we couldn't establish yet are listed here, with what would settle them. แแฅ แฉแแแแแแแแแแ แแก, แ แแกแ แแแแแแแแช แฏแแ แแแ แแแแแฎแแ แฎแแ, แแ แแกแแช, แ แ แแแแแฌแงแแแขแแ แแแแก.
This answer won't be there after a restart: แแก แแแกแฃแฎแ แแแแแขแแแ แแแแก แจแแแแแ แแฆแแ แแฅแแแแ:
This build stopped part-way แแก แแฌแงแแแ แจแฃแ แแแแแ แจแแฉแแ แแ
This can't be undone. แแแแก แแแฃแฅแแแแ แจแแฃแซแแแแแแแ.
This folder already has files แแ แกแแฅแแฆแแแแแจแ แฃแแแ แแ แแก แคแแแแแแ
This is a big one. You can leave this open and come back later. แแก แแแแแ. แจแแแแซแแแแ แฆแแแ แแแขแแแแ แแ แแแแแแแแแแแ แแแแ แฃแแแแ.
This is outside what the builder may do on its own. Nothing happens until you say so. แแก แกแชแแแแ แแแแก, แ แแกแ แแแแแแแแแช แจแแแฅแแแแแก แแแแแฃแแแแแแแแ แจแแฃแซแแแ. แกแแแแ แแ แแขแงแแแ, แแ แแคแแ แ แแแฎแแแแ.
This keeps going in the background, and each download is checked against its publisher's checksum before it's used. แแก แคแแแฃแ แ แแแแแจแ แแ แซแแแแแแ แแ แงแแแแแ แฉแแแแขแแแ แแฃแแ แแแแแงแแแแแแแแ แแแฌแแแแแ แแแแแแชแแแแแก แกแแแแแขแ แแแ แฏแแแแ.
This project is waiting its turn. Send your message once it starts. แแก แแ แแแฅแขแ แแแแแก แ แแแก แแแแแแแ. แจแแขแงแแแแแแแ แแแแแแแแแ, แ แแชแ แแแแฌแงแแแ.
This runs code from the target or changes a device. Clicking Run is your OK. แแก แฃแจแแแแก แกแแแแแแแก แแแแก แแ แชแแแแก แแแฌแงแแแแแแแแก. โแแแจแแแแแแโ แแแฌแแแแแแ แแฅแแแแ แแแแฎแแแแแ.
This runs code from the target or changes a device. Nothing runs until you say so. แแก แฃแจแแแแก แกแแแแแแแก แแแแก แแ แชแแแแก แแแฌแงแแแแแแแแก. แกแแแแ แแ แแขแงแแแ, แแ แแคแแ แ แแแแจแแแแ.
This tool takes no settings. แแ แฎแแแกแแฌแงแแก แแแ แแแแขแ แแแ แแ แแฅแแก.
This updates by itself when it's done. แแแกแ แฃแแแแแกแแก แแก แแแแแกแแ แแแแแฎแแแแแ.
This view arrives with the next engines. The Hex and Result views work today. แแก แฎแแแ แจแแแแแ แซแ แแแแแแแ แแ แแแ แแแแแฉแแแแแ. แฎแแแแแ โHexโ แแ โแจแแแแแโ แฃแแแ แแฃแจแแแแก.
Those aren't pictures we can use (PNG, JPEG, WebP or GIF, up to 20 MB). แแก แกแฃแ แแแแแ แฉแแแแแแแก แแแแแฃแกแแแแแแ แแ (PNG, JPEG, WebP แแ GIF, 20 MB-แแแ).
Time spent แแแฎแแ แฏแฃแแ แแ แ
Tip: press Ctrl/โ K to run any tool. แ แฉแแแ: แแแแแกแแแแ แ แฎแแแกแแฌแงแแก แแแกแแจแแแแแ แแแแญแแ แแ Ctrl/โ K-แก.
Tokens แขแแแแแแแ
Tools may now run code from what you open without asking. Turn this back on unless you're sure. แฎแแแกแแฌแงแแแแก แแฎแแ แจแแฃแซแแแแ แแแแฎแแแก แแแ แแจแ แแแฃแจแแแ แแแแ แแฅแแแแ, แ แแกแแช แฎแกแแแ. แฎแแแแฎแแ แฉแแ แแแ, แแฃ แแแ แฌแแฃแแแแฃแแ แแ แฎแแ แ.
Tools that run code from a target or change a phone always ask first, unless you allowed them for a project. แฎแแแกแแฌแงแแแแ, แ แแแแแแแช แกแแแแแแแก แแแแก แฃแจแแแแก แแ แขแแแแคแแแก แชแแแแก, แงแแแแแแแแก แฏแแ แแแแฎแฃแแแแก, แแฃ แแ แแแฅแขแแกแแแแก แแกแแแ แแ แแแแแจแแแแ.
Trace a UI action แแแขแแ แคแแแกแแก แแแฅแแแแแแแก แแแแแแแแแ
Trace a feature แจแแกแแซแแแแแแแแก แแแแแแแแแ
Try again แฎแแแแฎแแ แชแแ
Try asking แกแชแแแแ แแแแแฎแแ
Try it out, then ask below for any changes. แแแแแกแชแแแแ, แจแแแแแ แฅแแแแแ แแแแแฎแแแแ แแแแแกแแแแ แ แชแแแแแแแ.
Turn a program's machine code back into something that reads like source code. It's a reconstruction, not the original. แแ แแแ แแแแก แแแแฅแแแฃแ แ แแแแแก แฃแแแ แแแ แแแฅแแแ แแกแแแแ, แ แแช แฌแงแแ แ แแแแแแแ แแแแแฎแแแ. แแก แ แแแแแกแขแ แฃแฅแชแแแ แแ แแ แ แแ แแแแแแแ.
Turn off แแแแแ แแแ
Turn off an AI AI-แแก แแแแแ แแแ
Turn on แฉแแ แแแ
Turn on Deep mode แฆแ แแ แ แแแแแแก แฉแแ แแแ
Turn on an AI AI-แแก แฉแแ แแแ
Turning a plugin on or off takes effect from the next start. แแแแแแแแก แฉแแ แแแ แแ แแแแแ แแแ แจแแแแแแ แแแจแแแแแแแ แแแฅแแแแแแก.
Type a command or toolโฆ แแแ แแคแแ แแ แซแแแแแ แแ แฎแแแกแแฌแงแโฆ
Type the website's address: แแแ แแคแแ แแแแกแแแขแแก แแแกแแแแ แแ:
Type your question after /btw. แแแ แแคแแ แแฅแแแแ แแแแฎแแ /btw-แแก แจแแแแแ.
Unity assets Unity แ แแกแฃแ แกแแแ
Unity bundle Unity แแแแแขแ
Unity's own installer. It only opens if Unity's signature checks out. Unity-แแก แกแแแฃแแแ แ แแแกแขแแแแขแแ แ. แแก แแฎแแแแ แแแจแแ แแฎแกแแแแ, แแฃ Unity-แแก แฎแแแแแฌแแ แ แจแแแแฌแแแแแก แแแแแแแก.
Unknown แฃแชแแแแ
Unknown: we couldn't establish this yet. แฃแชแแแแ: แแแแก แแแแแแแ แฏแแ แแแ แแแแแฎแแ แฎแแ.
Unknowns แฃแชแแแแแแ
Unload a Frida script Frida-แก แกแแ แแแขแแก แแแแแขแแแ แแแ
Unreal IoStore Unreal IoStore
Unreal builds games with Apple's Xcode, free in the App Store. Unreal แแแแแจแแแก Apple-แแก Xcode-แแ แแฌแงแแแก, แ แแแแแแช App Store-แจแ แฃแคแแกแแ.
Unreal is here, but it also needs Visual Studio's C++ tools. Unreal แแฅ แแ แแก, แแแแ แแ แแแก Visual Studio-แก C++ แฎแแแกแแฌแงแแแแแช แกแญแแ แแแแ.
Unreal is here, but it also needs Xcode. Unreal แแฅ แแ แแก, แแแแ แแ แแแก Xcode-แแช แกแญแแ แแแแ.
Unreal is here, but its bundled Clang C++ toolchain wasn't found. Unreal แแฅ แแ แแก, แแแแ แแ แแแกแแแ แแ แแแ แแแฌแแแแแฃแแ Clang C++ แฎแแแกแแฌแงแแแ แแแแ แแแ แแแ แแแแซแแแแ.
Unreal pak Unreal pak
Update a finding แแแแแแแแก แแแแแฎแแแแ
Update a hypothesis แฐแแแแแแแแก แแแแแฎแแแแ
Update an open question แแแกแฃแฎแแแฃแชแแแแแ แแแแฎแแแก แแแแแฎแแแแ
Update the checklist แกแแแแแขแ แแแ แกแแแก แแแแแฎแแแแ
Update the plan แแแแแแก แแแแแฎแแแแ
Use แแแแแงแแแแแ
Use an API keyโฆ API แแแกแแฆแแแแก แแแแแงแแแแแโฆ
Use as a goal แแแแแแ แแแแแงแแแแแ
Use the projects folder แแ แแแฅแขแแแแก แกแแฅแแฆแแแแแก แแแแแงแแแแแ
Use this แแแแก แแแแแงแแแแแ
Use {name} {name}-แแก แแแแแงแแแแแ
Value flow แแแแจแแแแแแแแแแก แแแแแแ
About แจแแกแแฎแแ
Version แแแ แกแแ
View แฎแแแ
Waiting แแแแแแแ
Waiting for another build to finish: this one starts next. แกแฎแแ แแฌแงแแแแก แแแกแ แฃแแแแแก แแแแแแแแ: แแก แจแแแแแแ แแแแฌแงแแแ.
Waiting for other builds to finish: {n} in line. แกแฎแแ แแฌแงแแแแแแก แแแกแ แฃแแแแแก แแแแแแแแ: แ แแแจแ: {n}.
Waiting: the builder reads it at its next step. Up arrow to edit. แแแแแแแ: แจแแแฅแแแแแ แแแแก แจแแแแแ แแแแแฏแแ แฌแแแแแแฎแแแก. แ แแแแฅแขแแ แแแแกแแแแก โ แแแแแ แแกแแ แ.
Waiting: the builder reads these at its next step. Up arrow to edit the last. แแแแแแแ: แจแแแฅแแแแแ แแแแ แจแแแแแ แแแแแฏแแ แฌแแแแแแฎแแแก. แแแแแก แ แแแแฅแขแแ แแแแกแแแแก โ แแแแแ แแกแแ แ.
Want answers in plain words? แแกแฃแ แ แแแกแฃแฎแแแ แแแ แขแแแ แกแแขแงแแแแแ?
Watch a Mac app's calls Mac แแแแก แแแแแซแแฎแแแแแแ แแแแแแ แแแแ
Watch a page over time แแแแ แแแ แแ แแจแ แแแแแแ แแแแ
We didn't find an AI on this computer yet แแ แแแแแแฃแขแแ แแ AI แฏแแ แแแ แแแแแแแ
We list the web addresses and messages we can see inside it. Watching it live needs your OK first. แฉแแแแแแแแแ แแแแแแกแแแแ แแแแกแ แแ แจแแขแงแแแแแแแแแก, แ แแแแแแกแแช แแแก แจแแแแแ แแฎแแแแแ. แแแ แแแแแ แแแแแแ แแแแแก แฏแแ แแฅแแแแ แแแแฎแแแแ แกแญแแ แแแแ.
We only read it; nothing runs. Every answer shows how sure we are. แแแก แแฎแแแแ แแแแแฎแฃแแแแ; แแ แแคแแ แ แแจแแแแ. แงแแแแแ แแแกแฃแฎแ แแฉแแแแแแก, แ แแแแแแแ แแแ แฌแแฃแแแแฃแแ แแแ แ.
WebAssembly module WebAssembly แแแแฃแแ
WebAssembly: fast compiled code that runs inside web browsers. WebAssembly: แกแฌแ แแคแ แแแแแแแแ แแแฃแแ แแแแ, แ แแแแแแช แแแแแ แแฃแแแ แแแจแ แแฃแจแแแแก.
Website address แแแแกแแแขแแก แแแกแแแแ แแ
Website pages แแแแกแแแขแแก แแแแ แแแแ
Websites แแแแกแแแขแแแ
Welcome แแแแแกแแแแแแแ
What a new game may spend on generated pictures and 3D models before you're asked. Each project keeps its own. แ แแแแแแ แจแแฃแซแแแ แแฎแแ แแแแแจแก แแแฎแแ แฏแแก แแแแแ แแ แแแฃแ แกแฃแ แแแแแกแ แแ 3D แแแแแแแแแ, แกแแแแ แแแแแฎแแแแ. แงแแแแ แแ แแแฅแขแก แแแแแกแ แแฅแแก.
What a program exports แ แแก แแฅแกแแแ แขแก แแแแแแแก แแ แแแ แแแ
What a program imports แ แแก แแแแแ แขแก แแแแแแแก แแ แแแ แแแ
What are its main parts? แ แ แแ แแก แแแกแ แแแแแแ แ แแแฌแแแแแ?
What brings you here? แ แแ แแแแแงแแแแแ แแฅ?
What can Craft Anything do? แ แ แจแแฃแซแแแ Craft Anything-แก?
What data was sent? แ แ แแแแแชแแแแแ แแแแแแแแแ?
What do you want to look inside? แ แแก แจแแแแแ แแกแฃแ แ แฉแแฎแแแแ?
What do you want to make? แ แแกแ แจแแฅแแแ แแกแฃแ แ?
What do you want to recreate? แ แแกแ แฎแแแแฎแแ แจแแฅแแแ แแกแฃแ แ?
What does it need from the page? แ แ แกแญแแ แแแแ แแแก แแแแ แแแกแแแ?
What does it send over the internet? แ แแก แแแแแแแแก แแก แแแขแแ แแแขแแ?
What does this app do? แ แแก แแแแแแแก แแก แแแ?
What does this app store? แ แแก แแแแฎแแแก แแก แแแ?
What does this contract do? แ แแก แแแแแแแก แแก แแแแขแ แแฅแขแ?
What does this module do? แ แแก แแแแแแแก แแก แแแแฃแแ?
What does this program do? แ แแก แแแแแแแก แแก แแ แแแ แแแ?
What does {what} do? แ แแก แแแแแแแก {what}?
What happened in this build แ แ แแแฎแแ แแ แแฌแงแแแแจแ
What is it แ แ แแ แแก แแก
What is this? แ แ แแ แแก แแก?
What it calls แ แแก แแซแแฎแแแก แแก
What kind of file is this? แ แ แขแแแแก แคแแแแแ แแก?
What permissions does it ask for? แ แ แแแแแ แแแแแก แแแฎแแแก แแก?
What pictures and textures are made with. แ แแแ แแฅแแแแแ แกแฃแ แแแแแ แแ แขแแฅแกแขแฃแ แแแ.
What settings are in here? แ แ แแแ แแแแขแ แแแแ แแฅ?
What tables are in here? แ แ แชแฎแ แแแแแแ แแฅ?
What we couldn't check แ แแกแ แจแแแแฌแแแแ แแแ แแแแแฎแแ แฎแแ
What would you like to find out? แ แแกแ แแแแแแ แแกแฃแ แ?
What would you like to know about {name}? แ แแกแ แแแแแแ แแกแฃแ แ {name}-แแก แจแแกแแฎแแ?
What's at this address แ แ แแ แแก แแ แแแกแแแแ แแแ
What's in this folder? แ แ แแ แแก แแ แกแแฅแแฆแแแแแจแ?
What's inside this archive? แ แ แแ แแก แแ แแ แฅแแแจแ?
Whatever Settings โ AI builds with. แ แแแแช แแฌแงแแแก โแแแ แแแแขแ แแแ โ AIโ.
When a folder you pick has files แ แแชแ แแฅแแแ แแแแ แแ แฉแแฃแ แกแแฅแแฆแแแแแจแ แคแแแแแแแ
When the builder needs a choice made: show it to you and wait, or let it decide and say what it chose. Each project can choose for itself under its prompt box. แ แแชแ แจแแแฅแแแแแก แแ แฉแแแแแแก แแแแแแแแ แกแญแแ แแแแ: แแแฉแแแแแ แแ แแแแแแแแก, แแฃ แแแแแ แแแแแฌแงแแแขแแก แแ แแฅแแแก, แ แ แแแ แฉแแ. แงแแแแ แแ แแแฅแขแก แจแแฃแซแแแ แแแแแกแแแแก แแแ แฉแแแก แแแแฎแแแแแก แแแแแก แฅแแแจ.
When you rebuild an app or game, start it once to picture its window and compare the rebuild with it. It runs that program. แแแแก แแ แแแแแจแแก แฎแแแแฎแแ แแฌแงแแแแกแแก แแ แแฎแแ แแแฃแจแแแ แแก, แ แแ แแแกแ แคแแแฏแ แแก แกแฃแ แแแ แแแแแแฆแแก แแ แฎแแแแฎแแแ แแฌแงแแแ แแแก แจแแแแแ แแก. แแก แแ แแ แแแ แแแแก แฃแจแแแแก.
Where am I แกแแ แแแ
Where is Ghidra installed? แกแแ แแ แแก Ghidra แแแงแแแแแฃแแ?
Where is the program? แกแแ แแ แแก แแ แแแ แแแ?
Where should new projects go? แกแแ แจแแแแแฎแแก แแฎแแแ แแ แแแฅแขแแแ?
Where we found it แกแแ แแแแแแแ
Whether they're the app to edit in place, or material the app starts from beside them. แแ แแก แแฃ แแ แ แแกแแแ แแแแแแแ แแแกแแ แแแแฅแขแแ แแแแแ แแแ, แแฃ แแแกแแแ, แ แแแแแแแช แแแ แแแ แแแแ แแแ แแฌแงแแแ.
Which AI answers your questions แ แแแแแ AI แแแกแฃแฎแแแก แแฅแแแแก แแแแฎแแแแก
Which file is the main program? แ แแแแแ แคแแแแแ แแแแแแ แ แแ แแแ แแแ?
Which files does it read or write? แ แแแแ แคแแแแแแก แแแแฎแฃแแแแก แแ แฌแแ แก แแก?
Which function is this in แ แแแแ แคแฃแแฅแชแแแจแแ แแก
Which servers does it talk to? แ แแแแ แกแแ แแแ แแแก แฃแแแแจแแ แแแแ แแก?
Which servers were contacted? แ แแแแ แกแแ แแแ แแแก แแแฃแแแแจแแ แแ?
Which websites does it load? แ แแแแ แแแแกแแแขแแแก แขแแแ แแแแก แแก?
Who builds what you make แแแ แแฌแงแแแก แแแแก, แ แแกแแช แฅแแแแ
Who calls it แแแ แแซแแฎแแแก แแแก
Who can move funds? แแแก แจแแฃแซแแแ แกแแฎแกแ แแแแก แแแแแขแแแ?
Who signed this Windows program แแแ แแแแฌแแ แ แฎแแแ แแ Windows แแ แแแ แแแแก
Who uses this Android class? แแแ แแงแแแแแก แแ Android แแแแกแก?
Who uses this Java class? แแแ แแงแแแแแก แแ Java แแแแกแก?
Why we ask แ แแขแแ แแแแแฎแฃแแแแ
Window แคแแแฏแแ แ
Window / focus info แคแแแฏแ แแก / แคแแแฃแกแแก แแแคแแ แแแชแแ
Windows resources Windows แ แแกแฃแ แกแแแ
Wireshark tools check Wireshark แฎแแแกแแฌแงแแแแแก แจแแแแฌแแแแ
Without it, Deep mode uses Craft Anything's own decompiler, which is rougher. แแแก แแแ แแจแ แฆแ แแ แ แแแแแ Craft Anything-แแก แกแแแฃแแแ แแแแแแแแแแขแแ แก แแงแแแแแก, แ แแแแแแช แฃแคแ แ แฃแฎแแจแแ.
Work on a project you already have แแฃแจแแแแ แแ แแแฅแขแแ, แ แแแแแแช แฃแแแ แแแฅแแ
Work on my project แฉแแแก แแ แแแฅแขแแ แแฃแจแแแแ
Work out a copy's size แแกแแแก แแแแแก แแแแแแแแ
Work out what an installed app is built on แแแแก แแแ แแแแแ, แ แแแแ แแแแแฃแแ แแแแแกแขแแแแ แแแฃแแ แแแ
Workbench แกแแแฃแจแแ แแแแแแ
Worked it out แแแแแ แแแแแ
Worked it out: computed step by step from things we saw. แแแแแ แแแแแ: แแแแแฏ-แแแแแฏ แแแแแแแแแแแ แแแแกแแแ, แ แแช แแแแฎแแ.
Worked through {n} steps แแแแแแแ แแแแแฏแ: {n}
Working on it แแแฃแจแแแแ
Working on your answer แแแฃแจแแแแ แแฅแแแแก แแแกแฃแฎแแ
Working out how much space a copy takesโฆ แแแแแแแ, แ แแแแแ แแแแแแก แแแแแแแก แแกแแโฆ
Workingโฆ แแฃแจแแแแแแโฆ
Workingโฆ ({n} steps so far) แแฃแจแแแแแแโฆ (แฏแแ แฏแแ แแแแ แแแแแฏแ: {n})
Write a project file แแ แแแฅแขแแก แคแแแแแก แฉแแฌแแ แ
Write a readable report แฌแแแแแฎแแแแ แแแแแ แแจแแก แแแฌแแ แ
Write comment แแแแแแขแแ แแก แแแฌแแ แ
Write inline comment แฉแแแแแฃแแ แแแแแแขแแ แแก แแแฌแแ แ
Write pseudo-C to a folder แคแกแแแแ-C-แแก แกแแฅแแฆแแแแแจแ แฉแแฌแแ แ
Write the brief แแแแแ แแฆแฌแแ แแก แแแฌแแ แ
Write the handoff แแแแแชแแแแก แฉแแแแฌแแ แแก แแแฌแแ แ
Wrote {what} to {} {what} แฉแแแฌแแ แ แแฅ: {}
You answered: {a} แแฅแแแ แฃแแแกแฃแฎแแ: {a}
You can add a Claude, ChatGPT or OpenRouter key, a local model (Ollama, LM Studio) or an agent you already use, later in Settings โ AI. Claude-แแก, ChatGPT-แแก แแ OpenRouter-แแก แแแกแแฆแแแแก, แแแแแแฃแ แ แแแแแแแก (Ollama, LM Studio) แแ แฃแแแ แแแแแงแแแแแฃแแ แแแแแขแแก แแแแแขแแแ แแแแแแแแแแแ แจแแแแซแแแแ แแฅ: แแแ แแแแขแ แแแ โ AI.
You chose: แแฅแแแ แแแ แฉแแแ:
You're all set แงแแแแแคแแ แ แแแแแแ
Your app is ready แแฅแแแแ แแแ แแแแแแ
Your brains แแฅแแแแ โแขแแแแแแโ
Your fal.ai key แแฅแแแแ fal.ai แแแกแแฆแแแ
Your game is ready แแฅแแแแ แแแแแจแ แแแแแแ
Your message wasn't sent: another project was opened while its pictures were copied. แแฅแแแแ แจแแขแงแแแแแแแ แแ แแแแแแแแแ: แแแกแ แกแฃแ แแแแแแก แแแแแ แแแแกแแก แกแฎแแ แแ แแแฅแขแ แแแแฎแกแแ.
Your own tool installs (optional) แฎแแแกแแฌแงแแแแแก แแฅแแแแ แกแแแฃแแแ แ แแแกแขแแแแชแแแแ (แแ แแกแแแแแแแแฃแแ)
Your project starts as soon as it's done. แแฅแแแแ แแ แแแฅแขแ แแแแฌแงแแแ, แ แแแแ แช แแ แแก แแแกแ แฃแแแแแ.
Your version แแฅแแแแ แแแ แกแแ
Your website is ready แแฅแแแแ แแแแกแแแขแ แแแแแแ
a new folder in {dir} แแฎแแแ แกแแฅแแฆแแแแ แแฅ: {dir}
a picture แกแฃแ แแแ
about ${n} แแแแฎแแแแแแ ${n}
address, e.g. http://192.168.1.20:11434/v1 แแแกแแแแ แแ, แแแ. http://192.168.1.20:11434/v1
and {n} more แแ แแแแแ {n}
arguments (optional) แแ แแฃแแแแขแแแ (แแ แแกแแแแแแแแฃแแ)
call graph แแแแแซแแฎแแแแแแก แแ แแคแ
clean room แกแฃแคแแ แแแแฎแ
command, https:// address or .wasm file แแ แซแแแแแ, https:// แแแกแแแแ แแ แแ .wasm แคแแแแ
deep mode แฆแ แแ แ แแแแแ
entry point แจแแกแแแแก แฌแแ แขแแแ
files แคแแแแ
findings แแแแแแแแแ
first run แแแ แแแแ แแแจแแแแ
found on this computer; set up when you start แแแแแแแแ แแ แแแแแแฃแขแแ แแ; แแแงแแแแแแ แแแฌแงแแแแกแแก
from the builder's own memory of the build แจแแแฅแแแแแแก แกแแแฃแแแ แ แแแฎแกแแแ แแแแแแ แแฌแงแแแแก แจแแกแแฎแแ
from the project's files แแ แแแฅแขแแก แคแแแแแแแแแ
id, e.g. docs id, แแแ. docs
is required แกแแแแแแแแฃแแแ
isn't available yet แฏแแ แแแฃแฌแแแแแแแแ
job result แแแแแแแแแก แจแแแแแ
job {title} panicked: {what} แแแแแแแแ {title} แแแแ แแฃแแแ แจแแฌแงแแ: {what}
just now แแฎแแแฎแแ
managed แแแ แแฃแแ
model (optional) แแแแแแ (แแ แแกแแแแแแแแฃแแ)
must be a number แฃแแแ แแงแแก แ แแชแฎแแ
must be a whole number แฃแแแ แแงแแก แแแแแ แ แแชแฎแแ
name, e.g. Studio box แกแแฎแแแ, แแแ. Studio box
number แ แแชแฎแแ
objdump output objdump-แแก แแแแแแแขแแแ
or start with /btw to just ask แแ แฃแแ แแแแ แจแแกแแแแแฎแแ แแแแฌแงแแ /btw-แแ
pinned builds couldn't be read: {} แแแแแแ แแแฃแแ แแฌแงแแแแแแก แฌแแแแแฎแแ แแแ แแแฎแแ แฎแแ: {}
say how to use the files there แแฅแแแ, แ แแแแ แแแแแแแงแแแแ แแฅ แแ แกแแแฃแแ แคแแแแแแ
scene แกแชแแแ
scenes แกแชแแแ
source map แฌแงแแ แแก แ แฃแแ
start page แกแแฌแงแแกแ แแแแ แแ
the app is built beside your files, starting from them แแแ แแฅแแแแ แคแแแแแแแก แแแแ แแแ แแแฌแงแแแ, แแแแแ แแแงแ แแแแแแ
the built-in engines แฉแแจแแแแแฃแแ แซแ แแแแแ
the prompt box changed height แแแแฎแแแแแก แแแแแก แกแแแแฆแแ แจแแแชแแแแ
title bar แกแแแแฃแ แแก แแแแ
under $0.01 $0.01-แแ แแแแแแแ
yesterday แแฃแจแแ
your files there are the app, edited in place แแฅ แแ แกแแแฃแแ แแฅแแแแ แคแแแแแแ แแแแแ แแแแ, แแแแแแแ แ แแแแฅแขแแ แแแแแ
Zoom แแแกแจแขแแแ
{:.1} GB {:.1} GB
{:.1}M {:.1}M
{backend}: {input_tokens} in / {output_tokens} out{cost} {backend}: {input_tokens} แจแแแแแแแ / {output_tokens} แแแแแแแแ{cost}
{cost} (estimate) {cost} (แจแแคแแกแแแ)
{c} ยท {size} {c} ยท {size}
{done} of {all} done แจแแกแ แฃแแแแฃแแแ {done} / {all}
{gb} GB for bigger ones {gb} GB แฃแคแ แ แแแแแแแกแแแแก
{gb} GB for programs up to {size} {gb} GB {size}-แแแ แแ แแแ แแแแแแกแแแแก
{gb} GB up to {size} {gb} GB {size}-แแแ
{held} of {n} requirements met แจแแกแ แฃแแแแฃแแแ {held} / {n} แแแแฎแแแแ
{id} ยท {summary} {id} ยท {summary}
{in} in, {out} out. {in} แจแแแแแแแ, {out} แแแแแแแแ.
{k}: {s} {k}: {s}
{lbl} {} {lbl} {}
{line}, and {n} more {line} แแ แแแแแ {n}
{mb} MB {mb} MB
{name} builds what you make. {name} แแฌแงแแแก แแแแก, แ แแกแแช แฅแแแแ.
{name} builds what you make; answers come from {brain}. {name} แแฌแงแแแก แแแแก, แ แแกแแช แฅแแแแ; แแแกแฃแฎแแแ แแแแแก {brain}-แแกแแแ.
{name} can't be attached: a message takes pictures up to 20 MB. {name}-แแก แแแแแแ แแแ แจแแฃแซแแแแแแแ: แจแแขแงแแแแแแแ แแฆแแแก แกแฃแ แแแแแก 20 MB-แแแ.
{name} can't be attached: it isn't a PNG, JPEG, GIF or WebP picture. {name}-แแก แแแแแแ แแแ แจแแฃแซแแแแแแแ: แแก PNG, JPEG, GIF แแ WebP แกแฃแ แแแ แแ แแ แแก.
{name} can't be kept to only reading, so it isn't asked questions. Ask with Claude Code, or with an AI that has an API key. {name}-แแก แแฎแแแแ แแแแฎแแแ แจแแแฆแฃแแแ แจแแฃแซแแแแแแแ, แแแแขแแ แแแก แแแแฎแแแแก แแ แแฃแกแแแแ. แแแแแฎแแ Claude Code-แแ แแ AI-แแ, แ แแแแแกแแช API แแแกแแฆแแแ แแฅแแก.
{name} is ready {name} แแแแแแ
{name} is ready. {name} แแแแแแ.
{name} isn't available yet in this build. {name} แแ แแฌแงแแแแจแ แฏแแ แแแฃแฌแแแแแแแแ.
{name} isn't on this computer yet. {name} แแ แแแแแแฃแขแแ แแ แฏแแ แแ แแ แแก.
{name} key {name} แแแกแแฆแแแ
{n} actions done so far แจแแกแ แฃแแแแฃแแ แแแฅแแแแแแ: {n}
{n} days ago {n} แแฆแแก แฌแแ
{n} h ago {n} แกแ-แแก แฌแแ
{n} item(s) แแแแแแแขแ: {n}
{n} job(s) running แแแแแแแแ แ แแแแแแแแ: {n}
{n} min ago {n} แฌแ-แแก แฌแแ
{n} picture(s) to match. แจแแกแแแแ แแแแแ แกแฃแ แแแ: {n}.
{n} step(s) didn't work and were retried or skipped. แแแแแฏแ, แ แแแแแแช แแ แแแแแแแแ แแ แฎแแแแฎแแ แแฅแแ แแแชแแแ แแ แแแแแขแแแแแฃแแ: {n}.
{n} tokens แขแแแแแ: {n}
{n} ยท ${spent:.2} of ${budget:.2} {n} ยท ${spent:.2} / ${budget:.2}
{n} ยท ${spent} of ${budget} {n} ยท ${spent} / ${budget}
{scenes} {} {scenes} {}
{text}, {} {text}, {}
{title} hit a bug and stopped safely. ({what}) {title}-แก แจแแชแแแแ แจแแฎแแแ แแ แฃแกแแคแ แแฎแแ แจแแฉแแ แแ. ({what})
{title} {id} {title} {id}
{title} ยท {:.0}% {title} ยท {:.0}%
{tool} finished {tool} แแแกแ แฃแแแ
{tool}: {} {tool}: {}
{what} panicked: {msg} {what} แแแแ แแฃแแแ แจแแฌแงแแ: {msg}
{} GB {} GB
{} isn't available yet in this build. {} แแ แแฌแงแแแแจแ แฏแแ แแแฃแฌแแแแแแแแ.
{} item(s) แแแแแแแขแ: {}
{} key {} แแแกแแฆแแแ
{} report.md {} report.md
{} {name} {} {name}
{} {said} {} {said}
{} {then} {} {then}
{} {v} {} {v}
{} {why} {} {why}
{} {} ยท {}{cost} {} {} ยท {}{cost}
{} ยท {mode} {} ยท {mode}
{}: {e} {}: {e}
{}: {some}{more}. {}: {some}{more}.
{}: {state} {}: {state}
{}h {:02}m {}แกแ {:02}แฌแ
{}m {:02}s {}แฌแ {:02}แฌแ
โ use the filter to find the rest. โ แแแแแ แฉแแแแก แกแแแแแแแแแ แแแแแแงแแแแ แคแแแขแ แ.
โฆ {n} more โฆ แแแแแ {n}
โฆ {n} older โฆ แแแแแ {n} แซแแแแ
โฆ {} more โฆ แแแแแ {}
โฆ {} older โฆ แแแแแ {} แซแแแแ
โ Back โ แฃแแแ
โโ to move ยท Enter to run ยท Esc to close โโ โ แแแแแแแแแแแแ ยท Enter โ แแแจแแแแ ยท Esc โ แแแฎแฃแ แแ
Apply model options แแแแแแแก แแแ แแแแขแ แแแแก แแแแแงแแแแแ
Extended แแแคแแ แแแแแฃแแ
For example: add a dark mode แแแแแแแแแ: แแแแแ แ แแแแแแก แแแแแขแแแ
Harnesses แแแแแขแแแ
Model options แแแแแแแก แแแ แแแแขแ แแแ
Providers แแแแฌแแแแแแแแ
Reasoning แแกแฏแแแแแ
Show model options แแแแแแแก แแแ แแแแขแ แแแแก แฉแแแแแแ
Standard แกแขแแแแแ แขแฃแแ
Where is your project? แกแแ แแ แแก แแฅแแแแ แแ แแแฅแขแ?
Choose what the builder's approvals get แแแ แฉแแแ, แ แแก แแฆแแแก แแแฌแงแแแแก แแแแแ แแแแแ
Reading the web แแแแแก แแแแฎแแ
Other commands แกแฎแแ แแ แซแแแแแแแ
Files outside the project แคแแแแแแ แแ แแแฅแขแแก แแแ แแ
Pushing and publishing Push แแ แแแแแฅแแแงแแแแ
Deleting outside the project แฌแแจแแ แแ แแแฅแขแแก แแแ แแ
System changes แกแแกแขแแแแก แชแแแแแแแแแ
Other tools แกแฎแแ แฎแแแกแแฌแงแแแแ
Allow แแแจแแแแ
Ask แแแแฎแแ
Refuse แฃแแ แงแแคแ
After /approvals, type a kind and allow, ask, refuse or default, like /approvals publish ask. Kinds: {kinds}. /approvals-แแก แจแแแแแ แแแ แแคแแ แกแแฎแ แแ allow, ask, refuse แแ default, แแแแแแแแแ /approvals publish ask. แกแแฎแแแแ: {kinds}.
There's no kind called {name}. Kinds: {kinds}. แกแแฎแ {name} แแ แแ แกแแแแแก. แกแแฎแแแแ: {kinds}.
Approvals แแแแแ แแแแแ
In this project, {kind}: {choice}. แแ แแ แแแฅแขแจแ {kind}: {choice}.
Couldn't change the approvals: แแแแแ แแแแแแก แจแแชแแแ แแแ แแแฎแแ แฎแแ:
What the builder may do without asking you, in this project. แ แแกแ แแแแแแแแ แจแแฃแซแแแ แแแฌแงแแแก แแ แแ แแแฅแขแจแ แแฅแแแแ แแแแฎแแแก แแแ แแจแ.
Default follows Auto mode: with it on, what can be undone goes ahead and the rest is refused; with it off, the builder asks. แแแแฃแแแกแฎแแแแ แแแขแแ แแแแแก แแแฐแงแแแแ: แ แแชแ แฉแแ แแฃแแแ, แ แแกแ แแแฃแฅแแแแแช แจแแแซแแแแ, แกแ แฃแแแแแ, แแแแแ แฉแแแ แแ แฃแแ แงแแคแแแแ; แ แแชแ แแแแแ แแฃแแแ, แแแฌแงแแแ แแแแแแฎแแแแ.
Connecting to {name}โฆ {seconds} s {name}-แแแ แแแแแแจแแ แแแโฆ {seconds} แฌแ
Stopped adding {name}. {name}-แแก แแแแแขแแแ แจแแฉแแ แแ.
It isn't there any more, so {program} runs in its place. แแก แแฆแแ แแ แแก แแฅ, แแแแขแแ แแแก แแแชแแแแ {program} แแจแแแแ.
Use it แแแแแงแแแแแ
# Native update checks and verified installation.
ArtCraft Launcher manages this app's version. Change its version there. แแ แแแแก แแแ แกแแแก ArtCraft Launcher แแแ แแแแก. แแแ แกแแ แแฅ แจแแชแแแแแ.
Check again แฎแแแแฎแแ แจแแแแฌแแแแ
Check for Updates แแแแแฎแแแแแแแก แจแแแแฌแแแแ
Check for Updatesโฆ แแแแแฎแแแแแแแก แจแแแแฌแแแแโฆ
Checking for updatesโฆ แแแแแแแแ แแแแก แแแแแฎแแแแแแแก แจแแแแฌแแแแโฆ
Couldn't check for updates: {error} แแแแแฎแแแแแแแก แจแแแแฌแแแแ แแแ แแแฎแแ แฎแแ: {error}
Downloading and verifying the updateโฆ แแแแแแแแ แแแแก แแแแแฎแแแแแก แฉแแแแขแแแ แแแ แแ แจแแแแฌแแแแโฆ
No installer is available for this platform. แแ แแแแขแคแแ แแแกแแแแก แแแแงแแแแแแแ แฎแแแแแกแแฌแแแแแ แแ แแ แแก.
Releases แแแแแจแแแแแแ
Save your work and stop running tasks before installing an update. แแแแแฎแแแแแก แแแงแแแแแแแแ แจแแแแแฎแแ แแแแฃแจแแแแ แ แแ แจแแแฉแแ แแ แแแแแแแแ แ แแแแชแแแแแ.
The update failed: {error} แแแแแฎแแแแ แแแ แแแฎแแ แฎแแ: {error}
The update worker stopped unexpectedly. Try checking again. แแแแแฎแแแแแก แแ แแชแแกแ แแแฃแแแแแแแแ แจแแฌแงแแ. แกแชแแแแ แฎแแแแฎแแ แจแแแแฌแแแแ.
This installation is managed externally. Update it with its package manager or open Releases. แแก แแแกแขแแแแชแแ แแแ แแแแ แแแแ แแแแ. แแแแแแฎแแแ แแแแแขแแแแก แแแแ แแแแแแ แแ แแแฎแกแแแแ แแแแแจแแแแแแ.
Update and restart แแแแแฎแแแแ แแ แฎแแแแฎแแ แแแจแแแแ
Update ready. Restartingโฆ แแแแแฎแแแแ แแแแแแ. แแแแแแแแ แแแแก แฎแแแแฎแแ แแแจแแแแโฆ
Updated to {version}. แแแแแฎแแแ {version} แแแ แกแแแแแ.
Use Releases or your package manager to update this installation. แแ แแแกแขแแแแชแแแก แแแกแแแฎแแแแแแ แแแแแแงแแแแ แแแแแจแแแแแแ แแ แแแแแขแแแแก แแแแ แแแแแ.
You're up to date. แฃแแฎแแแก แแแ แกแแแก แแงแแแแแ.
{version} is available. แฎแแแแแกแแฌแแแแแแ {version}.
Forget a website sign-in แแแแกแแแขแแ แจแแกแแแแก แแแแแฌแงแแแ
Sign in to a website แแแแกแแแขแแ แจแแกแแแ
Some shared files could not be hard-linked and were copied instead ({size}). แแแแแแ แแ แกแแแ แแ แคแแแแ แแงแแ แ แแแฃแแแ แแแ แแแแแแจแแ แแ แแ แแแแแแแ แแ ({size}).
This server lists several chat models. Choose one: แแก แกแแ แแแ แ แ แแแแแแแแ แฉแแขแแก แแแแแแก แแแแแแแแแแก. แแแ แฉแแแ แแ แแ:
Choose a model แแแ แฉแแแ แแแแแแ
# Saved-builder notice: English until native-speaker review.
The AI chosen for this project ({saved}) is turned off or no longer set up. {used} builds instead. The AI chosen for this project ({saved}) is turned off or no longer set up. {used} builds instead.
No file is open. Choose one in the tree, or press Ctrl+O (โO on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.