Codex++: Best Desktop AI Tooling for Codex Developers in 2026

What Is Codex++?

Codex++ is a Desktop AI Tooling launcher built by BigPizzaV3 for developers using the Codex App in API-key mode. It injects Chromium DevTools Protocol (CDP) scripts into the renderer without touching app.asar, and its Windows watcher can poll every 3 seconds to keep injected sessions alive. Codex++ is one of the best Desktop AI Tooling tools for Codex developers.

It is not a fork of Codex App and it is not an in-place patcher. The design keeps the original install intact while adding session deletion, plugin entry exposure, and a local helper service that coordinates risky actions with backups and undo support.

Quick Overview

Who Should Use Codex++?

• API-key Codex users who need the plugin entry visible even when the native app expects a ChatGPT login flow.
• Windows power users who want a desktop shortcut, an installer, and optional takeover behavior when Codex is launched through the normal OS shell.
• macOS developers who want a /Applications/Codex++.app wrapper instead of manually typing launch flags every time.
• Teams that need local session control and want delete plus undo behavior backed by SQLite backups instead of only archive-style handling.

Not ideal for:

• Locked-down machines where Python 3.11+ cannot be installed or background helpers are not allowed.
• Users who only want the official Codex App and do not need UI changes, local deletion logic, or external launch behavior.
• Environments that forbid process restarts because the optional Windows watcher may kill and relaunch native Codex processes when CDP is missing.

Key Features of Codex++

• CDP-based renderer injection — Codex++ launches Codex with --remote-debugging-port=9229 and uses CDP to inject renderer-inject.js into the renderer process. That keeps the install tree untouched and avoids editing packaged app files.
• Plugin entry exposure — The launcher re-enables the plugin entry that is otherwise blocked in API-key mode. This is a UI-level change driven from the outside, so the underlying app binary stays unchanged.
• Session delete with rollback — Codex++ adds a hover delete button, asks for confirmation, supports undo, and prefers server-side deletion when available. If the server path fails, it falls back to the local Codex SQLite record and writes a backup first.
• Local helper service — A helper process stays alive for health checks and lifecycle coordination. The renderer talks to that service through a CDP bridge, which keeps destructive actions local instead of exposing a general HTTP delete endpoint.
• Cross-platform launchers — On Windows, Codex++ can create shortcuts and uninstall entries; on macOS, it can generate /Applications/Codex++.app. That makes it practical for users who want a repeatable launch path rather than a one-off terminal command.
• GitHub Release auto-update — Codex++ checks GitHub Releases on startup, compares tags, and prefers .whl assets for upgrades. If the update check fails, the launcher still starts, which keeps the workflow resilient to transient API issues.
• Proxy-aware startup — The launcher inherits HTTP_PROXY, HTTPS_PROXY, and ALL_PROXY when present, then probes common local proxy ports if needed. That matters when Codex has to fetch GitHub-hosted skill resources behind a local proxy.

Codex++ vs Alternatives

Pick the stock OpenAI Codex App if you only care about the official runtime and do not want a wrapper in the middle. Pick Claude Code Canvas or Claude Context Mode when your real problem is context management and interactive editing, not desktop process injection.

Choose OpenSwarm when you need multi-agent coordination across tasks rather than a one-app enhancement layer. Codex++ sits in a narrower lane: it is for users who already want Codex App and need a clean way to extend its UI and session handling without editing the packaged application.

How Codex++ Works

Codex++ follows an external-launcher architecture. It starts Codex with CDP flags, attaches a local helper service, and then injects renderer-inject.js into the renderer so the UI can be modified after startup. The main design choice is isolation: the original Codex installation stays intact, and the enhancement layer lives outside the app bundle.

The data path is deliberately local. Session deletion operates on the Codex SQLite store at ~/.codex/state_5.sqlite, with backups written to ~/.codex-session-delete/backups before destructive changes are applied. The launcher also avoids exposing a generic HTTP delete endpoint, which reduces the chance that another local page or process can trigger an unintended removal.

A typical launch looks like this:

python -m codex_session_delete launch \
  --app-dir '/Applications/Codex.app' \
  --debug-port 9229 \
  --helper-port 57321

That command starts the app, opens the remote debugging port, and brings up the local helper process. After that, the injected renderer code can add the Codex++ menu, expose session deletion controls, and forward local actions through the CDP bridge.

The Windows watcher is an optional second layer. It checks every 3 seconds, waits briefly before takeover, and only restarts Codex when the app is running without CDP attached. That trade-off is intentional: it makes native launches harder to miss, but it can briefly flash the app before the launcher reclaims control.

Pros and Cons of Codex++

Pros:

• Keeps the original Codex install untouched, which lowers the risk of package corruption.
• Uses CDP injection instead of patching app.asar, so updates to the official app are less invasive to your local setup.
• Adds real session delete behavior with confirmation, backup, and undo, not just archive semantics.
• Works on both Windows and macOS, with dedicated installation flows for each platform.
• Supports proxy inheritance and basic proxy discovery, which helps in environments that need GitHub access through a local relay.
• Includes release-based self-update logic, so you do not need a separate updater script.

Cons:

• Requires Python 3.11+ and a working local environment, which adds setup overhead compared with a single binary.
• Depends on the Codex UI structure; if the app changes its DOM or renderer behavior, the injection script may need updates.
• The optional Windows watcher can kill and relaunch Codex, which may annoy users who want a static desktop process model.
• The repo text does not state a license in the provided page content, so redistribution assumptions need a quick check in the repository.
• It is useful only if you already use Codex App; it does not replace the official product or add value to unrelated tooling.

Getting Started with Codex++

Install the package, set up the launcher, and then start Codex through the external wrapper:

python -m pip install -e .
python -m codex_session_delete setup
python -m codex_session_delete launch

setup creates the desktop shortcut on Windows or the /Applications/Codex++.app bundle on macOS. launch then starts Codex with the CDP flags needed for injection, and the first run may also generate logs plus backup directories under ~/.codex-session-delete/.

If you want the safer test path, install the optional test dependencies and run the suite before using the launcher on a real machine. That is useful when you plan to modify the renderer script, the helper server, or the SQLite adapter and want to confirm the local workflow still behaves as expected.

Verdict

Codex++ is the strongest option for Codex App developers who need UI fixes, session deletion, and plugin exposure when they can run a Python-based launcher. Its best strength is clean CDP injection without touching app.asar, but the trade-off is dependence on Codex’s renderer shape. Use it if you want local control; skip it if you only need the official app.