Skip to content

Commit 6913a6e

Browse files
yanmxaclaude
yanmxa
and
claude
committed
docs: add GenCode vs Claude Code performance benchmark
Compare binary size, startup time, memory usage, and task response time between GenCode (Go) and Claude Code (Node.js). GenCode shows 4-9x faster startup, 5-7x lower memory, and 2-7x faster task completion due to Go's native compilation and leaner architecture. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com> Signed-off-by: Meng Yan <myan@redhat.com>
1 parent 7807687 commit 6913a6e

1 file changed

Lines changed: 133 additions & 0 deletions

File tree

‎docs/benchmark-gencode-vs-claudecode.md‎

Lines changed: 133 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,133 @@
1+
# GenCode vs Claude Code: Performance Benchmark
2+
3+
Comparison between **GenCode v1.12.0** (Go) and **Claude Code v2.1.96** (Node.js/TypeScript).
4+
5+
**Environment**: macOS Darwin 25.4.0, Apple Silicon (arm64)
6+
**Model**: Both use `claude-sonnet-4-20250514` via Anthropic API
7+
**Date**: 2026-04-10
8+
9+
---
10+
11+
## 1. Distribution Size
12+
13+
| Metric | GenCode | Claude Code | Ratio |
14+
|--------|---------|-------------|-------|
15+
| Binary / Package | 38 MB | 62 MB | 0.6x |
16+
| Compressed (.tar.gz) | 12 MB | N/A (npm install) | - |
17+
| Runtime dependency | None (static binary) | Node.js v24 (~112 MB) | - |
18+
| Total install footprint | **38 MB** | **~174 MB** (62 + 112) | **0.22x** |
19+
| File count | 1 | ~30 + node_modules | - |
20+
21+
GenCode ships as a single static binary with zero runtime dependencies. Claude Code requires Node.js and installs ~62 MB of npm packages (16 MB node_modules + 34 MB vendor).
22+
23+
---
24+
25+
## 2. Startup Time (`--version`)
26+
27+
| Run | GenCode | Claude Code |
28+
|-----|---------|-------------|
29+
| 1 | 0.05s | 0.19s |
30+
| 2 | 0.01s | 0.18s |
31+
| 3 | 0.01s | 0.18s |
32+
| 4 | 0.01s | 0.18s |
33+
| 5 | 0.01s | 0.19s |
34+
| **Avg** | **~0.02s** | **~0.18s** |
35+
36+
GenCode starts **~9x faster**. The first run is slightly slower due to OS page cache; subsequent runs complete in ~10ms.
37+
38+
---
39+
40+
## 3. Startup Memory (`--version`)
41+
42+
| Run | GenCode | Claude Code |
43+
|-----|---------|-------------|
44+
| 1 | 32.8 MB | 185.0 MB |
45+
| 2 | 32.8 MB | 185.8 MB |
46+
| 3 | 33.0 MB | 185.1 MB |
47+
| 4 | 32.9 MB | 185.0 MB |
48+
| 5 | 33.1 MB | 185.4 MB |
49+
| **Avg** | **~33 MB** | **~185 MB** |
50+
51+
GenCode uses **~5.6x less memory** at startup. The Node.js runtime alone accounts for a large portion of Claude Code's baseline.
52+
53+
---
54+
55+
## 4. Simple Task: "What is 2+2?"
56+
57+
Non-interactive print mode (`-p`), measuring total wall time and peak RSS.
58+
59+
| Run | GenCode (time / RSS) | Claude Code (time / RSS) |
60+
|-----|----------------------|--------------------------|
61+
| 1 | 4.68s / 38.8 MB | 13.67s / 275.6 MB |
62+
| 2 | 6.90s / 38.5 MB | 11.10s / 275.6 MB |
63+
| 3 | 3.72s / 40.2 MB | 13.34s / 284.1 MB |
64+
| 4 | 3.99s / 39.0 MB | 11.59s / 285.7 MB |
65+
| 5 | 6.83s / 39.6 MB | 9.92s / 287.4 MB |
66+
| **Avg** | **5.22s / 39.2 MB** | **11.92s / 281.7 MB** |
67+
68+
- Response time: GenCode **~2.3x faster**
69+
- Memory: GenCode **~7.2x less**
70+
71+
Note: Both tools use the same Anthropic API and model. The time difference reflects client-side overhead (startup, system prompt construction, session management, hooks, etc.), not LLM inference time.
72+
73+
---
74+
75+
## 5. File Read Task: "Read main.go and count lines"
76+
77+
Requires tool use (Read tool) + LLM response.
78+
79+
| Run | GenCode (time / RSS) | Claude Code (time / RSS) |
80+
|-----|----------------------|--------------------------|
81+
| 1 | 3.19s / 39.0 MB | 32.92s / 284.2 MB |
82+
| 2 | 2.95s / 39.7 MB | 14.18s / 285.4 MB |
83+
| 3 | 2.80s / 38.8 MB | 16.71s / 288.6 MB |
84+
| **Avg** | **2.98s / 39.2 MB** | **21.27s / 286.1 MB** |
85+
86+
- Response time: GenCode **~7.1x faster**
87+
- Memory: GenCode **~7.3x less**
88+
89+
Claude Code's longer times include CLAUDE.md loading, hook processing, LSP initialization, and other features GenCode doesn't implement yet.
90+
91+
---
92+
93+
## 6. Tool-Use Task: "Count .go files in internal/tool"
94+
95+
Requires Glob/Bash tool call + counting + response.
96+
97+
| Run | GenCode (time / RSS) | Claude Code (time / RSS) |
98+
|-----|----------------------|--------------------------|
99+
| 1 | 3.21s / 39.6 MB | 14.46s / 281.4 MB |
100+
| 2 | 2.89s / 39.2 MB | 15.31s / 284.2 MB |
101+
| 3 | 4.60s / 39.7 MB | 13.89s / 277.5 MB |
102+
| **Avg** | **3.57s / 39.5 MB** | **14.55s / 281.0 MB** |
103+
104+
- Response time: GenCode **~4.1x faster**
105+
- Memory: GenCode **~7.1x less**
106+
107+
---
108+
109+
## Summary
110+
111+
| Metric | GenCode | Claude Code | GenCode Advantage |
112+
|--------|---------|-------------|-------------------|
113+
| Install size | 38 MB | 174 MB | **4.6x smaller** |
114+
| Startup time | ~0.02s | ~0.18s | **9x faster** |
115+
| Startup memory | ~33 MB | ~185 MB | **5.6x less** |
116+
| Simple task time | ~5.2s | ~11.9s | **2.3x faster** |
117+
| Simple task memory | ~39 MB | ~282 MB | **7.2x less** |
118+
| Tool-use task time | ~3.6s | ~14.6s | **4.1x faster** |
119+
| Tool-use task memory | ~40 MB | ~281 MB | **7.1x less** |
120+
121+
### Why the difference?
122+
123+
- **Language runtime**: Go compiles to native code with a lightweight runtime (~10 MB baseline). Node.js has a heavier runtime with JIT compilation, garbage collector, and V8 engine overhead (~185 MB baseline).
124+
- **Startup path**: GenCode initializes a Bubble Tea TUI model. Claude Code loads hooks, LSP, plugin sync, CLAUDE.md discovery, OAuth/keychain, memory system, and more.
125+
- **Architecture**: GenCode is a single static binary. Claude Code is a bundled TypeScript application running on Node.js with npm dependencies.
126+
- **Feature scope**: Claude Code has significantly more features (IDE integration, OAuth, Chrome integration, Teams, prompt caching, auto-memory, etc.) which add overhead. GenCode is leaner but covers core CLI agentic coding functionality.
127+
128+
### Caveats
129+
130+
- LLM inference time is identical (same API, same model) — the difference is purely client-side overhead.
131+
- Claude Code's additional startup work (hooks, LSP, etc.) provides features GenCode doesn't have yet.
132+
- Network latency variance affects individual runs; averages across 3-5 runs are more reliable.
133+
- Memory is measured as peak RSS; actual working set may differ.

0 commit comments

Comments
 (0)