Bytefray 5.1.0-alpha.1 — Windows Alpha

Bytefray 5.1.0-alpha.1 — Windows Alpha

Bytefray is a programmable-agent arena: write agents, run deterministic matches,
and inspect recorded replays. This Windows prerelease previews Active Sensing
alongside Classic gameplay. Bytefray 5.0.0 remains the stable release.

Download and install

Download Bytefray-5.1.0-alpha.1-Windows-x64-Setup.exe and SHA256SUMS from this
release. Verify with PowerShell:

Get-FileHash -Algorithm SHA256 .\Bytefray-5.1.0-alpha.1-Windows-x64-Setup.exe

Expected installer SHA-256:
b306c6b0909a003bed13fa6039f88994cadcac378c84f09d15a0e3e3129df433.
The installer is 114,129,318 bytes. Installer and programs are unsigned; proceed
through SmartScreen only after verifying the official download and digest.

Setup first shows the terms for the included Microsoft Visual C++ runtime files and
continues only after you select I accept the agreement. They apply only to those
Microsoft files. An unattended (/SILENT or /VERYSILENT) installation is refused
unless it passes /ACCEPTMICROSOFTRUNTIMETERMS=BYTEFRAY-5.1-MSVC-RUNTIME-TERMS-1.

For Windows x64 (AMD64); qualified historically on Windows 11. Windows ARM64 is
unsupported. No separate Python, Godot editor, Git or development checkout is
required. Run the installer for your Windows account, without administrator rights.
Open Bytefray Agent Designer (5.1 Alpha) from the Start Menu afterward.

The Alpha uses its own per-user program folder
%LOCALAPPDATA%\Programs\Bytefray 5.1 Alpha, data folder
%LOCALAPPDATA%\Bytefray 5.1 Alpha, Start Menu group and uninstall identity. It
ignores the inherited BYTEFRAY_ROOT setting used by 5.0. Actual simultaneous
5.0/5.1 installations were not independently tested; the project lead accepted
this remaining qualification risk for Alpha 1.

Uninstall through Settings → Apps. The Alpha data folder and Spectator settings
at %APPDATA%\Godot\app_userdata\Bytefray Spectator are preserved by policy.
Keep install paths under about 150 characters and keep data outside program
folders. Avoid junctions or symbolic links in installation paths. Installing an
older 5.1 Alpha build over a newer build is refused.

Included components

• Classic (bytefray-rules-4) remains the default.
• Active Sensing (Alpha), bytefray-rules-6-alpha1, requires explicit selection
  in Advanced, Development or supported CLI commands.
• Agent creation, bundled learning agents, CLI tools and the Pygame replay viewer.
• Bytefray Spectator 0.1.0-alpha.1, built with Godot 4.7.2, for completed
  two-agent Active Sensing matches; Broadcast and Agent A perspectives.

Application display version is 5.1.0-alpha.1; Python package version is 5.1.0a1.
Agent API v2; replay schema 4; result schema 2; trace schema 2; presentation manifest
2 (Spectator reads manifest versions 1 and 2). Consult the attached frozen compatibility
JSON and Markdown for supported workflows and historical read compatibility.
The compatibility record remains marked candidate and identifies the original
build checkpoint. Evaluation actions fall back to Pygame when required trace data
is absent; the detailed replay behavior below governs this Alpha.

Understanding the bundled agents

Bytefray includes 13 bundled agents with different purposes. In Agent Designer and bytefray agents list, their names begin with V4, V5 or V6. The categories below describe their intended roles; Designer does not yet display these categories.

Learning agents demonstrate gameplay concepts and programming techniques. They are designed to teach mechanics rather than provide optimized competitive play.

• Classic — four "V5 … (Starter)" agents: Region Attacker, Scout Striker, Core Defender and Dual Team introduce region attacks, scouting, core defense, and coordinated processes.
• Active Sensing — three "V6 … (Starter)" agents: Window Scout, Watchful Keeper and Roaming Reacquirer demonstrate observation, delayed information, defensive sensing, and reacquisition.

Practice opponents are five simpler Classic agents: V4 Claimer, V4 Concentrated Attacker, V4 Defender Scout, V4 Local Defender and V4 Scout. They are useful for testing your own strategies.

Competitive example: V4 Quorum (Advanced Example) uses six coordinated processes and was the strongest bundled agent in earlier Classic testing.

Trying Active Sensing (Alpha): Select two V6 learning agents yourself. Designer's initial matchup uses two Classic agents, so change the agents as well as the ruleset.

Classic agents can run under Active Sensing, but their strategies were written for Classic, where opponents are passively visible. Active Sensing disables that visibility.

V6 learning agents may also produce quiet matches because their instructional scenarios were qualified against controlled opponents rather than arbitrary pairings.

Spectator preparation delay

Before Spectator can show a completed two-agent Active Sensing match, Bytefray prepares a presentation of it.

Designer normally starts this preparation automatically in the background when a match finishes. For substantial matches, preparation can take several seconds or longer.

If you click View Last Match before preparation finishes, Spectator opens once it is ready. If background preparation was skipped because another match was being prepared, clicking View Last Match can initiate preparation of the selected match.

Designer reports preparation activity in its match log (lines beginning [Spectator]), but the button does not visibly change, so it may look as if nothing happened. Clicking again for the same match does not restart preparation.

Once a match has been prepared, opening it again with View Last Match is generally much faster because the presentation is cached.

Improved visual feedback during replay preparation is planned for a future update.

Replay viewer behavior

Spectator supports completed two-agent Active Sensing matches. Two replay workflows can open it:

• View Last Match in the Simple and Advanced views. Presentation preparation normally begins automatically after the match finishes.
• Open Replay on the Development tab, following an agent test. Agent tests do not prepare presentations in the background, so the first opening includes a preparation wait.

Other replay controls open the Pygame viewer in the current Alpha, even for matches that Spectator could otherwise display. These include Replay History, Tournament replay controls, Evaluation results and Evaluation History, and View Replay in the Advanced view. Evaluation replay actions attempt Spectator first but fall back to Pygame because their matches lack the required trace file.

Development tab hint: The instructions suggest selecting Active Sensing in Advanced and then using "Run and Open Replay." The Advanced view does not have an Open Replay button. Use View Last Match there instead.

Reopening matches: To reopen a match in Spectator, use View Last Match while it is still the most recent match and Designer remains open. After Designer restarts, View Last Match is unavailable until another match completes. Earlier matches can still be opened from Replay History, in the Pygame viewer.

Additional known limitation

The bytefray agents list command currently mentions the Active Sensing ruleset requirement only for Window Scout. Watchful Keeper and Roaming Reacquirer require the same ruleset:

--ruleset bytefray-rules-6-alpha1

This is an omission in the command's output, not a difference in agent compatibility.

Other Alpha limitations

• Active Sensing is unavailable in Simple, evaluations and tournaments.
• Spectator's Tab hint is inaccurate: Tab moves focus. Use the perspective list;
  Space activates a focused button, so use playback controls when needed.
• Designer's entrant C selector lacks a screen-reader name; Alpha accessibility
  has not been reviewed.
• Linux packaged support and native Ubuntu Xorg are not qualified for this release;
  macOS is not qualified. Human comprehension research remains incomplete.
• Teaching agents demonstrate concepts; no competitive Active Sensing strength
  is claimed. E9 Requirement C remains not established.
• Standalone sensing demonstration generators remain source-only.
• Missing/damaged installation records or overlapping data folders prevent startup;
  windowed programs may show a generic script-error dialog. Reinstall as directed.

Source, licenses and provenance

Bytefray and Spectator use MIT licenses. Bundled dependencies retain their own
licenses, including LGPL terms. Versioned third-party notices and exact-version
upstream source downloads accompany this release. The dependency source
index records their origin, size and SHA-256. Source availability alone does not
establish satisfaction of all redistribution or replacement requirements.

The Microsoft Visual C++ runtime files (14.51.36247.0) are redistributed by Rod
Satterfield under the Microsoft Visual Studio Community 2026 Distributable Code terms;
their recipient terms are shown in Setup and installed in
licenses\microsoft-visual-cpp-runtime\.
Status: installed qualification of Windows build 5.1.0.1011 passed on 2026-10-24 (205 qualifying checks in a separate standard Windows account).
The installer (Windows build 5.1.0.1011) was built from Bytefray c0a84134e5eab89ae33aa6072788d638a866a57d.
Spectator was built from 14089a7bf624a5974346306a277e307ea8f48c07.
See the attached build provenance and checksums for these exact binaries.

Downloads

Installer and checksums

• Bytefray-5.1.0-alpha.1-Windows-x64-Setup.exe
• [SHA256SUMS](https://github.com/libertaine/Bytefray/releases/downlo...

Bytefray 5.0.0

Bytefray 5.0.0

Bytefray 5.0 is the stable final release of the 5.0 line, promoting the qualified 5.0.0-rc1 candidate. No gameplay, Agent API, or wire-schema change has been made since RC1 — this release finalizes the agent-authoring, parameterization, and desktop experience atop the immutable bytefray-rules-4 gameplay core and Agent API v2.

Highlights

• Replay History Subsystem — a global Replay History dialog (History → Replay History…) with automatic discovery of recorded match and evaluation replays, result indexing, real-time filtering/search, and direct Replay Viewer launch.
• Complete Tournament UX Workflow — an end-to-end Configure → Run Tournament → See Results → Browse Matches → View Replay loop in Agent Designer, with atomic checkpoints, standings, and per-match result/replay inspection.
• Unified Result-Backed Replay Integrity — match, tournament, and evaluation replay views re-verify their SHA-256–backed result association before opening a replay.
• Accessibility baseline — full keyboard navigation across Designer workspaces and dialogs, accessible names/descriptions, visible keyboard focus, and dual keyboard/mouse activation throughout.
• Reorganized application menus and hardened parameter consistency across CLI runs, tournament matches, and GUI panels.
• Process-share validation repair — Agent API v2 multi-process share declarations (including bundled v5_dual_team parameterizations) are now validated against the same exact-rational partition Ruleset-v4 construction uses, eliminating a false-rejection edge case found during release-candidate review.

See the full CHANGELOG for details.

Platform support

• Windows: install via the standalone administrative installer (Bytefray-Setup-5.0.0.exe below), which places the CLI, Agent Designer, and Replay Viewer under C:\Program Files\Bytefray\bin.
• Python / Linux: install the wheel or source distribution (bytefray-5.0.0-py3-none-any.whl / bytefray-5.0.0.tar.gz below) into a Python 3.10–3.14 virtual environment. See docs/LINUX_INSTALL.md for GUI/X11/Xvfb setup. Bytefray 5.0.0's Agent Designer and Replay Viewer were additionally smoke-tested on a native GNOME/Wayland desktop (Ubuntu 26.04.1 LTS); the Linux wheel should otherwise still be treated as headless-first by default.
• Match replays are byte-identical across Windows and Linux, source and packaged forms, for a given seed and configuration.
• macOS is not an officially tested or supported platform.

Installation

See the README for full installation instructions. Note: pip install bytefray from PyPI is not available for this release — install from the wheel or sdist attached below.

Verifying downloads

SHA256SUMS (attached) lists the SHA-256 digest of every binary/package asset in this release.

Bytefray v5.0.0-rc1

Bytefray v5.0.0-rc1 — release candidate for v5.0.0.

This is a prerelease, not the final v5.0.0. Built from candidate source commit bfd3bb8 and qualified on Windows only (clean elevated installation, machine registration, Start Menu integration, installed CLI/Designer/Replay Viewer, all 21 starter agents, battle, Tournament, former RC blocker regressions, uninstall/reinstall, repository/venv independence).

Linux packaging qualification for this build has not been completed and is not represented by this release. The Linux wheel and sdist are intentionally not attached here; they will be published once Linux qualification is finished and documented.

What's in v5

Bytefray v5 stabilizes the agent-authoring, parameterization, and desktop experience atop the immutable bytefray-rules-4 gameplay core and Agent API v2. RC1 consolidates the post-Alpha 1 remediation phases into a unified, release-ready desktop and headless product:

• Global Replay History dialog with automatic discovery, indexing, filtering/search, and Replay Viewer launch
• Complete Tournament UX workflow: Configure → Run Tournament → Results → Matches → Replay, with atomic checkpointing
• Unified result-backed replay integrity preflight across last-match, Development, Tournament, Replay History, and Evaluation views
• Standard accessibility baseline and reorganized application menu/commands
• Starter agent refresh hygiene

Assets

File	SHA-256
Bytefray-Setup-5.0.0-rc1.exe	f40f8f4a07b36b12b227300655fc458470093550111e08e6dd9a2797fd312d96

Verify with SHA256SUMS.txt.

🤖 Generated with Claude Code

Bytefray 5.0.0 Alpha 1

Bytefray 5.0.0 Alpha 1

Bytefray is a deterministic programmable-agent arena where Python agents move,
observe, and compete over shared memory. Bytefray 5 begins establishing the
project's post-Core-War identity while retaining the proven stable V4 gameplay
ruleset.

Highlights

• Four new educational V5 starters demonstrate stronger objective-capable
  behavior: attacking regions, finding contacts, defending a core, and teamwork.
• Agent API v2 authoring includes blank and annotated scaffolds, parameter
  schemas with validation, and named presets.
• The Designer generates typed controls from agent schemas, shows effective
  values, and provides an explicit Randomize Seed action.
• Deterministic execution supports reproducible matches; result and replay
  metadata expose the effective agent parameters.
• Bundled-starter refresh updates recognized pristine copies and preserves
  customized agents.
• Packaging and cross-platform hardening cover API-v2 scaffold resources,
  clean packaged contents, Windows installed workflows, and Linux wheel/source
  installation. Runtime Python support is 3.10–3.14.

Meet the V5 starters

Agent	Lesson
v5_region_attacker	Apply pressure across an objective-sized region.
v5_scout_striker	Search, remember a contact, then strike.
v5_core_defender	Observe your core and repair confirmed losses.
v5_dual_team	Coordinate a raider and keeper with a shared action budget.

These are readable teaching agents, with deliberate trade-offs and tunable
parameters. See the V5 starter guide.

Agent authoring

Use API v2: initialize in reset, return your roster of ProcessDeclaration
objects from declare_processes, and respond to ObservationV2 in act.
Use the deterministic RNG supplied by MatchContextV2. Parameter resolution is
defaults < preset < explicit override.

Start with the Agent API v2 authoring guide
and scaffolding and validation workflow.

Compatibility

Historical V4 starters remain available, and Agent API v1 retains its existing
compatibility path. Stable gameplay remains bytefray-rules-4, the default for
an API-v2 roster. Product version 5.0.0a1 does not introduce a
bytefray-rules-5 gameplay ruleset.

Installation

• Windows AMD64: use Bytefray-Setup-5.0.0a1.exe for the complete applications;
  administrative installation is required. Launch Agent Designer from the
  Bytefray Start Menu group. The installer does not add commands to PATH.
• Individual Windows executable assets: bytefray.exe, bytefray-cli.exe,
  bytefray-agent-designer.exe, and bytefray-replay-viewer.exe are the qualified
  launcher binaries. They require their matching adjacent PyInstaller runtime
  directories and resources; a downloaded .exe alone is not a portable app.
  Use the installer to obtain the complete layouts.
• Python wheel: download bytefray-5.0.0a1-py3-none-any.whl, activate a virtual
  environment, then run
  python -m pip install ./bytefray-5.0.0a1-py3-none-any.whl.
  The core CLI is headless; optional replay and designer extras provide the
  desktop tools. These instructions install the GitHub asset, not a PyPI release.
• Source distribution: bytefray-5.0.0a1.tar.gz supports source installation.
  Linux wheel and source installation were qualified on Ubuntu 24.04 under WSL2.

Alpha notice

This is an Alpha release. Interfaces, starter behavior, and UX may continue
to evolve before Bytefray 5.0.0 final.

Qualified source: 28a10b8f8fd47bf32ec9281dcc21b0645276962c.
Release tag: b5.0.0-alpha1.

SHA-256 checksums

BB8B6AD47D3C8B481415A72DD7514FD13159F6417AB71169689B9A2302BC252A  bytefray-5.0.0a1-py3-none-any.whl
03AAF95EFA6A87409789D10EEE5D91626B40A6561BE637CD42968B9818E9917A  bytefray-5.0.0a1.tar.gz
932C982B2C727422DFF61A1D343D56A94099B661A6D8E82D6482335DD3DBCE12  bytefray.exe
43BE230CEEBAF18E3D864E55A2B73E784D154051A1B2448B5690CA750E36CCED  bytefray-cli.exe
9B91FED22D18C3492C9449AE4A278E71FE00DEEFC490DCBB7825C6912A356520  bytefray-agent-designer.exe
D7B1F2B2EC8E1E8ABF76493D1D8E0AC72C8CAD980570265A6C0D0774EA94431B  bytefray-replay-viewer.exe
DFAA25609405CA170BED0DF7A6E684FC72F316B91FD846837F79909D3B07379F  Bytefray-Setup-5.0.0a1.exe

Bytefray v4.0.0

Bytefray 4.0.0 — Spatial Multi-Process Platform & Spectator Intelligence

Bytefray 4.0 is the official stable release of the next-generation programmable arena, establishing the permanent bytefray-rules-4 ruleset, multi-process Agent API v2, and the full spectator intelligence suite.

Built from qualified candidate commit 9077b61 on main, incorporating post-UX refinements and comprehensive dual-platform Windows and Linux qualification.

Highlights in Bytefray 4.0

• Spatial Multi-Process Combat (bytefray-rules-4): Fixed entrant quota (Q=8), multi-process execution with movable anchors and localized circular action reach, seed-derived deterministic core placement, and strict process-level fairness.
• Agent API v2: Support for multi-process process declarations (declare_processes()), rich typed observations (ObservationV2), and discrete action dispatch (ActionKindV2: MOVE, READ, WRITE).
• Complete Spectator Presentation:
  • Broadcast Cam: Omniscient bird's-eye arena view with real-time process markers and telemetry.
  • Perspective Cam: First-person view respecting entrant sensor bounds, anonymous contact memory, and stale scan tracking.
  • Spectator Director: Autonomous camera pacing and dynamic focus switching driven by real-time spatial events.
  • Fight Night Event Ribbon: Contextual live combat event stream (clashes, disruptions, claims, eliminations).
• Ruleset-First Agent Designer: Streamlined match configuration tabs (Simple & Advanced) with contextual ruleset parameters, dynamic 2–3 agent rosters, and default scoring aligned strictly with the simulation engine.
• Improved Replay Workflow: Automatic spectator trace recording from both Simple and Advanced Designer launches, integrated Replay Picker with empty-state guidance, and multi-entrant playback.
• Python 3.10–3.14 & pygame-ce Compatibility: Full support for modern Python runtimes with native headless and graphical execution.
• Multi-Platform Distribution: Standalone administrative Windows installer, portable Windows ZIP, official Python wheel, and source distribution.

See CHANGELOG.md for detailed release notes.

Downloads

Package	File	Size	Notes
Windows Installer	Bytefray-Setup-4.0.0.exe	96.0 MB	Administrative AMD64/x64 installer
Portable Windows	bytefray-4.0.0-windows.zip	135.7 MB	Portable AMD64 onedir apps (CLI, Designer, Replay Viewer)
Python Wheel	bytefray-4.0.0-py3-none-any.whl	901 KB	Pure Python 3.10–3.14 package
Source Archive	bytefray-4.0.0.tar.gz	886 KB	Python source archive
Checksums	SHA256SUMS.txt	374 B	SHA-256 integrity verification

Checksums

099f0cc7940307de9414211ccc0a588ec835a7c7d3b0b1d70ddb7518ed4f3236  bytefray-4.0.0-py3-none-any.whl
76fe52062288974bf508091abe45e5b15910fe108857c411edd4c949ed0cc94a  bytefray-4.0.0.tar.gz
ac522585e4a153348cbd3e203c7a3c8b7111d9f4c0baa0f4ca043498bd663921  bytefray-4.0.0-windows.zip
8aeb340a17570c9bb98329ddd7870b539d1b94e95e12b327932d9eafa111f7a5  Bytefray-Setup-4.0.0.exe

Bytefray v4.0.0-rc2

This is a prerelease, not final v4.0.0.

Bytefray v4.0.0-rc2 is the second v4.0 release candidate. It adds a self-contained Linux binary distribution and closes out the pygame-ce/Python 3.14 migration alongside the V4 Quorum advanced example agent. No gameplay, Agent API, Ruleset, or replay-schema change is included — RC1's stable v4 contract (bytefray-rules-4) is unchanged.

What's new since RC1

• Self-contained Linux binary distribution. A frozen PyInstaller onedir build of all four applications (bytefray, bytefray-cli, bytefray-agent-designer, bytefray-replay-viewer), packaged as bytefray-4.0.0-rc2-linux-x86_64.tar.gz. No system Python or pip install required to run it.
• Official Ubuntu 24.04 Linux build baseline. Built and qualified in CI on an explicitly pinned ubuntu-24.04 runner (not ubuntu-latest), gated on native shared-library resolution, the fixed-seed v4_quorum reference match, and a headless replay smoke. The exact built archive was additionally verified byte-for-byte on Ubuntu 26.04, with no source-repository or build-venv dependency. The measured maximum requirement is GLIBC_2.38; the archive is not qualified against Ubuntu 22.04 or Debian 12, and no universal Linux compatibility is claimed.
• Frozen Linux subprocess-launch portability fix. Every code path that relaunches the frozen executable as a subprocess (agents validate/test, tournament resume, Designer development-test/replay launch) unconditionally looked for a .exe-suffixed sibling, which made every such relaunch fail on a Linux onedir build whose launcher has no extension. The suffix now resolves per-platform.
• Replay/GUI dependency migrated from classic Pygame to pygame-ce (>=2.5.8), fixing a real Linux install failure on newer CPython where classic Pygame had no compatible wheel and fell back to a source build requiring SDL2 dev headers. Application and agent source is unaffected — both still import pygame.
• Python 3.14 formally supported and qualified across core, Agent API v2, Designer, and the Replay Viewer.
• V4 Quorum (Advanced Example) — a six-process coordinated entrant, bundled as v4_quorum.

See CHANGELOG.md for the full entry.

Stable v4 gameplay (unchanged from RC1)

bytefray-rules-4 remains the permanent, stable v4 gameplay Ruleset — spatial multi-process Agent API v2 combat, bounded local MOVE/READ/WRITE reach, deterministic seed-derived core placement, and fixed entrant quota Q=8. The spectator presentation suite (Perspective Cam, Spectator Director, Fight Night) and the seeded-placement evaluation methodology (schema 7) remain wired into the Designer's Simple/Advanced workflow, exactly as RC1 shipped them.

Downloads

Package	File	Notes
Python wheel	bytefray-4.0.0rc2-py3-none-any.whl	Pure Python 3.10–3.14 package; no pMARS binary
Source archive	bytefray-4.0.0rc2.tar.gz	Python/source workflows
Portable Windows applications	bytefray-4.0.0-rc2-windows.zip	AMD64 onedir apps: CLI, Agent Designer, Replay Viewer
Windows installer	Bytefray-Setup-4.0.0-rc2.exe	Administrative AMD64/x64 install; unsigned, see Installation
Self-contained Linux archive	bytefray-4.0.0-rc2-linux-x86_64.tar.gz	x86_64 onedir apps, built on Ubuntu 24.04, qualified on Ubuntu 24.04 + 26.04; no system Python required, see Linux installation
Checksums	SHA256SUMS.txt	SHA-256 values for all five assets above

Checksums

8bcfe7b0a79068489926b7f6b507a2180f97866bebd437950e08da569fcfdc3e  bytefray-4.0.0rc2-py3-none-any.whl
1f12df63254929b9d3d63974f766b92e791e03ee8ca2186396e6f09d3d294e2a  bytefray-4.0.0rc2.tar.gz
d63b0500a227520724ca7a4a45b896198ab23bc2439b0a6efd336f1cf1c5e536  bytefray-4.0.0-rc2-windows.zip
4dce9e5c2a07b99362e852bbea9139fcaa18bcc6500cc44863baaa12fffdc96f  Bytefray-Setup-4.0.0-rc2.exe
09c6986a9c16d5bf7e37d44bee1a9feea341ab27ec03e65f561d2da68b036a7e  bytefray-4.0.0-rc2-linux-x86_64.tar.gz

Windows asset note (2026-09-07): The two Windows assets above were completed after this release's initial publication. They are built from 1e22a6f, the exact commit the v4.0.0-rc2 tag points to — the same qualified candidate as every other asset in this release — but are a second build of that commit, not the original build. Bytefray's Windows packaging pipeline (PyInstaller onedir + Inno Setup + Compress-Archive) is not byte-reproducible (embedded build timestamps), a limitation already documented in this project's own RC1/RC2 Windows packaging qualification reports, so their checksums differ from values recorded in a pre-publication draft of this page and cannot be made to match. Source provenance is not in question: both files were rebuilt in a clean worktree pinned to 1e22a6f with git status verified clean throughout, and the fixed-seed v4_quorum vs v4_defender_scout reference match reproduced identically (winner=A, score={'A': 16.0, 'B': 10.0}, 11 ticks, last_agent_standing) against the rebuilt frozen bytefray.exe, in addition to build_win.ps1's own embedded GUI/CLI smoke tests, all passing.

Qualification summary

Built and qualified from a single frozen candidate source commit. Full source test suite green on both Windows and Linux, mypy clean on both canonical targets, and the fixed-seed v4_quorum vs v4_defender_scout reference match (winner=A, A=16.0/B=10.0, 11 ticks, last_agent_standing) reproduced identically across source, wheel, sdist, both frozen builds, and the portable Windows ZIP. The Windows installer compiles with correct RC2 metadata and an unchanged AppId; its live install/upgrade/uninstall lifecycle was not exercised this cycle (no admin-elevated session available), consistent with prior Bytefray release candidates.

Bytefray v4.0.0-rc1

Bytefray v4.0.0-rc1 — release candidate for v4.0.0.

This is a prerelease, not the final v4.0.0. Built from candidate source commit 3567026 and independently qualified on both Windows (full source suite, GUI suite, portable ZIP, installer install/upgrade/uninstall lifecycle, wheel, sdist) and Linux (packaged wheel/sdist install, native-Wayland Designer, Replay Viewer spectator modes, deterministic placement vectors, stable-v4/Alpha2 gameplay equivalence).

What's in stable v4

• Stable bytefray-rules-4 Ruleset and Agent API v2, promoted from the Alpha1/Alpha2 track
• Historical bytefray-rules-4-alpha1/-alpha2 identities preserved for existing agents/replays
• Agent API v1 (bytefray-rules-2) compatibility unchanged; fail-closed on invalid API/Ruleset pairings
• Evaluation methodology schema 7 (ruleset_v4_seeded_placements, arena 512, 8-seed/both-orientation matrix)
• Spectator Replay Viewer: Broadcast, Perspective, Director, and Fight Night modes

Assets

File	SHA-256
bytefray-4.0.0rc1-py3-none-any.whl	e5ec9b0f37f359dc46eeba4bbeeb7d396d737e1ba80541220a74ba408bbed5e3
bytefray-4.0.0rc1.tar.gz	3ee5631f425338d4eca75ddbf48cd2b11374e928159b404c9cf15362592a3fb8
bytefray-4.0.0-rc1-windows.zip	4c93c17ed22141406713772a502dcaf9c8a695a81dc813f03752d866f8fa6dab
Bytefray-Setup-4.0.0-rc1.exe	4f4756d297258b246150653e8aa29098677e24a7c512a74f525ee3c6cb110088

Verify with SHA256SUMS.txt.

🤖 Generated with Claude Code

Bytefray v4.0.0-alpha4 — Designer Spectator Integration

Alpha4 is a focused integration follow-up to Alpha3 spectator release. It makes Perspective Cam, Spectator Director, and Fight Night available through the normal Agent Designer workflow: run a v4 match from Simple or Advanced, then choose Open Replay. No v4 gameplay Ruleset or Agent API semantics changed.

The published v4.0.0-alpha3 assets were built before the Designer wiring below landed, so Simple/Advanced v4 matches did not yet produce the trace that Perspective Cam, Spectator Director, and Fight Night depend on. Alpha4 corrects that.

Fixed

• Designer Simple v4 matches automatically record spectator traces
• Designer Advanced v4 matches automatically record spectator traces
• explicit bytefray run --trace PATH support

Spectator controls

V / P    cycle perspective
1-9      select entrant
G        Spectator Director
N        Fight Night
?        help

Compatibility

• Ruleset v4 Alpha1 unchanged
• Ruleset v4 Alpha2 unchanged
• Agent API v2 unchanged
• replay schema 4 unchanged
• historical Ruleset v1/v2 preserved
• tracing is observational and does not alter canonical match identity

Packaged qualification

This release was verified against the actual built Windows artifacts, not just source: a real Simple-tab match (Ruleset v4 Alpha2, V4 Claimer vs V4 Concentrated Attacker) run through the packaged Agent Designer produced result.json, replay.jsonl, and trace.jsonl together, and the packaged Replay Viewer confirmed Perspective Cam, Spectator Director, and Fight Night all functioning against that trace.

The prior v4.0.0-alpha3 release remains published for reference; its assets are unchanged.

Bytefray v4.0.0-alpha3 — Spectator Intelligence & Perspective Cam

Bytefray v4.0.0-alpha3 — Spectator Intelligence & Perspective Cam

Bytefray v4.0.0-alpha3 introduces the v4 spectator presentation pipeline. Replay viewing now offers first-person entrant perspective modes, deterministic dynamic playback pacing, and contextual event feeds without altering canonical simulation determinism.

Highlights

• Perspective Cam (V / P to cycle, 1–9 direct select)

  • View matches strictly from an entrant's own delivered knowledge boundary under Agent API v2.
  • Anonymous Radar Contacts: Observed enemies appear as prominent gold CURRENT radar contacts and ghosted STALE rings with tick age (T-{age}). No synthetic enemy tracks, entrant IDs, process IDs, or continuity are inferred or displayed.
  • Own-Process Reach: Visualizes active process anchors and their local sensor reach boundaries.
  • READ Sample History: Displays historical memory cell sample tints, strictly separated from spatial contact identities.
  • Perspective-Safe HUD: Persistent opponent cards redact lifecycle state to UNKNOWN and core/score/territory/kills to ? placeholders during live viewing, revealing canonical values at the match terminal tick.
  • Perspective-Safe Capture Callouts: Reactive core-capture callouts suppress opponent-vs-opponent eliminations and strip killer attribution on own capture.

• Spectator Director (G to toggle)

  • Deterministic dynamic playback pacing that cruises smoothly through quiet exploration periods (up to 18 tps) and decelerates/holds during key combat events (disruptions, core damage, first contacts, eliminations).
  • Multi-entrant and Perspective pacing strictly respect the active entrant's knowledge domain.

• Fight Night Presentation (N to toggle)

  • Compact factual event ribbon anchored in the arena letterbox gutter showing recent contact, write, disruption, and elimination events with 2-, 3-, and 4-entrant presentation.

• Non-Intrusive Architecture & 100% Compatibility

  • Fixed-rate canonical Broadcast replay remains default. Replay playback functions independently with zero trace dependency, gracefully falling back to Broadcast mode if no trace is supplied.
  • Incremental PerspectiveCursor maintains (1)$ amortized per-frame performance.
  • Canonical simulation rulesets (bytefray-rules-4-alpha1 and bytefray-rules-4-alpha2), Agent API v2, and replay schema 4 wire shapes remain 100% frozen and bitwise compatible.

Release Qualification

• Full repository suite: 2,832 passed, 14 skipped, 2 deselected (313s)
• Focused spectator suite: 496 passed
• Static validation: ruff check . clean, mypy engine/src/battle_engine clean, mypy client/src/battle_client clean
• Packaging: Pure Python wheel (check_wheel.py validated), source tarball, and Windows portable AMD64 package tested across 2-, 3-, and 4-entrant matches.

---

Update: A follow-up release is available with the Agent Designer spectator integration fix: v4.0.0-alpha4. It makes the spectator features above available automatically from the Designer's Simple/Advanced workflow; this release's assets are unchanged.

Bytefray v4.0.0-alpha2 — Seeded Placement & Process Fairness

Bytefray v4.0.0-alpha2

Adds bytefray-rules-4-alpha2, a second v4 Ruleset identity differing from
bytefray-rules-4-alpha1 in exactly two gameplay semantics that the Phase 4
controlled gameplay study (~36,000 matches) identified as accidental rather
than designed.

What changed

• Seed-derived core placement. Entrant cores are placed from the match
  seed under a 64-cell minimum circular separation instead of a fixed
  evenly-spread seat layout, so own_core_base + arena_size / 2 is no
  longer a generally valid way to locate an opponent without observing
  anything. Derived from a SHA-256 counter stream, so placement is
  byte-identical across platforms and supported Python versions. Explicit
  --a-start/--b-start are still honoured exactly.
• Round-robin intra-entrant process selection. An entrant's own
  processes take action slots in rotation rather than always offering freed
  mid-tick quota to the earliest-declared eligible process. Quota
  allocation and redistribution are untouched: only which eligible
  process receives the next slot changes.

New agents hydra_alpha2 and nemesis_alpha2 acquire targets through the
Agent API v2 observation contract instead of the alpha1 placement
assumption; the historical hydra and Nemesis are unchanged.

What's unchanged

Agent API v2, replay schema 4, Q=8, core size, reach legality, the K=2
rotating entrant scheduler, disruption, and quota redistribution are all
unchanged. bytefray-rules-4-alpha1 remains available and explicitly
selectable everywhere a Ruleset can be named, for historical reproduction.
agents evaluate deliberately does not accept alpha2, since its placement
conditions are a disclosed evaluation-methodology axis that seeded
placement would contradict.

Known limitation

Global reach still provides whole-arena detection at no explicit cost, so
alpha2 removes the closed-form placement exploit but does not create a
reach economy. This is disclosed rather than treated as a last-minute
Ruleset change; it's the most likely subject of a future phase.

Compatibility

See docs/COMPATIBILITY.md,
docs/V4_ALPHA2_DESIGN.md,
and docs/V4_ALPHA2_PHASE5_QUALIFICATION.md
for the full contract, evidence, and release qualification record.

Packages

Package	Notes
Bytefray-Setup-4.0.0-alpha2.exe	Windows installer (admin, AMD64/x64)
bytefray-4.0.0-alpha2-windows.zip	Portable Windows onedir builds (all four executables)
bytefray-4.0.0a2-py3-none-any.whl	Pure Python 3.10-3.13 wheel
bytefray-4.0.0a2.tar.gz	Source distribution
SHA256SUMS.txt	Checksums for all of the above

This is a prerelease. We welcome gameplay feedback on the seeded placement
and process-fairness changes.