Doge Code: a Claude Code fork you point at your own endpoint

A source map reconstruction with modules filled in by hand

The base of this project is not a published source tree. It was recovered from the source maps of a built Claude Code bundle, then patched until it ran. The project is explicit that the recovery was incomplete, listing the typical gaps: type specific files missing, build artifacts and intermediate files missing, private package wrapper layers that cannot be recovered, native bindings that cannot be recovered, and dynamic import resources that are not complete. A restored tree also carries shims, fallbacks and compatibility layers that the original never had, which is why the fork warns that behaviour can differ from the upstream implementation even where the code looks similar. The stated goal was never to archive a pristine copy but to reach a tree that runs, then becomes maintainable, and only then gets modified.

Custom endpoints and custom models, not upstream fidelity

The fork states plainly that its target is not 100 percent fidelity to upstream, but a build that suits proxying, self hosting and custom model access. The listed direction includes support for a custom Anthropic compatible endpoint address, support for a custom API key, management of custom models and a model list, and a lower level of coupling to the official login flow, while keeping the main CLI and TUI structure intact. Read that list as the feature set of a self hosted or proxied variant of the tool. There is also a model list management angle, which matters for anyone routing requests to a local model server, and a stated preference for keeping the whole configuration tree in one place.

~/.doge is the whole point of the fork

The configuration directory is where this fork earns its keep. The default user directory has been narrowed to `~/.doge`, with the global configuration file at `~/.doge/.claude.json`, and the documentation states that this fork should not share configuration or cache directories with the original Claude Code. The reason given is contamination: a login session from the original leaking in, or an endpoint, token and model configuration from the original changing how the proxy logic behaves, or both installs sharing `.claude.json` or `.claude/` and producing strange network, authentication, model or interface behaviour. If you used the original before, the documentation says the symptom to expect is reading old settings you never set here. The escape hatch is the `CLAUDE_CONFIG_DIR` environment variable, which points the fork at a directory of your choosing.

The OpenAI bridge rewrites messages and is still experimental

The most interesting piece of engineering in the fork is a middle layer that keeps the internal request format as Anthropic Messages while forwarding to an OpenAI Chat Completions endpoint. When the OpenAI API format is selected, that layer rewrites a Messages request into a Chat Completions request, then converts the returning Chat Completions stream back into the Messages style stream events the internal code consumes. The documentation is careful to say this is not a matter of changing a base URL but a protocol level translation of input and output. The current status is also careful: the format selection interface and configuration persistence have been added, the bridge module is still being iterated on, and incomplete stream events, message mapping errors and partial tool call compatibility are all listed as possible symptoms. The advice given is to stay on the Anthropic compatible mode for stable use and treat the OpenAI format as a test feature.

bun link registers the fork as the doge command

The install path is source based. The environment requirements are Bun 1.3.5 or higher and Node.js 24 or higher, and dependencies install with:

bun install

The recommended route for someone working from a clone is to register the tree as a global command, which registers the package name `@doge-code/cli` and the command `doge`:

bun install
bun link

After that the CLI is available directly:

doge

To depend on the linked package from another project, link it by name:

bun link @doge-code/cli

or reference it from `package.json` with a link dependency:

{
  "dependencies": {
    "@doge-code/cli": "link:@doge-code/cli"
  }
}

The fork favours Git based updates over published package upgrades, so a long lived source checkout is refreshed with:

git pull
bun install
bun link

The package manifest sets the version string to `999.0.0-DOGE`, marks the package private, declares `[email protected]` as the package manager, requires `bun` and `node` engines, and maps the `doge` binary to `./src/bootstrap-entry.ts`.

The Buddy penguin sits next to the prompt box

One of the fork's own additions is a small penguin called Buddy, drawn beside the input box, which comments or cheers after some conversations. It is enabled by default in the current tree, and the command set covers the usual interactions:

/buddy
/buddy pet
/buddy mute
/buddy unmute
/buddy help

The mute command hides the pet and stops the comments without deleting its data, and unmute brings the display back. The documentation also notes that mentioning Buddy in a conversation can make it reply in its own bubble. This is decoration rather than engineering, but it is a fair illustration of how the fork presents itself, and it is a real behavioural difference from the original tool in a way that the endpoint and model work is not.

Provenance and licence are the awkward part

The repository carries a custom licence that GitHub cannot classify, with the manifest field pointing at `SEE LICENSE IN LICENSE.md`, and the project states a disclaimer that the code is for personal study and technical research only, with commercial or illegal use excluded, and that the copyright in the original source remains with Anthropic. The package metadata also lists the upstream Anthropic Claude Code repository under the repository field, which is honest about where the tree came from. The top level layout reinforces the story: `src/` alongside `packages/`, `vendor/` and `shims/`, plus a checked in `image-processor.node` native binary, a `bun.lock`, `tsconfig.json`, `AGENTS.md` and `CLAUDE.md`. There are no GitHub releases for this project, and the last push was on 2026-04-26.

When the original Claude Code remains the better choice

There are clear cases where the fork loses to the tool it came from. If you rely on the official login flow, the fork's own stated direction of loosening that binding is a regression rather than a feature. If you need the OpenAI format path to be dependable, the documentation itself calls it a test feature with known stream and tool call gaps. If you need release notes, changelogs and version pinning from a published package, a Git based fork with a private package and no GitHub releases is a different and rougher workflow. And for commercial work the licence text draws a line the project itself draws. What the fork does offer is a working tree you can point at a custom Anthropic compatible address with a custom key, isolated in `~/.doge`, and updated with three commands.

Editorial conclusion

Doge Code makes sense for a developer who wants the Claude Code CLI surface pointed at a proxy, a gateway or a self-hosted Anthropic compatible service, and who is comfortable working from a Bun source tree rather than a published package. It is the wrong choice for anyone who needs the official login flow, a stable OpenAI format bridge, or a project with a clear upstream release path, since the bridge is still being iterated on, the repository publishes no GitHub releases, and the last push was on 2026-04-26. Before installing it, read the LICENSE file, because the fork restricts use to personal study and non-commercial work while the original source copyright stays with Anthropic, and check that your existing Claude Code login state in ~/.claude is not something you want it to read.

Frequently asked questions

Official sources

1. HELPMEEADICE/doge-code on GitHub
2. Issues
3. README