DeepTide: three front ends, one npm redirect, and a native binary fetched by postinstall

The repository is three products and the docs for all three

A comparison table at the top of the README sets out three front ends that share a team and little else. DeepTide for macOS is a Swift 6 native binary of roughly 15 MB idle, requiring macOS 15 or later, installed from a script and described as 100 percent authored by DeepSeek V4. DeepTide CLI, the `deeptide` npm package, is a cross-platform terminal agent that runs on Bun with about 50 MB resident, and it is described as powered by an open-source project called Zero CLI. DeepTide CLI Rust, published as `deeptide-rs`, is a native Rust binary of roughly 10 MB on disk with no runtime, authored under `crates/` in this repository. So this tree holds the Swift app, four Rust crates, a Bun package, a hard fork of an inference engine and a gateway, and the repository states plainly that it is the community front door for all three rather than the home of all three. Only the Rust variant also carries a desktop GUI, and that one is described as a single Rust binary using egui with no Electron or webview, a thin window over the same engine the CLI uses, sharing its configuration, its session history and its entire tool set with no separate config to maintain.

The npm package calls itself a thin redirect in its own manifest

The manifest for the package the repository is named after describes itself differently from the README. Its `description` field reads that it is a thin redirect to `@paean-ai/zero-cli` which installs the `deeptide` and `tide` commands, and its entire `dependencies` list is that single package at `^0.11.6`. What it actually ships is two files, `bin.js` and `scripts/tide-local.mjs`, plus the README, the licence, a NOTICE and a logo. The README's own table assigns this package the richest plugin surface of the three, which is a claim about the upstream project it forwards to rather than about code in this repository. Version numbers run in parallel without meeting: this package is at 0.11.8 while its one dependency is at `^0.11.6`, and the repository publishes no releases at all. The two command names are declared as separate `bin` entries pointing at the same `bin.js` file, the manifest is an ES module, and the Rust package lives in its own `npm/deeptide-rs` directory rather than in this manifest.

The recommended macOS install is a signed download, not a build

The macOS section recommends a single command, and it fetches a binary rather than compiling anything:

curl -fsSL https://deeptide.sh/install.sh | sh

The prose says this downloads the signed build for the Mac architecture and installs both `deeptide` and the shorter `tide` command. A separate section does exist for building from source, and it points at this same repository as the open source Swift tree, describing it as the route for people who need to modify the native runtime or the local inference components. But the scripts in the manifest show what a source build actually involves: `build:ds4` runs make inside `native/ds4` and `build:dsgo` runs a Swift package build against `native/dsgo`, so the two native pieces are built by two different toolchains. The consequence is that the recommended path for most users is a signed artefact fetched over the network, while the reproducible path is the one the README tells you not to bother with. The same asymmetry shows up in the GUI, which is launched by asking the CLI to exec a desktop binary while sharing the same configuration and working directory, so on macOS the signed download is also what gets you a desktop app.

The Rust package pulls its binary from a release stream this repo does not publish

The two npm packages are described as not conflicting, because they expose different binary names, `deeptide` and `tide` against `deeptide-rs`, so both can be installed and switched between freely while the Rust port matures. The Rust port is intended to become the canonical cross-platform CLI over time, and the older package is to remain available as long as users find value in it, with no forced migration. That plan has one dependency worth naming. The Rust package is said to ship a native binary via a GitHub Releases postinstall, and the repository itself has no GitHub releases. So the postinstall step for the front end the README recommends for headless CI and single-binary deploys resolves its artefact from a release stream that this tree neither populates nor records the provenance of. The upside of that front end is real, though, and worth stating: because the GUI and the CLI read the identical `~/.config/tide/settings.json` and the project `.deeptide/settings.json`, and save conversations to the same on-disk store, a chat started in one is resumable from the other with a single click or a resume flag.

The manifest declares Node 18 while the runtime requires Bun

The install section for Linux and Windows opens with a prerequisite: Bun must be installed and on the path, because the CLI runtime requires it, matching the underlying project. It adds that Bun does not replace your Node install but sits alongside it. Then it offers three package managers, with bun recommended as fastest, npm noted as working too, and pnpm listed. The parenthetical on the npm line is the interesting part, because it says bun is still required at runtime. Meanwhile the manifest declares `engines` as Node 18 or newer. So a package whose runtime is Bun publishes a Node engine floor, and the engine field will not warn the person it needs to warn. Two command names are installed rather than one, the short `tide` and the full `deeptide`, plus a one-shot mode through `-p` and a `--help`. You can also skip this package entirely and install the upstream one it forwards to, with `bun add -g @paean-ai/zero-cli`, which is the same trade in the other direction.

Nine configuration areas are documented in another project's README

The quick start is short. The default path talks to the DeepSeek API by matching the native app, using `DEEPSEEK_API_KEY` in the environment, and any Anthropic-protocol-compatible endpoint can be driven instead with a `--base-url` and an `--api-key` pair, with Zhipu GLM, Volcengine, Paean, Qwen, Moonshot and self-hosted gateways named as candidates. Authentication has two commands rather than one: `tide auth login` for Paean OAuth, described as multimodal-aware, and `tide login` to save a DeepSeek API key directly. Local diagnosis is offered through `tide doctor`. Everything past that is handed elsewhere. The README states that for the full configuration surface, meaning the settings.json schema, hooks, permissions, MCP servers, sub-agents and model aliases, the upstream README is the authoritative reference. Nine areas of behaviour, none of them documented in the repository that ships the binaries.

The workspace denies three lints and justifies every version pin

The Rust workspace has four members, `deeptide-cli`, `deeptide-core`, `deeptide-gui` and `deeptide-host`, on edition 2024, and its dependency block reads more like a set of engineering notes than a version list. `libc` is at the workspace level because only the stdin polling path consumes it, for the mid-turn type-ahead feature on Unix, so other crates can opt in without duplicating the pin. `unicode-width` is held at 0.2, with the comment calling it the de facto Rust crate for East Asian width and noting it is the latest as of 2026-05, which fixes the wide classification of recent CJK extensions and adds variation selector awareness so that the project's own prompt editor, line wrapping and status bar agree with what the terminal renders. Against that attention to detail, the lint table denies exactly three things: `dbg_macro`, `todo` and `unwrap_used`. Two more choices in the same block are worth reading. The HTTP client is configured with default features off and only blocking, json, multipart and rustls-tls enabled, so TLS comes from a Rust implementation rather than from the platform's own stack, and no async runtime appears among the workspace dependencies at all.

A samples directory full of game templates sits beside the agent

The root holds the four crates, `native/`, `npm/`, `docs/`, `scripts/`, `skills/`, `benchmarks/`, `assets/` and a `samples/` directory, and the samples are the surprise. Among the listed entries are agent brief and workbench templates, a deck template, three canvas projects built on a brick breaker, a match-3 puzzle and a tower defence, and then a long run of directories named `pixel-` followed by a game: 2048, aegis, angler, aquarium, arcade, archery, armada, auto arena, backpack roguelite, barkeep, bastion, battle royale, beat runner, binairo, blackbox, block drop, bloxorz, boulder siege and bowl, with the list cut off there. Nothing in the README connects a coding agent to a shelf of arcade game templates, so the relationship between the two is undocumented, and the volume of it is large enough that a reader looking for agent examples has to filter past two naming families. The rest of the root is conventional, with a LICENSE and a NOTICE side by side, a SECURITY policy, and the recorded primary language given as Rust even though the package this repository is named after is JavaScript.

Editorial conclusion

Pick the front end that matches what you are actually building on. On macOS the signed native app is the tuned path and its cost is that you are running a binary from a website rather than something you compiled. On Linux, Windows or CI, the Rust CLI is the one to take: a single native binary with no runtime, its own GUI, and shared configuration and session history with the terminal build, which removes the usual reason to maintain two tools. The npm `deeptide` package is the weakest of the three despite being the one the repository is named after, since it forwards to another project, declares a Node engine while requiring Bun at runtime, and ships a two-file shim. Before you commit, check three things. Find out where the Rust binary comes from, because the postinstall path reads a release stream and this repository publishes no releases, so you are trusting an artefact whose provenance this tree does not record. Read the configuration schema, which lives in the upstream project's README rather than here, along with hooks, permissions, MCP servers, sub-agents and model aliases. And note the two separate login commands, since OAuth and a pasted API key are different trust decisions. If you need to modify terminal rendering or the inference engine itself, the source is here, with a deny list on `unwrap` and a dated pin on character width.

Frequently asked questions

Official sources

1. Issues
2. License: MIT
3. paean-ai/deeptide on GitHub
4. Project website
5. README