> ## Documentation Index
> Fetch the complete documentation index at: https://docs.ticket-rs.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Comparison

> How ticket-rs compares to other issue tracking tools

ticket-rs is built for a specific use case: **AI agents and developers who live in the terminal**. Here's how it compares to alternatives.

***

## Feature Comparison

<table>
  <thead>
    <tr>
      <th>Feature</th>
      <th>ticket-rs</th>
      <th>Beads</th>
      <th>JIRA/Linear</th>
      <th>GitHub Issues</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td>**Git-backed**</td>
      <td>✅ Markdown + YAML</td>
      <td>✅ SQLite + git</td>
      <td>❌ Cloud database</td>
      <td>❌ Cloud database</td>
    </tr>

    <tr>
      <td>**Dependencies**</td>
      <td>✅ Built-in graph</td>
      <td>✅ Built-in</td>
      <td>⚠️ Limited</td>
      <td>❌ None</td>
    </tr>

    <tr>
      <td>**Graph Analytics**</td>
      <td>✅ PageRank, critical path</td>
      <td>⚠️ Basic</td>
      <td>❌ None</td>
      <td>❌ None</td>
    </tr>

    <tr>
      <td>**AI-Native**</td>
      <td>✅ MCP, hooks, triage</td>
      <td>✅ Good CLI</td>
      <td>⚠️ API only</td>
      <td>⚠️ API only</td>
    </tr>

    <tr>
      <td>**Offline Mode**</td>
      <td>✅ Full functionality</td>
      <td>✅ Full functionality</td>
      <td>❌ Requires network</td>
      <td>❌ Requires network</td>
    </tr>

    <tr>
      <td>**Background Process**</td>
      <td>✅ None (stateless)</td>
      <td>❌ SQLite daemon</td>
      <td>❌ Browser required</td>
      <td>❌ Browser required</td>
    </tr>

    <tr>
      <td>**Installation**</td>
      <td>✅ Single binary</td>
      <td>⚠️ Go + SQLite</td>
      <td>❌ Browser only</td>
      <td>❌ Browser only</td>
    </tr>

    <tr>
      <td>**External Sync**</td>
      <td>✅ GitHub, Linear</td>
      <td>❌ None</td>
      <td>N/A (is the system)</td>
      <td>N/A (is the system)</td>
    </tr>

    <tr>
      <td>**Sandboxed Env**</td>
      <td>✅ Works everywhere</td>
      <td>⚠️ Needs SQLite</td>
      <td>❌ API tokens</td>
      <td>❌ API tokens</td>
    </tr>

    <tr>
      <td>**Merge Conflicts**</td>
      <td>✅ Rare (text files)</td>
      <td>❌ SQLite conflicts</td>
      <td>N/A</td>
      <td>N/A</td>
    </tr>

    <tr>
      <td>**Team UI**</td>
      <td>⚠️ CLI + sync</td>
      <td>❌ CLI only</td>
      <td>✅ Rich web UI</td>
      <td>✅ GitHub UI</td>
    </tr>

    <tr>
      <td>**Speed**</td>
      <td>✅ Rust performance</td>
      <td>✅ Go performance</td>
      <td>⚠️ Network latency</td>
      <td>⚠️ Network latency</td>
    </tr>
  </tbody>
</table>

***

## Performance Benchmarks

We maintain a comprehensive benchmark suite comparing ticket-rs against alternative implementations including bash scripts and Go-based tools (beads). All benchmarks are automated and run with Monte Carlo analysis across multiple dataset sizes.

### Benchmark Results

**Overall Performance** (median across all commands, 500 tickets, 30 iterations). This is the same canonical dataset that powers the chart on the [about page](https://ticket-rs.io/about) and is regenerated from the benchmark suite:

| Implementation                           | Median Time | Speedup     |
| ---------------------------------------- | ----------- | ----------- |
| **ticket-rs** (Rust CLI (tk))            | **9.0ms**   | 6.2x faster |
| kardianos/ticket (Go trie YAML)          | 9.7ms       | 5.8x faster |
| nwiizo/vibe-ticket (Rust (archived))     | 16.2ms      | 3.5x faster |
| **ticket-py** (Python bindings via PyO3) | **24.3ms**  | 2.3x faster |
| wedow/ticket (Bash)                      | 35.1ms      | 1.6x faster |
| steveyegge/beads (Go daemon)             | 55.9ms      | 1.0x faster |
| steveyegge/beads (Go direct)             | 58.8ms      | 1.1x slower |

<Info>
  Benchmarks run with 500 tickets, 30 iterations.
  Data source: [benchmark-data.json](https://github.com/ticket-rs/ticket/blob/main/web/src/data/benchmark-data.json)
</Info>

**Key Findings:**

<CardGroup cols={3}>
  <Card title="Rust CLI Speed" icon="gauge-high">
    Fastest overall — **\~4× faster than bash** and **6.2× faster than the Go daemon**, with no dependencies and instant startup.
  </Card>

  <Card title="PyO3 Bindings" icon="rocket">
    **Zero subprocess overhead** for Python-first workflows: in-process Rust via PyO3, no per-call process spawn.
  </Card>

  <Card title="Linear Scaling" icon="chart-line">
    **O(n) complexity** with excellent constants. Handles 1,000+ issues efficiently.
  </Card>
</CardGroup>

### Detailed Command Performance

Operations tested: `ready`, `list`, `show`, `stats`, `create`, `update`

**Highlights** (Rust CLI, 500-ticket dataset):

* **Ready command**: Finds unblocked issues in \~4.5ms (vs \~35ms in bash)
* **List command**: Full issue list in \~14ms (vs \~35ms in bash)
* **Show command**: Single issue lookup in \~4ms (vs \~39ms in bash)
* **Stats command**: Repository stats in \~14ms

<Note>
  Per-command latency scales with dataset size — the numbers above are at 500 tickets. On smaller repositories (and for the CLI's own regression suite) these commands run in the low single-digit milliseconds.
</Note>

### Scaling Analysis

Tested with 10, 50, 100, 500, and 1,000 ticket datasets:

* **ticket-rs/ticket-py**: O(n) scaling with minimal overhead
* **bash**: O(n²) for operations requiring full repository scans
* **beads daemon**: Constant daemon overhead + O(n) parsing

<Info>
  View full benchmark methodology, charts, and raw data in `pypi/benchmarks/BENCHMARK_REPORT.md`
</Info>

***

## When to Use ticket-rs

ticket-rs is ideal when you:

<Check>Work primarily in the **terminal and IDE**</Check>
<Check>Use **AI coding assistants** (Claude, Cursor, Windsurf)</Check>
<Check>Want **git-backed** issue tracking that versions with code</Check>
<Check>Need **dependency graphs** and smart prioritization</Check>
<Check>Value **offline capability** and zero external dependencies</Check>
<Check>Work in **sandboxed environments** (CI/CD, containers)</Check>
<Check>Want **blazing fast** commands (milliseconds, not seconds)</Check>

***

## When NOT to Use ticket-rs

Consider alternatives when you:

<Warning>
  **Need rich web UI** — JIRA/Linear have comprehensive dashboards, Gantt charts, reporting
</Warning>

<Warning>
  **Non-technical team** — PMs and designers may prefer visual interfaces (though you can sync externally)
</Warning>

<Warning>
  **Massive scale** — Optimized for \<10k issues per repo; use dedicated systems for millions of issues
</Warning>

<Warning>
  **Real-time collaboration** — No live updates; use git push/pull for sync
</Warning>

***

## Detailed Comparisons

### vs. Beads

**Beads pioneered AI-native issue tracking.** ticket-rs builds on those ideas:

<Tabs>
  <Tab title="Similarities">
    * ✅ Git-backed storage
    * ✅ Dependency tracking
    * ✅ AI-native CLI
    * ✅ Terminal-first workflow
  </Tab>

  <Tab title="Differences">
    * **No SQLite daemon** — ticket-rs uses plain files, no background process
    * **Graph analytics** — ticket-rs adds PageRank, critical path, centrality
    * **External sync** — ticket-rs syncs with GitHub, Linear, JIRA
    * **Rust performance** — Faster execution, smaller binary
    * **Sandboxed support** — Works in Claude Code web, restricted environments
  </Tab>

  <Tab title="Migration">
    ```bash theme={null}
    tk migrate-beads
    ```

    Converts `.beads/` SQLite to `.tickets/` markdown
  </Tab>
</Tabs>

***

### vs. JIRA / Linear

**JIRA and Linear are full-featured project management systems.** ticket-rs is **developer-focused**.

<Tabs>
  <Tab title="When to Use JIRA/Linear">
    * Team needs rich web UI
    * Non-technical stakeholders
    * Complex workflows (sprints, epics, boards)
    * Advanced reporting and dashboards
    * Real-time collaboration
  </Tab>

  <Tab title="When to Use ticket-rs">
    * Developers/AI agents as primary users
    * Terminal-first workflow
    * Git-backed versioning
    * Offline capability
    * Zero setup (no cloud account, no config)
    * Blazing fast local operations
  </Tab>

  <Tab title="Best of Both">
    ```bash theme={null}
    tk create "Add auth" -t feature
    tk linear sync
    ```

    PMs use Linear UI, devs use tk CLI
  </Tab>
</Tabs>

**You can have both:** Use ticket-rs for your workflow, sync to JIRA/Linear for team visibility.

***

## vs. GitHub Issues

**GitHub Issues is tightly integrated with GitHub.** ticket-rs is **git-native**.

<Tabs>
  <Tab title="GitHub Issues Pros">
    * Built into GitHub (no separate tool)
    * Rich web UI
    * Integrations with Actions, Projects
    * Team-friendly interface
  </Tab>

  <Tab title="ticket-rs Advantages">
    * **Git-backed** — Issues in your repo, not external API
    * **Offline** — Full functionality without network
    * **Dependencies** — Built-in graph, PageRank
    * **AI-native** — MCP server, hooks, optimized output
    * **Fast** — Millisecond local operations vs. API calls
  </Tab>

  <Tab title="Sync Both">
    ```bash theme={null}
    tk create "Fix bug" -t bug -p 0
    tk github sync
    ```

    Issues appear in both places
  </Tab>
</Tabs>

***

### vs. Plain Text / Markdown Files

**Some teams just use TODO.md or NOTES.md.** ticket-rs adds structure:

| Aspect             | Plain Files     | ticket-rs                  | Notes                                                                                                                                                            |
| ------------------ | --------------- | -------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Structure**      | Freeform        | YAML frontmatter           | [YAML frontmatter](https://docs.github.com/en/contributing/writing-for-github-docs/using-yaml-frontmatter) is a simple way to add structured data to your issues |
| **Dependencies**   | Manual tracking | Automatic graph            | Help your agents traverse a rich context graph                                                                                                                   |
| **Search**         | grep            | `tk grep`, `tk search`     | Fast term-based and BM25-based search                                                                                                                            |
| **Similarity**     | None            | `tk similar`               | `tk similar` finds issues similar to a given issue                                                                                                               |
| **Deduplication**  | None            | `tk duplicates`            | `tk duplicates` finds and manages duplicate issues                                                                                                               |
| **Status**         | Comments        | Structured status field    | Structured status field is a way to track the status of your issues                                                                                              |
| **Analytics**      | None            | PageRank, critical path    | PageRank and critical path are ways to analyze your issues                                                                                                       |
| **AI Integration** | Generic         | Purpose-built (MCP, hooks) | `tk prime` outputs AI-optimized workflow context                                                                                                                 |

***

## Migration Guides

Switching to ticket-rs is straightforward:

<CardGroup rows={3}>
  <Card title="From Beads" icon="database">
    ```bash theme={null}
    tk migrate-beads
    ```

    Auto-converts SQLite to markdown
  </Card>

  <Card title="From GitHub" icon="github">
    ```bash theme={null}
    tk github sync
    ```

    Imports existing issues
  </Card>

  <Card title="From Linear" icon="square-kanban">
    ```bash theme={null}
    tk linear sync
    ```

    Bidirectional sync
  </Card>
</CardGroup>

***

## Next Steps

<CardGroup cols={2}>
  <Card title="Quickstart" icon="rocket" href="/quickstart">
    Install ticket-rs and try it out
  </Card>

  <Card title="Philosophy" icon="lightbulb" href="/about/philosophy">
    Understand our design principles
  </Card>

  <Card title="Graph Analytics" icon="chart-network" href="/concepts/graph-analytics">
    Learn about tk's killer feature
  </Card>

  <Card title="GitHub" icon="github" href="https://github.com/ticket-rs/ticket">
    Star the repo and contribute
  </Card>
</CardGroup>