**** STAR TRADERS 64 ****
8 PLANET SYSTEM 38911 CREDIT BYTES FREE
READY.
LOAD "STARTRADERS64",8,1
SEARCHING FOR STARTRADERS64
LOADING
READY.
RUN
STAR TRADERS 64
** turn-based space trading — for humans and bots **
A turn-based space trading game: 8 planets, 3 goods, one fleet — first to reach 1000 credits or 10 ships wins. Play by hand in your browser or terminal, or write a bot or strategy that plays for you — the real game is the algorithm.
10 Levels 1–99
Star Traders 64 is not a single game but a 99-level ladder. You're standing at the very bottom — as it should be.
- LEVEL 1 — economic race LIVE NOW: the map above, 3 goods, ship building, price dynamics. Running in production.
- Unlocking LEVEL 2 COMING SOON: you advance once you've won at least one LEVEL 1 game. Levels get progressively harder all the way to 99.
- 3 modes on every level COMING SOON:
10s— 10 seconds per turn to submit your moves (effectively bot mode)1min— 1 minute per turn, playable pace for humansauto— the turn advances once everyone has submitted (the current game already works this way)
- Universes COMING SOON: one universe = one running game, up to 12 players — 2 of them built-in seed AI strategy bots, so you're never bored. When a universe fills up, a new one opens automatically.
- Leaderboard COMING SOON: wins, rankings, level unlocks.
Honestly, here's what's live today: LEVEL 1 runs as a single shared game
on the api.startraders64.com server. Universes, timed
modes and the leaderboard are still in the works — but your registration and
token are already permanent, so it's worth claiming your spot now.
20 Quick start — terminal
The client is a single Python file using only the stdlib (Python 3.10+ required, nothing else):
# 1. download the client curl -O https://www.startraders64.com/startraders.py chmod +x startraders.py # 2. register — one-time, prints your permanent token ./startraders.py --server https://api.startraders64.com --register YOURNAME # 3. play (the token is saved on your machine) ./startraders.py --server https://api.startraders64.com --join YOURNAME
~/.startraders64_sessions.json); from another machine, log in
with the --passwd <token> flag.30 COMMAND> reference
Once you're in, these commands work at the COMMAND> prompt:
| Command | What it does |
|---|---|
buy <good> <n> | buy on the local market, e.g. buy food 5 |
sell <good> <n> | sell on the local market, e.g. sell ore 3 |
travel <planet> | travel — full name, map code or unambiguous prefix: travel beta / travel BET / travel eps |
build | build a ship — only on shipyard planets, 100 credits + 10 ore from your cargo |
refuel <n> | buy n units of fuel on the current planet |
end | end your turn |
auto <file.json> | upload a strategy — the server replays it every turn until someone wins |
stop | disable your running strategy |
watch | live view (very handy while your strategy is doing the work) |
map / market | redraw the screen: map + local market |
reset | start a new game (re-joins you automatically) |
help / quit | help / exit |
Spectator mode for a running game, no login required:
./startraders.py --server https://api.startraders64.com --watch
40 API for bot writers
Everything the client does is a plain REST call — any language works.
Base URL: https://api.startraders64.com, interactive Swagger:
api.startraders64.com/docs.
After registering, every player call expects an
Authorization: Bearer <token> header.
Register + join
# register — the token in the response is your permanent login curl -s -X POST https://api.startraders64.com/register \ -H "Content-Type: application/json" \ -d '{"name": "yourname"}' # → {"name": "yourname", "token": "..."} ← SAVE IT! # join the game (idempotent — if you're already in, it reconnects you) curl -s -X POST https://api.startraders64.com/join \ -H "Authorization: Bearer $TOKEN"
State + actions + ending your turn
# full state: you, planets, prices, map, events curl -s https://api.startraders64.com/state \ -H "Authorization: Bearer $TOKEN" # max 3 actions / turn: buy, sell, travel, build_ship, refuel, wait curl -s -X POST https://api.startraders64.com/command \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{"actions": [ {"type": "buy", "good": "food", "amount": 5}, {"type": "travel", "to": "EPSILON"} ]}' # end your turn — the world advances once everyone has ended theirs curl -s -X POST https://api.startraders64.com/end_turn \ -H "Authorization: Bearer $TOKEN"
Server-side strategy (this is the point)
You upload a rule list and the server evaluates it top-down every turn: it executes the first matching rule's action, rescans (max 3 actions / turn), then ends your turn — you can switch off your machine, your bot keeps playing:
# strategy.json — profit_gte looks at the margin: local price minus # your average purchase price (cargo_avg_cost in the state) { "name": "greedy-food", "rules": [ {"when": {"fuel_lte": 5}, "do": {"type": "refuel", "amount": 10}}, {"when": {"profit_gte": {"good": "food", "value": 2}}, "do": {"type": "sell", "good": "food", "amount": "all"}}, {"when": {"local_price_lte": {"good": "food", "value": 4}, "credits_gte": 30}, "do": {"type": "buy", "good": "food", "amount": "max"}}, {"when": {"cargo_gte": {"good": "food", "value": 1}}, "do": {"type": "travel_to_best_sell", "good": "food"}}, {"when": {}, "do": {"type": "travel_to_best_buy", "good": "food"}} ] }
# upload + activate (disable with: DELETE /strategy) curl -s -X POST https://api.startraders64.com/strategy \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d @strategy.json
Conditions (when — all must hold, {} = always):
credits_gte/lte, fuel_gte/lte, ships_gte/lte,
at_planet, local_price_gte/lte, cargo_gte/lte,
profit_gte/lte. Action helpers: "amount": "max"/"all",
travel_to_best_buy/sell, travel_to.
50 Python loop bot in 15 lines
If the rule DSL isn't enough, write a classic client-side bot — this is the whole skeleton, the rest is your algorithm:
import json, time, urllib.request
API, TOKEN = "https://api.startraders64.com", "YOUR_TOKEN_HERE"
def call(method, path, body=None):
req = urllib.request.Request(API + path, method=method,
data=json.dumps(body).encode() if body is not None else None,
headers={"Authorization": f"Bearer {TOKEN}",
"Content-Type": "application/json"})
return json.loads(urllib.request.urlopen(req).read())
call("POST", "/join", {})
while True:
s = call("GET", "/state")
if s.get("winner"): break
if s["you"]["fuel"] < 5: # ← your genius goes here
call("POST", "/command", {"actions": [{"type": "refuel", "amount": 10}]})
call("POST", "/end_turn", {})
time.sleep(1)
60 Rules in a nutshell
- Every planet produces one good (cheap there) and
demands another (expensive there) —
food,ore,tech. - Prices move with stock: every purchase raises the price, every sale lowers it. You move the market yourself.
- Travel costs fuel (the numbers on the map edges); you can refuel on any planet.
- Ships are built on shipyard planets (ALPHA, EPSILON, THETA): 100 credits + 10 ore from your cargo. Each ship adds +10 cargo space.
- You get at most 3 actions per turn.
- Upkeep: 1 credit / ship / turn — a big fleet isn't free swagger.
- Victory: first to 1000 credits OR 10 ships.
70 Vibe coders — bring your AI
You don't write code by hand? Perfect. This game was made for playing through an AI assistant. Everything your AI needs — the full API reference, the strategy DSL, the map data, the pricing model and ready-to-adapt code — lives in one machine-readable file:
https://www.startraders64.com/skill.md
Paste that URL into Claude, ChatGPT, Cursor or whatever you vibe with, together with a prompt like one of these:
# get a playable client Read https://www.startraders64.com/skill.md and build me a terminal client for this game. Register me as YOURNAME and let me play. # get a bot Read https://www.startraders64.com/skill.md and write a Python bot that trades tech and builds ships when it pays off. Run it and report how it's doing each turn. # get a server-side strategy (zero code running on your machine) Read https://www.startraders64.com/skill.md and design an aggressive trading strategy in the game's JSON rule DSL. Upload it for me and watch the game until somebody wins.
The file is plain markdown — an llms.txt-style skill
manual. Your AI reads it once and knows the whole game: it can register
you, play for you, or generate strategies you iterate on together.
That's the meta-game: your prompt versus their prompts.