STAR

Steam Timed Achievement Replayer

Replays a real player's achievement timeline on your Steam account: the same achievements, in the same order, with the same gaps between them and the same play sessions and breaks. A desktop app for macOS and Linux.

curl -fsSL https://raw.githubusercontent.com/sepehrsardooeinasab/star/main/install.sh | sh

Paste it into a terminal. Python 3.8+ is the only requirement, and nothing needs sudo.

Releases

How it works

A player's real playthrough has a shape: they play for a while, unlock a few achievements minutes apart, stop for the night, come back the next day. STAR copies that shape. It takes the exact unlock times from a player who finished the game, splits them into sessions wherever the player stopped, and plays them back on your account at the same pace.

Copy a player's timeline

Paste a link to their achievements on SteamHunters or Steam, or the SteamHunters page itself. STAR reads every unlock and the time between them.

Split it into sessions

A pause longer than Session break after (3 hours by default) starts a new session. Between sessions the game is closed, as if the player stopped playing.

Play it back

For each session, the game shows as running on your Steam profile and its achievements unlock at the player's pace. Then it waits out the break before the next one.

Why sessions

A session is one sitting: the game shows as running on your profile, the achievements unlock as the player earned them, then the game closes. Your playtime grows along with the unlocks, and the breaks between sittings stay, so the timeline looks like a real playthrough instead of every achievement landing at once. Max session length (6 hours by default) adds a break when a long sitting would otherwise run on, and Warn if break under flags breaks short enough to look odd.

What does the unlocking

STAR drives ArchiSteamFarm (ASF) and its ASFAchievementManager plugin. ASF signs in to your Steam account, "plays" the game, and the plugin unlocks each achievement with aset <appid> <number>. The installer sets both up from their official releases, checked against their published checksums.

The plugin needs each achievement's number in the game. STAR asks ASF for the game's list and matches each achievement by name. Where a game reuses a name (Bongo Cat has four "Item Collector"s), it tells them apart by description. It warns when names repeat, and stops rather than guess when ASF and Steam disagree.

Optional randomness

With Randomize delays on, each delay longer than a minute moves by up to ±10% of itself, so a run never replays the player's timings to the second. A 10-minute delay becomes anywhere from 9 to 11 minutes. Unlocks that happened together are still sent together, and the value picked is saved with your progress, so stopping and resuming doesn't change it.

Using the app

Open STAR and sign in to Steam; it asks for the Steam Guard code if needed. The title bar switches between Schedule, Runs, Library and Settings (or the Go menu, ⌘1 to ⌘4). Library shows your achievements from Steam, newest first, and your games with their achievement progress; games marked Private or hidden in Steam are faded and marked.

1. Make a schedule

Paste into Schedule either:

A link to a player's achievements for the game, from SteamHunters (steamhunters.com/id/<player>/apps/<appid>/achievements) or Steam (steamcommunity.com/id/<player>/achievements/<appid>). The exact unlock times come straight from Steam, so the player's profile must be public.
The page itself: on SteamHunters, open the player's achievements for the game, select the whole page (⌘A / Ctrl+A), copy and paste. Turn on Show hidden achievements in SteamHunters' settings first, or hidden ones come without a name. Any sort or grouping works.

The game's name and App ID fill themselves in where they can. The sessions table beside the paste shows each session's achievements, length and the break before it; Full timeline shows every achievement, where you can add or remove breaks and change delays. Options holds the session rules. Then Save.

2. Run it

On Runs, pick a game in the list and press Run (or Continue) in the title bar:

1 session plays the game's next session, first waiting for its break to end if needed. All sessions plays every remaining one back to back, waiting out the breaks.
When ready can be changed to start in 30 minutes up to 4 hours, or Other… for any time (45m, 1h30m, or a clock time like 23:30).
While it runs, the same button is Stop (the bot stops playing, progress is kept), and 1 session / All sessions switches between stopping after the current session and playing on.
One game runs at a time. The running game is pinned to the top of the list; games still in their break are dimmed with a clock.

The selected game shows a summary (session, this session's length, unlocked so far, when it can play), its sessions with the current one marked, and its activity log as it runs. The arrow at the end of the summary shows its App ID and where it was copied from. Full timeline lists every achievement; open its lock to change the delays still ahead, then Save.

Runs keep going when the window is closed; open the app any time to see where they are. The computer has to stay on, and it's kept awake while a run is going.

3. Settings

Settings shows the ArchiSteamFarm and plugin versions with Check for updates, the Steam account (Use another account), a switch (and a test) for keeping the computer awake, whether finished games are listed in Runs, the Advanced run settings, and the data folder. Its Appearance card sets the theme, banners, gradient and accent, which are also in the View menu with Library's main choices.

ArchiSteamFarm and the plugin are pinned to versions known to work together, and ASF's own auto-update is off so it can't drift from the plugin. Check for updates offers the newest ASF in the series the latest plugin is built for; newer series need a new plugin first. Updates are swapped in between sessions, never during one. STAR updates itself: when a new release is out, it installs it once no game is in a session. Check for Updates… in its menu does it right away.

Good to know

Your data (schedules, progress, finished games, ArchiSteamFarm, settings) lives in ~/Library/Application Support/STAR (macOS) or ~/.local/share/star (Linux). Copy it to back up or move to another computer. Finished games move to completed/ inside it.
Keeping awake: macOS uses the built-in caffeinate; Linux uses systemd-inhibit, and a closed laptop lid may still suspend it, depending on your desktop.
Privacy: the app's page is served on 127.0.0.1 only, and only answers the app itself. Your Steam login is saved only in ArchiSteamFarm's own config on this computer.
Installing: run the install command again to update; your games and settings are kept. ... | sh -s -- --uninstall removes the app and keeps your data. Downloading the macOS app by hand from Releases means macOS asks you to allow it once in System Settings → Privacy & Security; the install command avoids that.

Disclaimer. This doesn't violate Steam's own terms of service, but it does violate the rules of achievement-tracking and ranking sites (e.g. SteamHunters) that expect achievements to reflect legitimate play. Use at your own risk.

Command line

The installer also adds runsteamunlocker, which runs the same code. You don't need it with the app; it's there for computers without a screen (a Linux box over SSH), without the app (--no-app; --ui opens the interface in the browser), or when something's wrong (-k stops ArchiSteamFarm and every run, --ui-stop stops a stuck app server). Games are named by their file name (jsons/config_<name>.json).

runsteamunlocker <name>          # run the game's next session (asks first)
runsteamunlocker -f <name>       # same, without asking
runsteamunlocker -w <name>       # confirm now, wait until the session can run, then start it
runsteamunlocker -in 2h <name>   # confirm now, start in 2h (also 30, 45m, 1h30m)
runsteamunlocker --auto <name>   # every remaining session back to back, waiting out the breaks
runsteamunlocker -t <name>       # the next session's wait and length, without running
runsteamunlocker -s <name>       # achievements from the current session on (or: all, or a number)
runsteamunlocker -ls             # every game's next session and when it can run
runsteamunlocker -a              # list the saved games
runsteamunlocker -u              # open the app in the browser
runsteamunlocker --setup         # download ArchiSteamFarm + plugin, write configs, sign in to Steam
runsteamunlocker --ui-stop       # stop the app's server; games it started keep running
runsteamunlocker -k              # stop ArchiSteamFarm and any running session
runsteamunlocker -h              # help

Details

Safety checks

Config check: before anything else, the schedule is checked for a valid App ID and, on every achievement, a whole-number id (no duplicates), a delay of 0 or more and a true/false session start. A broken one stops with a list of what's wrong, instead of failing partway through a session.
Order changed: progress is saved as a position in the schedule's achievement list, with a fingerprint of that list's order. If the order changes later (e.g. you rebuild it from another player), you're asked before continuing. Editing delays or breaks doesn't count as a change.
One game at a time: while a game is running, breaks included, starting any other game (or the same one again) is refused until it's stopped or finished. The locks are released automatically when a run exits, even if it's killed.
Safe progress saves: progress is written to a temporary file and then swapped in, so stopping a run mid-save can't corrupt it.

Run settings

The app's Advanced run settings edit these; they're saved in settings.json in the data folder, which only keeps what differs from the defaults. An unknown key or a wrong type stops the unlocker with an error, so a typo never quietly falls back to a default.

Key	Default	What it does
`keep_awake`	`true`	Keeps the computer from sleeping while a run waits or plays.
`show_finished`	`false`	Lists finished games in the app's Runs (at the bottom).
`steam_api_key`	`null`	A Steam Web API key, so the app's Library covers every game you play, not just the games in STAR. Set it in Settings → Library.
`clock`	`"system"`	How the app writes times: `"12h"` (2:30 PM) or `"24h"` (14:30). Until one's set (`"system"`), the usual one for the computer's language. Set it in Settings → Clock.
`theme`, `accent`	`"dark"`, `"violet"`	The app's look, from Settings › Appearance: `"dark"` or `"light"`; `"violet"`, `"wine"`, `"blue"`, `"teal"` or `"amber"`.
`unlocks_range`	`"month"`	How far back the app's Library lists achievements: today (`"day"`), this week, this month, this year, or `"all"`. Set it in Settings → Library.
`week_start`	`"monday"`	The day Library's Week starts on: `"monday"`, `"sunday"` or `"saturday"`. Set it in Settings → Library.
`library_tab`	`"achievements"`	Which section Library opens on: `"achievements"` or `"games"`.
`library_check`	`"6h"`	How often Library checks Steam for new games and achievements, in the background, at set times of day counted from midnight (`"6h"`: 12 AM, 6 AM, 12 PM, 6 PM; a check older than the latest of them is made up at once): `"1h"`, `"3h"`, `"6h"`, `"12h"`, `"24h"`, or `"manual"` (only on Refresh). Set it in Settings → Library.
`achievement_sort`, `achievement_order`, `achievement_group`	`"date"`, `"desc"`, `"status"`	How a game's page in Library lists its achievements: in Steam's own order (`"default"`, as ArchiSteamFarm's `alist` lists them), by `"date"` unlocked or `"name"`; `"desc"` (reversed, newest, Z–A) or `"asc"`; grouped into unlocked and locked (`"status"`) or not (`"none"`). Set it in Settings → Library.
`library_active`, `library_finished`, `library_private`, `library_no_achievements`	`"show"` each	Which games Library's Games lists, by group, each `"show"` or `"hide"`: those you marked finished on their page, those marked Private in Steam, those without achievements, and the rest (`library_active`). A game shows when any group it's in is shown. Set it in Settings → Library, or for a while in Games' Filters.
`hidden_descriptions`	`"unlocked"`	When Library shows a hidden achievement's description: `"unlocked"` (once you've unlocked it), `"all"` or `"none"`. Set it in Settings → Library.
`library_sort`, `library_order`	`"played"`, `"desc"`	How Library's Games are sorted: `"played"` (last played), `"achievement"` (last achievement), `"name"`, `"progress"` or `"playtime"`; `"desc"` (newest, Z–A, most first) or `"asc"`. Set it in Settings → Library.
`jitter_enabled`	`false`	Randomness on delays, so a run doesn't replay the player's timings to the second.
`jitter_percent`	`10`	How far a delay can move, either way, as a percentage of itself (0–100).
`jitter_min_delay`	`60`	Only delays longer than this many seconds get randomness.
`simultaneous_max_delay`	`1`	Unlocks this many seconds apart or less are sent together.
`stop_other_asf`	`true`	Stops other ArchiSteamFarm installs on this computer when a session starts, since Steam allows one login per account. Turn it off if they use other accounts (e.g. a card-farming install).
`warm_settle_delay`	`10`	Seconds between starting the game and the first unlock, when the bot was already connected.
`reconnect_settle_delay`	`60`	The same wait when Steam just reconnected. Shorter values have produced offline-looking timestamps.
`play_check_interval`	`30`	How often (seconds) a session checks whether the bot reconnected to Steam, which drops the game it was playing. Only ASF's log is read, so it can be often. It's also checked before every unlock.
`bot_connect_timeout`	`60`	Seconds a command keeps retrying while ASF starts or the bot connects to Steam.
`asf_shutdown_delay`	`300`	Seconds after a session ends before an idle ASF is shut down.
`run_logs_kept`	`3`	How many of a game's runs its log keeps (Runs shows them, up to 1 MB). Each run starts with a "Started" line.
`asf_port`	`1243`	Port ASF's local API listens on. Must match ASF's `IPC.config`.
`ipc_password`	`null`	ASF's `IPCPassword`, if you set one.
`ui_port`	`8788`	Port of the app's local server.

Manual setup

Only needed without the install command, e.g. running straight from a clone of the repository. The README has the full steps: set up ArchiSteamFarm with the ASFAchievementManager plugin and a single bot, give ASF's local API port 1243 in IPC.config, then open STAR in your browser with runsteamunlocker --ui to build a schedule (it saves into jsons/) and run it. Python 3 is required; the unlocker only uses its standard library.

Schedules are made from pasted pages or public Steam data because SteamHunters has no public API for per-player achievement data and blocks automated access.