← PixaAnything

PIXA USER MANUAL

PixaAnything

Product workflows, account access, recovery and updates. Source-backed tool tours are included where a registered tool catalog is connected; this is not a complete reference for every editor command.

Use your browser’s Find command to search this manual. The app includes the same guide in its Manual and Quick tour controls. Download availability is shown on the product page.

Contents
  1. Start a first project
  2. Make a first edit
  3. Keep your work organized
  4. Save and export
  5. Your account
  6. Updates
  7. Find your way around
  8. Undo and safe experiments
  9. Linked files and portability
  10. Working with another application
  11. Recovery and backups
  12. Troubleshooting
  13. Read an app's screen
  14. Drive an app's screen
  15. Watch a Mac app's calls
  16. Inventory an archive or app bundle
  17. Extract an archive
  18. Compare two artifacts
  19. What's at this address
  20. Compare two functions
  21. Compare two evidence bundles
  22. Summarise what changed
  23. Find a call path
  24. Line up code and behaviour
  25. Check a rebuild claim
  26. Ask the person
  27. Investigation so far
  28. Write the brief
  29. Update the plan
  30. Record a hypothesis
  31. Update a hypothesis
  32. Record a finding
  33. Update a finding
  34. Write the handoff
  35. Read the journal
  36. Java archive overview
  37. Find Java classes
  38. Java class
  39. Java method bytecode and pseudo-Java
  40. Who uses this Java class?
  41. Analyse a JavaScript app
  42. Match static code to what ran
  43. Pin a project's build
  44. List pinned builds
  45. Open a pinned build
  46. Stop a pinned build
  47. Rename a pinned build
  48. Remove a pinned build
  49. Run and watch a program
  50. Compare two runs
  51. List projects
  52. Show a project
  53. Answer a project's question
  54. Play a project's result
  55. Preview a project's website
  56. Open a project's folder
  57. Rename a project
  58. Fold a project's plan
  59. Duplicate a project
  60. Delete a project
  61. Choose what the builder's questions get
  62. Choose what the builder's approvals get
  63. Call the build done
  64. Set a project's asset budget
  65. Let a project generate assets
  66. Save a report
  67. Write a readable report
  68. Open
  69. Close
  70. List open targets
  71. Switch target
  72. Where am I
  73. Evidence so far
  74. Export evidence
  75. Import evidence
  76. Open questions
  77. Record an open question
  78. Update an open question
  79. Check an answer
  80. List engines
  81. Install an engine
  82. Show settings
  83. Change a setting
  84. List plugins
  85. Refresh plugins
  86. Add a plugin
  87. Remove a plugin
  88. Open an engine's app
  89. Export captured scripts
  90. Find the original source line
  91. Inspect a network recording
  92. Recover readable sources
  93. Picture a program's window

Start a first project

Choose software or files you own or are authorized to inspect. Begin with a small, clearly defined question.

Make a first edit

Use the application's available exploration tools and read the evidence they return. Distinguish confirmed findings from guesses or missing information.

Keep your work organized

Keep the project focused and review any action that would execute code, change files or affect another device before approving it.

Save and export

Save the project and its findings. Test any new software you build in an isolated environment before using it with important data. If the device access refresh fails, keep the app open and use Save recovery copy to choose a destination. Reconnect before closing if you have unfinished text fields or background operations. Open the recovered native files in the editor after reconnecting; retain the original files. PixaAnything copies drafts and attachments into a session.pixasession file. Use Restore drafts in a fresh idle session after reconnecting. Keep existing project folders; jobs do not resume automatically. Provider settings, keys and account credentials are excluded.

Your account

Use Your account in the Pixa footer to connect this device. Pixa is free early access with no card requirement and no scheduled account expiration. Only approve the code displayed on your own device. Device access refreshes online; a disconnected, revoked or signed-out device must reconnect. Your files remain local.

Updates

Use Updates in the Pixa footer to check the Pixa publisher feed. On Mac, download the candidate, save your work and choose Install and restart. The app checks the installer digest, Apple publisher signature, bundle identity and Gatekeeper before replacement. A canceled editor-close prompt cancels the pending restart. Windows and Linux open the Pixa download page. No update is offered until a matching publisher release exists.

Find your way around

The menu bar and editor panels contain the main controls. Use the existing workspace controls to show a hidden panel. Manual and Quick tour in the Pixa footer reopen this help without changing the project.

Undo and safe experiments

Use Undo to reverse a normal document edit, and Redo to restore it. Keep an original project or duplicate before destructive operations. Undo does not reverse an external file deletion, a published upload or every background operation.

Linked files and portability

An editable project may refer to media, fonts, textures or other external files. Keep those resources alongside your project in a stable folder. Copy the complete folder when moving computers and reopen it before removing the original.

Working with another application

Save a native editable copy before exporting an interchange format. Features such as effects, fonts and linked resources may differ in another application. Reopen exported files in the destination application before relying on them.

Recovery and backups

Save regularly and keep a separate backup of important projects and original media. Recovery copies contain committed project state; unfinished text fields, external files and background tasks may need separate attention. Restore into a new project or folder rather than overwriting the original.

Troubleshooting

For missing content, check the active document, selected object, visible panels, layers and linked-file paths. For account problems, reconnect in Your account. For failed updates, keep the existing application and use the verified Pixa download page; do not disable operating-system security checks.

Read an app's screen

See the buttons, labels and fields of a running app. Read the UI tree of a running app by its pid: every window's controls in order with their depth, role, title, identifier and value (macOS: the accessibility tree, optionally with a screenshot; Windows: UI Automation, also the class, position and size, and whether it's enabled; window_id picks one window by its handle). Password fields' values are never read; long values are cut at 500 characters. Other hosts get a clear wrong_os result.

Drive an app's screen

Click through an app step by step and record what the screen shows. Run a short scripted UI walkthrough against a running app by its pid and record its UI tree before and after the steps. Each step names an action and an element (its exact title or identifier). macOS: any accessibility action (e.g. AXPress). Windows (UI Automation): press (invoke, else toggle, select or expand), expand, collapse, toggle, select or focus; AXPress, AXShowMenu and AXRaise work too. Each step reports dispatched, element_not_found, not_supported, unknown_action or failed. Password fields' titles and values are never read. Other hosts get wrong_os.

Watch a Mac app's calls

Watch which functions a Mac app calls as it runs. Launch a macOS program under lldb, set breakpoints on named functions and ObjC selectors, and record each hit with its argument registers. Bounded by duration and event count. macOS only.

Inventory an archive or app bundle

List everything packed inside an app or archive, with a fingerprint for each file. Content-addressed inventory of a ZIP/APK/IPA/JAR, Electron ASAR, app bundle or folder: every file with size, kind, role and sha256; nested archives opened to a bounded depth; ASAR integrity hashes and ZIP CRCs checked. Paged (offset/limit).

Extract an archive

Unpack an app or archive into a new folder so you can look at the files. Extract every regular file of a ZIP/APK/IPA/JAR or ASAR (plus its .asar.unpacked files) into a fresh private temporary folder chosen by PixaAnything, and return its path. Bounded size and count; entries that would escape the folder are refused.

Compare two artifacts

See which files differ between two versions of an app or archive. Compare two archives, app bundles or folders file by file: added, removed, changed (by sha256) and moved files. Inputs are absolute paths or core_archive_show evidence.

What's at this address

See everything we know about one spot in the program. The name, containing function, comment, inline comment and bookmarks at one address in the active target. Each facet is a value or a clear 'unavailable' with a reason.

Compare two functions

See how one function differs between two versions. Compare two native_function_study evidence records: name, size, blocks, instructions, callee set and pseudo-code. Reports what changed.

Compare two evidence bundles

See what two saved sets of findings have in common and where they differ. Compare two exported evidence bundles (core_evidence_export files) and report which records were added, removed or changed, matched by operation and subject. Every record is checked against its own id, so one edited after export is reported, never counted as unchanged.

Summarise what changed

Pull all your comparisons together into one 'what changed' answer. Combine several comparison evidence records (app_function_versions_compare, core_archives_compare, runtime_captures_compare) into one summary of what changed and what stayed the same.

Find a call path

Find how one function reaches another through the calls between them. Find a path of calls from a start address to a goal address over a call graph assembled from native_function_study evidence records.

Line up code and behaviour

Check whether a change you see in the code matches a change you see when it runs. Correlate static comparisons (app_function_versions_compare/core_archives_compare) with runtime comparisons (runtime_captures_compare) through caller-supplied mappings, and report where they agree or disagree.

Check a rebuild claim

Check that a claim about rebuilding something is actually backed by proof. Check a reconstruction specification: every expectation must cite evidence that exists and is intact. Reports which expectations are satisfied.

Ask the person

Lets the assistant ask you a quick question. Ask the person a question in the app and wait for the answer: a short question, up to six suggested answers shown as buttons, and optionally a typed reply. Use it when a choice changes the result (scope, style, which feature first) and you can't decide from the evidence. Returns the answer text, or a note to continue with your best judgement if nobody answers within 30 minutes.

Investigation so far

See what we're trying to find out, the plan, and what we know so far. The working memory of this investigation: brief, plan with step status, hypotheses, findings (with evidence ids) and the latest handoff. Read it first when starting or resuming.

Write the brief

Write down the question we're answering and what a good answer looks like. Set the investigation brief: the question, purpose, targets, constraints and what 'done' means. Write it before the first analysis call on a new question.

Update the plan

Update the step-by-step plan. Replace the plan with a numbered list of steps, each todo/doing/done/blocked with a short why. Pass based_on_revision to avoid overwriting someone else's update.

Record a hypothesis

Write down a guess we're going to check. Record a claim being tested, ideally with the prediction that would confirm or refute it, plus any supporting/contradicting evidence ids.

Update a hypothesis

Mark a guess as confirmed, wrong, or still being checked. Change a hypothesis's status (testing/supported/refuted/abandoned) and attach supporting or contradicting evidence ids and notes.

Record a finding

Save something we now know for sure, with the proof. Record a settled answer. Requires at least one evidence id; every id is checked against the ledger. Findings are the source for reports.

Update a finding

Correct something we found, keeping its proof and reference. Correct a recorded finding without changing its id. Requires a statement and existing evidence ids; pass based_on_revision to refuse a stale investigation update.

Write the handoff

Leave a note so we can pick up exactly where we left off. Rewrite the handoff note: where we are, what's next, traps to avoid. Write it at the end of every turn so the next turn (or agent) resumes without re-deriving.

Read the journal

See a log of everything that happened in this project. Page through the project's append-only journal (tool calls, model turns, consents, errors), filtered by day, kind or tool. Needs an open project.

Java archive overview

See what's inside a Java program (.jar/.war): its name, its main entry point, its packages and what it bundles. Read a JAR or WAR with the built-in parser: the MANIFEST.MF attributes (main class, class-path, versions), the classes it defines grouped into a package tree, bundled dependencies (nested jars and native libraries), resources, and the class-file (Java) version(s) seen.

Find Java classes

Find the pieces of code inside a Java program by name. Search the classes (and optionally methods) defined in a JAR/WAR or a single .class by name; an empty query lists every class. Paged (offset/limit).

Java class

Look inside one piece of a Java program's code. One class from a JAR/WAR or a bare .class: its Java version, access flags, superclass, interfaces, source file, annotations, inner classes, and its fields and methods with Java-style signatures. With decompile=true, also a pseudo-Java skeleton of the class.

Java method bytecode and pseudo-Java

Read the instructions of one function in a Java program, and a best-guess of its original Java source. A method's JVM bytecode as a disassembly listing with resolved constant-pool references (fields, methods, classes, string/number constants), branch targets, switch tables and the exception table, plus a best-effort structured pseudo-Java reconstruction (confidence Inferred). Paged over instructions.

Who uses this Java class?

Find every place in a Java program that uses a piece of code. Every instruction in every class of a JAR/WAR (or a single .class) that calls, reads, writes, creates or casts to a class (or only calls one of its methods when method_name is given), with the calling method and bytecode offset. Paged.

Analyse a JavaScript app

Look inside a desktop app built with web technology (Electron) or a website's code, and map how its pieces talk to each other. Static analysis of an Electron app (app.asar or unpacked folder), a web bundle folder, a ZIP or a single script into an application graph: package and entry points (main, preload, renderer), BrowserWindow webPreferences, the IPC channel map (ipcMain.handle/on ↔ ipcRenderer.invoke/send, contextBridge members), module imports, bundler and chunk splitting (webpack, esbuild, browserify; Vite/Rollup detected), routes, HTTP endpoints, storage, platform effects, native modules, vendors and source maps. Built-in parser; nothing is executed.

Match static code to what ran

Check which parts of an app's code actually ran in a recording. Match app graph evidence against what was seen running (captured scripts with URLs and sha256): each static module is loaded, resident in a loaded bundle, loaded with different content, not observed, or unknown; runtime-only scripts are listed. Pure computation over evidence.

Pin a project's build

Keeps this version so you can always open it. Keep the project's current build at hand to open later, whatever the builder changes next. `frozen` (the default) copies the app's files and its program into the project's pinned/ folder, without compiler output or dependencies it doesn't start from, so rebuilds can't change or break it. `light` copies the program and the code too but hard-links dependencies and media to the project's, saving their space: replacing or deleting those in the project leaves the pin's as they were, but a file rewritten in place changes in both. With `estimate`, only says what each would take. Websites can't be pinned yet.

List pinned builds

Shows the versions you kept. The pins of one project, or of every project in the project folders from settings: id, name, frozen or light, the round it was pinned at, its size, and whether it's running (started in this session).

Open a pinned build

Opens a version you kept. Start a pinned build in its own window. If it's already running, says so instead of starting a second copy, unless `another` is true (copies of one pin share the files they save beside themselves). A start that quits within two seconds is reported with its exit code and last output. It runs the code the builder wrote, so it needs the person's consent.

Stop a pinned build

Closes a version you opened. Close what a pin started in this session (every copy of it).

Rename a pinned build

Renames a version you kept. Give a pin a new name.

Remove a pinned build

Removes a version you kept. Remove a pin. Its copy goes with it, including anything the program saved beside itself there, so `confirm` must be true; a running pin is refused until it's stopped.

Run and watch a program

Actually run the program in a safe, watched sandbox and see what it does on screen and which files it touches. Run a program under a terminal with a scripted timeline of typed input, resizes and signals, then record the terminal screen, exit, and (opt-in) which files changed. Values that change every run (process ids, loopback ports, 10 ms time buckets; optionally paths and literal patterns) are normalised so two runs compare. Bounded by time, output and files; the whole process group is killed on timeout or cancel. Runs code, so it needs your OK.

Compare two runs

See what differs between two runs of a program. Compare two runtime_walkthrough_record evidence records dimension by dimension (terminal, exit, filesystem, events) and report what changed. Pure; no program is run.

List projects

Shows everything you're making. List the projects in every project folder from settings (where new projects go, then `project_folders`), or in one folder, newest first: name, folder, app folder, request, target, stack, status, the latest check and how many questions are waiting.

Show a project

Shows one project and what happened in it. One project: its request, target, stack, status, checks, questions still waiting for an answer, and its conversation (paged with offset/limit, newest last).

Answer a project's question

Answers a question the builder asked you. Answer a question or approval a project is waiting on (an id from project_show): a choice or text for questions, allow (and always) for approvals. The answer reaches a running build at once and is kept in the project's conversation.

Play a project's result

Opens the game or app that was made. Start the finished game or app a project built (its program, a Unity or Unreal package, or a Godot project in Godot), in its own window. If it's already running, says so instead of starting a second copy, unless `another` is true. A start that quits within two seconds is reported with its exit code and last output. It runs the code the builder wrote, so it needs the person's consent. Websites use project_preview instead. Known limit on Windows: when the caller's output is a pipe, the started program inherits it, so a caller reading that output to its end waits until the program exits (#207).

Preview a project's website

Shows the website that was made. Serve a project's built website on this computer only (loopback) and return its address. It keeps serving for this session; with `wait`, the call itself serves until it's cancelled (Ctrl+C in the CLI).

Open a project's folder

Opens the project's files. Open the project's folder (or its app/ folder) in the file manager, or one of its pinned builds' folders.

Rename a project

Renames something you're making. Give a project a new name (its folder stays where it is).

Fold a project's plan

Hides the builder's checklist until it makes a new one. Fold the builder's plan card away (#504). The steps stay in the project's conversation, and a later run's plan shows again. Call it between builds: a build saves its conversation as it goes, so a fold made during one can be overwritten by that build's next save.

Duplicate a project

Makes a copy to try something different. Copy a project beside it under a new name, to try something else from where it is: what was built, the pictures of the original and the study come along; the conversation, questions and usage don't, and neither do dependencies or compiler output (the next build makes them again). An app edited in place is copied into the copy's app/ folder.

Delete a project

Deletes something you made. Your own files are kept. Delete a project: everything PixaAnything made in its folder (its records, checks, and what was built in app/). The person's own files stay (an app edited in place, the files a project started from). Can't be undone, so `confirm` must be true; stop a build first.

Choose what the builder's questions get

Chooses whether the builder asks you or decides by itself. Choose whether the builder's questions (core_person_ask) in a project are shown to the person to answer (`ask`) or answered with "decide yourself and say what you chose" (`decide`); `default` follows the app's setting (`questions` in settings, which follows Auto mode until set). With no mode, says what applies now. Takes effect from the builder's next question, also mid-build.

Choose what the builder's approvals get

Chooses what the builder may do without asking you. Choose, for one kind of builder action in a project, whether it goes ahead (`allow`), waits for the person's OK on a card (`ask`) or is refused (`refuse`); `default` follows Auto mode. Kinds: `web` (reading websites, searching), `commands` (outside the usual build commands), `outside_files` (changing files outside the project), `publish` (git push, npm publish, gh pr create…), `delete_outside`, `system` (system changes and files, PixaAnything's own records), `other_tools`. With no kind, says what every kind gets now. Takes effect from the builder's next action, also mid-build. Only the person changes these: an agent's call may only make a kind stricter.

Call the build done

Keeps the build as it is and stops offering to carry on. The person is happy with the build as it is (#210): its status becomes Ready and the conversation says they called it done, so a paused, stopped or failed build no longer offers to carry on. Everything so far is kept, and a new message carries on from here. It doesn't stop a build that is still running: pause it first.

Set a project's asset budget

Changes how much a project may spend on generated art. Set what a project may spend on generated pictures and 3D models (US dollars), or read it with no amount. Shows what's been spent so far.

Let a project generate assets

Chooses whether your game may get generated pictures and 3D models. Turn on or off whether the builder may generate pictures and 3D models for a project (paid per asset from its asset budget, and only with an asset provider's key), or read it with no value. Off until the person turns it on.

Save a report

Saves a report to a file you choose. Save a report a client composed (Markdown, HTML or plain text) to an absolute path the person chose. Only .md, .html, .htm or .txt files.

Write a readable report

Make a clear write-up of what we found, with the proof and the open questions. Turn the investigation (brief, plan, findings, hypotheses, handoff) and the evidence ledger into a readable report: what we looked at, what we found (each finding with its plain-English summary, confidence and cited evidence), open questions, and how it was done. format=markdown (default) or html. With an absolute path it writes the file (WRITES_FILESYSTEM); otherwise it returns the text.

Open

Open a program, app or file so we can look inside it. Open a file, app bundle or folder as the active target. Detects what it is from its contents. For raw machine code pass format=raw-binary with architecture and entry_point.

Close

Close what you're looking at. Your findings are kept. Close the active target (or the one named). Evidence stays in the project.

List open targets

See everything you have open. Every open target with its id, kind and sha256.

Switch target

Switch to another thing you have open. Make another open target the active one.

Where am I

Where you are in the program right now. The current cursor address in the active target.

Evidence so far

Everything we've found so far, with the proof. All evidence recorded in this session (detail=summary for a compact list; filter by operation or evidence_id).

Export evidence

Save your findings to a file you can share. Write every evidence record and unknown to a JSON bundle file.

Import evidence

Load findings someone saved. Load a bundle written by core_evidence_export. Tampered records are rejected.

Open questions

Questions we haven't answered yet. Recorded unknowns, filtered by status, severity or domain.

Record an open question

Write down a question we still need to answer. Record something not yet known, with what would settle it.

Update an open question

Mark a question as answered (or still stuck). Change an unknown's status, evidence or resolution. Pass based_on_revision; a stale revision gives stale_revision.

Check an answer

Check that an answered question really has proof. Check that a resolved unknown has a resolution and cites evidence that exists and is intact.

List engines

Shows which helper programs are installed. What's on this computer: each external engine (where it was found, what it's for, whether it can be installed for you), Ghidra for Deep mode, and the game engines that can build games (Unity, Unreal, Godot, Rust) with whether each is ready.

Install an engine

Installs a helper program for you. Download and install an engine into PixaAnything's own folder: `ghidra` (Deep mode, with its Java), `godot`, or any engine with a pinned download (`adb`, `jadx`…). Every download is checked against its published SHA-256. Unity and Unreal need their vendors' installers and accounts: on Windows the installer (Unity Hub, the Epic Games Launcher) is downloaded, its publisher checked, and opened for the person; elsewhere they get the download page.

Show settings

Shows your settings. The current settings as JSON (mode, Auto mode, Deep mode/Ghidra, engine paths, projects folder, asset budget and picture model, AI backends). API keys are never in settings.

Change a setting

Changes one of your settings. Set one setting by its dotted key from settings_show (`auto_mode`, `deep_mode`, `projects_dir`, `assets.budget_usd`…) to a JSON value, then save. Unknown keys and values of the wrong type are refused, and nothing is written.

List plugins

Shows the add-ons you've set up. The external MCP servers configured as plugins ([[plugins.mcp]] in config.toml): id, command, whether it's on and asks before each call, and the tools cached from its last refresh.

Refresh plugins

Reads which tools an add-on offers. Start a plugin's MCP server (or every enabled one), read its tool list and cache it. New or changed tools are offered from the next start of the app or CLI. It runs the plugin's program, so it needs consent.

Add a plugin

Adds an add-on: another program or server whose tools PixaAnything can use. Add an external MCP server as a plugin ([[plugins.mcp]] in config.toml): an id, and either a command (a local server, with args, env and cwd) or a url (a remote https server, with headers). A plugin added here always asks before each call. replace overwrites a plugin with the same id. Run plugins_refresh next to read its tools.

Remove a plugin

Removes an add-on. Remove a plugin from config.toml by its id. Its tools stop being offered from the next start.

Open an engine's app

Opens Unity Hub or the Epic Games Launcher. Open Unity Hub or the Epic Games Launcher (to sign in and install the Unity Editor or Unreal Engine), found on this computer. Only those two; nothing else is started.

Export captured scripts

Save the JavaScript a website loaded into a folder you can analyse. Write the scripts held by a web capture (page inspection or walkthrough evidence, a capture JSON file, or a HAR with saved bodies) into a new folder as files/<host>/<path> plus manifest.json; query variants and collisions get content-hash names with a stated reason. The result names the folder to pass to js_app_map.

Find the original source line

Turn a location in squashed website code back into the original source file and line. Map a position in generated (bundled/minified) JavaScript back to its original file, line, column and name through a source map (a .map file, a script's sourceMappingURL, or an inline data: map). Lines are 1-based, columns 0-based UTF-16. Returns every original position at that point and nearby original source when the map embeds it.

Inspect a network recording

Understand which servers an app talked to and what it asked for, from a saved recording, without exposing passwords or cookies. Read a HAR capture offline: requests, methods, statuses, hosts, timings and an API surface grouped by method + origin + path template, with JSON bodies reduced to outlines (no values). Cookies, credential headers, URL user-info and credential-like query values are never kept; secrets the caller names are redacted in raw, URL-encoded and JSON-escaped forms. Paged (offset/limit) or pick entries with record_numbers.

Recover readable sources

Make squashed JavaScript readable again and split a bundle back into its original pieces. Turn minified bundles back into readable files in a new folder: split webpack/esbuild/browserify module tables into one file per module, pretty-print everything, apply safe unminify rewrites (!0→true, void 0→undefined, statement sequences, webpack module parameter names via scope analysis) and write original files embedded in source maps. manifest.json records every input digest, module byte range and output file.

Picture a program's window

Opens a program for a few seconds and takes a picture of its window. Start a program (an app or a game), wait for its window, take a picture of it and close the program (Windows and macOS). Optionally save the PNG to `output`, and the UI tree of its windows (as runtime_ui_read reads it; Windows and macOS) to `ui_tree` as JSON. It runs the program, so it needs consent.