10 · Cost

What it cost to build

A human team (estimate)
2–8 engineer-years, $0.5M–$2.3M
About 6–23 months with a team of 4 senior engineers. Method and inputs are under "The human estimate" below.
What it took here
$16k–$20k API · ~125–150 h
Claude at published API list prices, plus one person directing, testing on hardware and copying SD cards, over 11 calendar weeks (2026-08-11 → 10-26). The hours are the author's own figure, checked against the transcripts; see "The author's time".

Priced the same way, the human route costs roughly 11–69× more, even after billing the author's hours at a senior engineer's rate ($140/h, which puts this project at $33k–$41k). The token and API figures are counted exactly from the session transcripts; the human figures are estimates and the author's hours come from the transcripts and the author, and the page says how each was made.

Updated 2026-10-26. The first version of this page priced only the first phase (08-11 to 09-03): 3.17 B tokens and $4,974. This version counts every phase through 2026-10-26 (census run 2026-10-26 23:40 UTC; the last day is still open): 22.59 B tokens and $19,559 by the same method, or $15,567 billing each cache write at the duration it actually logged (see "Prices used").
22.59 B
tokens processed, all sessions, subagents and workflow agents, 08-11 to 10-26
$19,559
at API list prices, every cache write at the 1-hour rate (the first-phase page's method)
$15,567
at API list prices, each cache write at the duration it logged (5 minutes for most)
107,419
API calls (assistant turns) after de-duplication
22.0 M
output tokens: the text and code the models actually wrote
777
human prompts typed into the project's sessions
588
background subagents launched with the Agent tool
1,288
short-lived agents inside deep-research workflows

By phase

PhaseDatesAPI callsTokensOutputSubagents / workflow agentsCost, 1 h writesCost, as logged
New 3DS, to v0.9.008-11 → 09-0322,5523.20 B13.3 M147 / 1,103$4,998$4,419
Native fork, to v1.0.009-07 → 10-1962,05115.21 B6.8 M317 / 185$12,427$9,463
v1.1.0 work10-20 → 10-2622,6244.14 B1.7 M124 / 0$2,074$1,625
Between phases09-04 → 09-0619241.7 M170 K0 / 0$60$60
Total08-11 → 10-26107,41922.59 B22.0 M588 / 1,288$19,559$15,567
Opus 5.5Fable 5Opus 5Fable 5.1Sonnet 5Opus 4.8Haiku 4.5
0.03.57.010.413.9New 3DS|to v0.9.0 · Fable 5: 3.6New 3DS|to v0.9.0 · Opus 5: 0.0New 3DS|to v0.9.0 · Fable 5.1: 1.0New 3DS|to v0.9.0 · Opus 4.8: 0.4New 3DS|to v0.9.0 · Haiku 4.5: 0.05.0New 3DSto v0.9.0Native fork|to v1.0.0 · Opus 5.5: 7.2Native fork|to v1.0.0 · Opus 5: 3.2Native fork|to v1.0.0 · Fable 5.1: 1.0Native fork|to v1.0.0 · Sonnet 5: 1.1Native fork|to v1.0.0 · Haiku 4.5: 0.012.4Native forkto v1.0.0v1.1.0 work · Opus 5.5: 2.1v1.1.0 work · Sonnet 5: 0.02.1v1.1.0 workthousands of USD, 1-hour cache writes
The second phase cost about two and a half times the first. It ran 43 calendar days against 24, on more agents in parallel, with larger contexts. Opus 5.5 carried more than half of the second phase's spend and nearly all of the work since v1.0.0; Fable 5 carried most of the first phase.

Prices used

Published Claude API list prices in dollars per million tokens: the same table the first version of this page used, with the two models that arrived since (Opus 5.5 and Sonnet 5) added at their published rates. Cache reads are 0.1× input except where listed.

ModelInputOutputCache write (1 h)Cache write (5 min)Cache read
Claude Fable 5.1$10$50$20$12.50$0.25
Claude Fable 5$10$50$20$12.50$1.00
Claude Opus 5 / Opus 4.8$5$25$10$6.25$0.50
Claude Opus 5.5$4$20$8$5.00$0.20
Claude Sonnet 5$2$10$4$2.50$0.20
Claude Haiku 4.5$1$5$2$1.25$0.10
A correction to the first version. It billed every cache write at the 1-hour rate, on the belief that 1 hour was the TTL these sessions used. The usage records say otherwise: of 1.25 B cache-write tokens that carry a duration, 95% were 5-minute writes. Billed as logged, the first phase comes to $4,419, not $4,998, and the whole project to $15,567. Both figures are shown because the first is the like-for-like update of the number this page used to print and the second is the better estimate. The user's Claude plan is not billed per token; these are what the same usage would have cost on the API. Web searches and context compactions are not in the transcripts and are not counted (in the first phase they came to about $13).

By model

ModelAPI callsOutput tokensCache-read tokensCost, 1 h writesCost, as logged
claude-opus-5-545,6743,257,06510,477,297,093$9,299$6,711
claude-fable-515,1909,293,4002,151,927,954$3,647$3,339
claude-opus-516,9841,996,9613,658,547,740$3,165$2,728
claude-fable-5-14,7153,488,5851,042,680,573$1,989$1,485
claude-sonnet-520,3691,815,6613,583,164,321$1,072$946
claude-opus-4-84,1322,038,747398,856,214$385$356
claude-haiku-4-5-2025100114876,3406,114,482$2$2

Spend by day

$0$615$1,230$1,845$2,4612026-08-11: $9408-112026-08-12: $62026-08-13: $39008-132026-08-14: $1,091first race2026-08-15: $4108-152026-08-16: $02026-08-17: $008-172026-08-18: $02026-08-19: $008-192026-08-20: $2642026-08-21: $98908-212026-08-22: $902026-08-23: $008-232026-08-24: $02026-08-25: $008-252026-08-26: $02026-08-27: $76608-272026-08-28: $3002026-08-29: $008-292026-08-30: $02026-08-31: $008-312026-09-01: $1592026-09-02: $49609-022026-09-03: $3132026-09-04: $4509-042026-09-05: $152026-09-06: $009-062026-09-07: $2012026-09-08: $009-082026-09-09: $02026-09-10: $009-102026-09-11: $02026-09-12: $009-122026-09-13: $7582026-09-14: $009-142026-09-15: $02026-09-16: $009-162026-09-17: $3082026-09-18: $809-182026-09-19: $92026-09-20: $12209-202026-09-21: $02026-09-22: $009-222026-09-23: $1,4232026-09-24: $41809-242026-09-25: $3232026-09-26: $38009-262026-09-27: $1672026-09-28: $009-282026-09-29: $687Old 3DS boots2026-09-30: $1,14309-302026-10-01: $1,3762026-10-02: $84010-022026-10-03: $2962026-10-04: $010-042026-10-05: $02026-10-06: $010-062026-10-07: $6652026-10-08: $2,14010-082026-10-09: $02026-10-10: $010-102026-10-11: $02026-10-12: $010-122026-10-13: $02026-10-14: $010-142026-10-15: $4212026-10-16: $32510-162026-10-17: $882026-10-18: $3610-182026-10-19: $292v1.0.02026-10-20: $1610-202026-10-21: $7582026-10-22: $31210-222026-10-23: $2332026-10-24: $12610-242026-10-25: $3442026-10-26: $28610-26USD per day, 1-hour cache writes
48 days with API calls in 77 calendar days. The first phase spent in a few large bursts between plan-allowance pauses. The second phase's heaviest days were 09-23 (fitting the Old 3DS build into its memory), 09-29 to 10-02 (the first Old 3DS hardware session through the first native-renderer race) and 10-08, the end of the 3D-at-60 push and the most expensive day of the project at $2,140. Hover a bar for its value.

The human estimate

A rough comparison, not a quote. The scope a team would face is what shipped: a citro3d rendering backend, a 32-bit sweep, audio on the DSP, stereo, lifecycle, an owned native renderer sized to the Old 3DS's instruction cache, the 64DD Expansion Kit, a bottom-screen dashboard and menus, and 2–4 player multiplayer over local wireless and the internet, on two consoles.

InputValueBasis
Code written for the port181,208 linesport/3ds at ac33c30, excluding the vendored libultraship subset, third-party libraries, generated asset headers and docs; includes the patch stack and 13,349 lines of tests, probes and harness. Build and dev tools add another 41,324, not counted below
Lines a human team would need84k–168kHalf to all of the production code. The agents wrote heavily instrumented code (receipts, A/B arms, levers); a team would write less of it for the same result
Rate100–200 lines per engineer-dayThe rate the first version of this page used for low-level port work once debugging and hardware loops are counted; 220 working days a year
Effort1.9–7.6 engineer-yearsLines ÷ rate
Cost$0.5M–$2.3M$240k–$300k loaded per senior engineer-year (US; $20–25k a month, as before)
Calendarabout 6–23 monthsA team of 4, ignoring hiring and ramp-up

A check against people who have done comparable work: Ship of Harkinian, the Ocarina of Time PC port, was built by a volunteer team from November 2021, when the decompilation was finished, to its first release in March 2022; 2 Ship 2 Harkinian, the Majora's Mask port on the same libultraship base, shipped in May 2024, six months after its decompilation was finished (Wikipedia). Those are PC ports with no memory or frame budget to speak of. The N64-on-3DS projects listed on Pushing the boundaries are hobby efforts that, by their own READMEs, mostly target the New 3DS at 30 fps or with interpolation. Nothing here contradicts the range above; nothing narrows it much either.

The author's time

The transcripts hold 777 prompts typed into this project's sessions on 49 days between 08-10 and 10-26 (US Eastern time). Grouping prompts less than 20–45 minutes apart into sittings, and adding 15 minutes to each, gives 126–157 hours at the keyboard. The author confirms the total was about 125–150 hours: hardware testing, SD-card copies, photographing screens and reading the docs leave no trace in the transcripts, but they largely overlapped with sittings or were short, so the total is close to the keyboard time. Prompts fall on every day of the week and at every hour from 8 am to 3 am, so this was not only evenings.

No code was written by hand. The author's work was direction (what to build next, what to drop), judgement on evidence (which experiments were real wins), and the hardware loop the agents could not run themselves.

Side by side

This projectHuman team, estimate
Calendar11 weeks (08-11 → 10-26), 48 days with API activity6–23 months with 4 engineers
Money$15,567–$19,559 API-equivalent$0.5M–$2.3M
Peopleone person, ~125–150 hours, no code written by hand2–8 engineer-years
What shippedv0.9.0, v1.0.0 (Old and New 3DS, Expansion Kit) and v1.1.0 (multiplayer); known gaps listed in the release notesthe same scope, plus whatever polish a funded team would add

Cost per outcome

Measure1-hour writesAs logged
Per human prompt$25$20
Per day with API activity (48)$407$324
Per line of port code (181,208)$0.11$0.09

How the census was made

docs/postmortem/gen/pa_census.py re-implements the first version's method and can be re-run. It reads every transcript under the project's two Claude Code directories (~/Code/G-Diffuser through v1.0.0, ~/Code/gdx-3ds since; 1,881 files: orchestrator sessions, Agent-tool subagents and deep-research workflow agents). Each assistant message id is one API call; the 2–5 streamed records of the same message are merged by taking the largest value of each usage field, so nothing is counted twice. Sessions started from the home directory that only mention the project, and every other project on the same account, are excluded.

CheckFinding
The first phase reproduces.Over 08-11 to 09-03 the script finds 3.20 B tokens and $4,998 (1-hour writes), against 3.17 B and $4,974 published. The first census stopped at 19:04 UTC on 09-03; this one counts the whole UTC day.
Claude Code's own stats file counts every streamed record.Its totals are about 1.9× the de-duplicated count (found in the first phase, 5.94 B vs 3.17 B). The API bills per request, so the de-duplicated figure is the one used.
/usage shows plan utilisation, not dollars.Reaching a weekly cap says nothing about the dollar value of the tokens under it, and other projects shared the same allowance.
Not counted.Web searches and fetches billed per use, context compactions and title/summary side calls are not in the transcripts. In the first phase they came to about $13 in total.

The first phase's per-subagent and per-tool tables are in source-census.md. Its clearest cost lesson still stands: two 900-turn agents of 08-14 were left running through a credit pause and each re-read a very large context hundreds of times. An agent that has finished its brief should be stopped.