Release Notes

Each asset in the catalog now has an action menu: keep, ignore, flag for cleanup, or reclassify. You can also multi-select and act in bulk. BranchPy saves those decisions to your project and honours them on every re-scan — assets you marked as ignored stay out of the way.

Each section now shows a count and an issue count at a glance, so you can see where the problems are without expanding everything. Your open/closed choices are remembered for the session, and a Copy folder button on file-backed assets lets you jump straight to the right folder in your terminal or file manager.

You can now teach BranchPy which labels are entry points and which call-return patterns your project uses. Flowchart reads those settings directly, so the graph reflects your project's actual structure rather than relying solely on static analysis.

The enriched graph was silently showing an empty view in some project configurations. Fixed: the graph now correctly reads edge and node data from the analysis cache.

Opening VS Code with BranchPy installed no longer briefly flashes a command prompt window on screen. All background processes now run fully hidden.

The edge certainty breakdown has been removed from the Analysis panel. Edge certainty filtering is still available in the Filter panel, where it is consistent with the other filter controls. The Analysis panel now shows only graph metrics and node type breakdown.

Total Nodes and Total Edges in the Graph Metrics section now include an info tooltip explaining that BranchPy's counts include routing and system nodes added to represent flow structure, and inferred connections that may exceed the number of explicit jumps in your scripts.

The Select All button in the Filter panel now toggles node types, edge certainty, and edge styles together. The label updates automatically — it reads "Unselect All" when all filters are active, and "Select All" in any other state. Previously the button only affected edge style filters.

The flowchart now groups parallel story branches into self-contained blocks around the main story spine, making complex projects easier to follow. Note: very large projects (over ~800 nodes) still render in a mostly vertical layout — a path-aware algorithm for those is in development.

Scenes are now classified into three semantic lanes: Lane A (main narrative spine), Lane B (call detour sub-scenes), and Lane C (peripheral or synthetic nodes). Use the new Semantic Lanes filter panel to focus on any combination.

A new readability pass reduces crossing edges and enforces consistent spacing between nodes in each layer. On graphs with over 500 nodes, the pass is automatically skipped to keep the view responsive.

Call edges (teal solid) and return edges (violet dashed) are now extracted and rendered, showing exactly where subroutine calls go and where they return to. Previously only the jump destination was shown.

The flowchart now includes edges from screen action buttons (Jump/Call inside screen definitions) and Python script transfers (renpy.jump() / renpy.call() in $ expressions and python: blocks). These appear as distinct, filterable edge types in the Edge Types legend.

When all prerequisites are met (project analyzed, CLI up to date), Flowchart+ now opens the full interactive graph directly — no more placeholder. All layout and filter features from the standard Flowchart command are available.

A new certainty threshold control in Flowchart+ lets you filter edges by confidence: All, Weak+, Strong+, or Proven. Edges are classified automatically based on how BranchPy resolved each connection (static CFG → Proven; PFI-resolved → Strong; inferred → Weak; unresolved dynamic calls → Speculative).

Several edge cases that could produce empty or broken flowcharts have been fixed: cycles in the flow graph no longer cause the layout direction to reverse, and multi-root workspace handling has been improved.

If you signed out of one BranchPy account and signed into a different account on the same machine, the Control Center showed an error: 'Your device was recognised but BranchPy account setup did not complete.' This is now fixed.

Renaming a project in the Control Center previously updated the label but left the internal entry under the old name, causing mismatches with the CLI. Deleting a project left a stale entry in the CLI registry. Both are now fixed — the project list stays in sync between the extension and the CLI.

In some situations (no project active, CLI unavailable, or a slow network), the Doctor panel's loading indicator never cleared and the results never appeared. The panel now reliably shows check results — or a clear empty state — even when some checks cannot complete.

Items like BQF scan and Omega analysis are now labelled 'Needs Setup' instead of 'Warning', so you can see at a glance what is required versus what is recommended. Each card explains why the item matters and whether it is required for core functionality.

The vertical spacing between story branch rows has been reduced by half. Parallel branches and detour lanes now sit much closer to the main story spine, making the overall graph easier to scan without excessive scrolling. The main narrative path stays centered.

When Flowchart+ is ready (all prerequisites met), the panel now shows a clear notice: graph rendering is coming in a future release, and the interactive map is available through the standard Flowchart command in the meantime. Previously the panel showed a placeholder that could be read as a loading state rather than a scope boundary.

An experimental flowchart editing option that had no effect was visible in VS Code settings. It is now hidden until the feature is ready.

If the BranchPy CLI is not installed, the Welcome Hub panel now replaces its normal content with a dedicated screen showing the exact install command and a link to the installation guide. Previously the panel showed “You’re all set” even when the CLI was absent.

If a CLI version older than the extension is detected, a non-blocking banner appears with the version numbers and a one-click upgrade command. This prevents silent incompatibilities between the extension and CLI.

The Windows installer’s Add/Remove Programs entry and the standalone uninstall script were silently skipping CLI removal because they referenced the wrong package name. Fixed so uninstalling BranchPy also cleanly removes the CLI.

The Localization section of the Control Center now has Export and Import & Validate buttons alongside the existing Run Localization Audit button. Export saves all translatable strings to a structured XLSX workbook; Import & Validate opens a full preview of every change before writing anything.

After loading a translated workbook, a dedicated panel lists every row grouped by language: rows to update, rows with warnings (empty translations, source drift), and rejected rows (placeholder mismatches, unknown keys). Rows with errors are blocked until fixed in the spreadsheet. Rows with only warnings show an Apply with Warnings confirmation step.

Once translations are written, a toast shows the before/after coverage percentage for each language — for example ✅ L10n apply complete | French: 78% → 92% | View Report. Clicking View Report opens the updated Localization Coverage panel.

A timestamped snapshot of every .rpy file that will be modified is created in .branchpy/l10n/backups/ before the first write. If anything goes wrong, the backup is there to restore from.

New users see a Welcome to BranchPy panel on first launch. Select a Ren'Py project folder to get a local structure snapshot instantly — no account required. The panel adapts its content based on whether you are signed in and whether a project is already saved.

The Privacy Policy (section 9 — Cookies) has been updated to document two new first-party analytics cookies (bpy_utm_ft and bpy_utm_lt) that record which channel brought you to branchpy.com. No personal data, no browsing history — they expire after 30 days and can be deleted in your browser settings at any time.

The VS Code extension was missing a final identity-confirmation step after device approval on the Control Center login path. Both sign-in paths now complete this step before the login process finishes. If the confirmation fails, the session is safely discarded and a clear error is shown.

The VS Code Marketplace listing was showing broken image placeholders because the extension repository is private and GitHub raw URLs are not accessible without authentication. Screenshots are now hosted at branchpy.com/img/marketplace/ and load correctly for all users.

The CLI wheel, VS Code extension VSIX, and download page references are now consistently versioned at 1.1.22. No functional changes from 1.1.19–1.1.21 for end users.

BranchPy is now distributed as a standard Python package on PyPI. Run pip install branchpy-cli on Windows, macOS, or Linux to install the CLI, then run branchpy. The VS Code extension is published on the Marketplace and can be found by searching for BranchPy. The .exe installer remains available as a fallback for users who prefer it.

You can now tell PILOT which chapter or branch labels to start from, instead of always beginning at the default entry. Configure one or more entry labels in Control Center under Analysis Settings → PILOT. The report then shows a separate path count and percentage for each entry point, so you can compare coverage between chapters or routes side by side.

OMEGA was reading a condensed summary file that contains only totals, not the full path data. As a result, Paths seen, Variables seen, and State changes always showed zero even on projects with clear branching. OMEGA now reads the correct full-detail output. All counts are accurate.

The Stats panel includes a new Structure card that classifies your project as finite branching, loop-based, or hybrid, and shows a one-line plain-language summary. A coverage ratio indicates what proportion of your story's labels appear in the paths that were explored.

The Stats command has been optimised end-to-end. On a large project with over 1 000 script files, the total time dropped from around 17 seconds to around 3 seconds. Stats also no longer asks for confirmation before starting — it runs immediately.

The panel that appears when you try a feature requiring a free account has been fully rewritten. It now tells you exactly what you tried to do, what a free account gives you, and how to create one — with a single clear button. After clicking, the panel guides you back to VS Code and offers a one-click way to connect your new account.

When BranchPy blocks a feature in the terminal, the message now matches the VS Code panel: it explains what you are missing and links directly to the account creation page.

The analysis engine now stores internal calculation data in a protected location, separate from the results shown in the reports panel. The public report contains only the summary results relevant to you — not intermediate engine state. No workflow change is required.

The PILOT panel now reads a focused analysis output instead of the full internal report. Results load faster and the panel is more resilient to analysis edge cases.

Previously, the command opened a terminal and ran the BranchPy CLI's whoami command. That reads a separate CLI-only session file that the VS Code login never creates, so the result was always "No active session" even when you were clearly logged in. The command now reads the extension's own login state — the same data the Control Center uses — and shows your username, email, plan, status and session timestamp as a VS Code notification. No terminal is launched.

You no longer need to run the stats command separately before opening the Stats panel. Opening BranchPy: Show Stats now triggers the analysis, waits for it to complete, and then displays the results — the same way Insights and Pilot already work.

Results from Stats, Media Validation, and Tests are now saved in their own dedicated folders inside your project's .branchpy directory — .branchpy/stats/, .branchpy/media/, and .branchpy/tests/. These folders are created automatically on first run. They are safe to inspect and safe to delete (results are recreated on the next run). A copy is also kept in .branchpy/out/ during a short transition period for any tools that read that location. See: Where BranchPy stores data →

The stats pipeline has been optimised end-to-end. The analysis engine now reads each script file once instead of twice, uses a constant-time graph lookup instead of a full edge-list scan on every call, and replaces a quadratic label-search loop with a binary-search index built once. On a large project (1 128 files, 20.7 MB), total stats time dropped from 17 seconds to around 3 seconds.

After the performance improvements above, the pre-run time estimator was still producing a large estimate based on old calibration data, and showing a confirmation prompt before Stats could run. Stats now bypasses that prompt entirely and starts immediately. The estimator heuristic has also been recalibrated to reflect current performance for all other commands.

The save dialog completed without error but no file was created on disk. The CLI's default report path pointed to .branchpy/analyze/unified_report.json, which does not exist — the file actually lives at .branchpy/reports/unified/unified_report.json. The path has been corrected and the export file is now written as expected.

After running an analysis, the Insights panel was blank. The panel renderer had no branch for the Insights report format, which uses a distinct schema (story_health, variable_health, complexity, state_space, assets). A dedicated renderer now displays all five sections as a card summary layout.

Running bpy guard after initializing a project crashed with a "too many values to unpack" error. The internal scanner that reads variable assignments expected 4 fields per record but the CLI was returning 5. The unpacking has been corrected and guard now runs reliably from start to finish.

BranchPy: Show Identity and BranchPy: Export Media References could launch inside a stale terminal that still had a different project's virtual environment active. Both commands now always dispose any existing BranchPy terminal and open a fresh one rooted at the current project directory, so the correct environment is always used.

The panel header showed "Unknown Project" even when insight data was present. The project name is stored under runtime_metadata.project_path in the Insights file, not at the top level. The fallback chain now checks that field and the correct name is displayed.

Running export-media, journal or merge from the CLI produced an AttributeError immediately — the commands were not registered in the internal dispatch table and fell through to the wrong code path. All three are now routed correctly.

Running BranchPy: Run Guard on a project that had not been configured showed a raw CLI error. The command now detects the missing configuration, pauses, and shows an Initialize Guard dialog so you can set up gracefully without leaving VS Code.

Reads the latest .branchpy/insight_summary.json from your project and opens a summary panel in VS Code. Shows story health, variable health, complexity score, state space, and asset coverage at a glance — no terminal required.

Runs branchpy guard directly from VS Code. Guard checks for missing media references, unused assets, and variable consistency issues. If your project has not been initialized yet, the command detects this and offers a guided Initialize Guard setup dialog.

Shows who is currently logged into BranchPy. Runs branchpy whoami and displays the result in an integrated terminal.

Opens a format picker (CSV or JSON), a save dialog, then runs branchpy export-media to write the output file — all without leaving VS Code.

The Windows installer (install_branchpy.bat) detects whether BranchPy is already installed. Fresh installations walk you through setup and offer to run your first analysis immediately. Upgrades happen silently with a short what's-new summary — no questions, no manual uninstall required.

After running bpy analyze, the output now opens with a First Insight block — a short, specific summary in plain language: how many labels, which ones are unreachable (content players will never see), how many variables, and which are never reused (state that has no effect on the story). One sentence of interpretation follows.

Several panels that previously showed misleading placeholders have been corrected. Engine detection accurately reports its status. The Certificates and Cloud Hub panels are clearly marked as planned rather than active. Code actions that were not yet implemented now say so explicitly.

A clean removal command is now built into the CLI. It removes the Python package, VS Code extension, and optional local data — each step confirmed. After removal, an optional one-question feedback prompt helps improve the product. No data is collected without your action.

The VS Code extension now provisions a telemetry token when you sign in and writes it to your local auth file. The CLI reads this token automatically on upload, so usage data is correctly linked to your account without any manual setup.

AI features (Pilot, Omega AI explanations) are off by default. When you enable them for the first time, BranchPy shows a clear explanation of the additional packages needed and offers to install them. Enabling AI without the packages no longer fails silently.

The Image Validation panel now shows actual scan results from the CLI instead of demo data. When the CLI is unavailable, an amber banner is displayed. The Open button has been replaced with Reveal, which highlights the file in your file explorer.

Running branchpy --project /path image-validate previously ignored the --project flag and scanned the current directory instead. It now always targets the correct project.

Image validation could scan your current working directory instead of the project you specified. It now always targets the right project, whether you run it from the terminal or from the VS Code panel.

The doctor command crashed when running media and health checks on a project. It now completes all checks reliably and reports results correctly.

An issue prevented usage data from reaching our servers. Telemetry now works reliably, which helps us understand how BranchPy is being used and prioritise improvements.

The flowchart engine now understands your story's structure — it detects the main narrative spine, groups related scenes together, and arranges branches in a way that makes large, complex visual novels much easier to read. No configuration needed; it adapts automatically to your project.

When your script uses call and return to navigate between labels, those paths are now shown in the flowchart as distinct edge types. You can see at a glance which scenes call into others and where control returns.

Media Validation now groups unreferenced files into three buckets: safe to remove, needs a closer look, and possibly loaded at runtime — do not delete. Each file gets a confidence rating so you can make informed decisions rather than guessing.

During the beta period, creating a free account and claiming the Ren'Py Free license gives you access to all BranchPy commands. No payment required to explore the full tool.

Several small issues in the VS Code extension were cleaned up, including better compatibility with Safari and improved accessibility across panels.

We added a clear statement to the homepage confirming that BranchPy's core analysis runs entirely on your machine and produces the same result every time. No AI is involved unless you choose to connect one.

Some pages previously used language that implied AI was built into BranchPy. We updated those to make clear that AI integrations are entirely optional add-ons, not required to use the tool.

The FAQ now explains that if you do use an optional AI integration, it works with your own API key — we never hold or proxy your credentials.

You can now create an account on branchpy.com and apply to join the early access program. Early testers get to shape what gets built next.

The official BranchPy website launched with account creation, early access applications, and documentation.

Full privacy controls are available from day one: you decide what data you share, whether to participate in the community, and you can delete your account at any time.

BranchPy was run against community Ren'Py projects with thousands of files. Several edge cases were found and fixed, making the tool noticeably more stable on complex projects.

The background process that powers the VS Code extension was improved. It starts up more quickly, uses fewer resources while idle, and shuts down cleanly.

Groundwork was laid to allow BranchPy to work with multiple projects open at the same time without them interfering with each other.

The command-line tool, VS Code extension, and analysis engine were brought together into a single coherent experience. Commands, results, and error messages are consistent no matter how you run BranchPy.

When BranchPy finds a problem in your project, the messages it shows are now more specific and easier to act on.

Command references, help text, and examples were aligned so you always get the same information whether you look in the CLI, the extension, or the docs.

BranchPy can now find scenes and labels in your script that can never be reached — whether due to missing jumps, dead-end branches, or labels defined but never called.

The foundation for visual story maps was built. The flowchart feature started here, turning your script structure into something you can actually see.

The analysis engine was rebuilt to be modular — new checks and rules can be added without touching the core, making BranchPy easier to extend over time.

BranchPy is now available as a VS Code extension. Install it and run analysis, media checks, and flowchart generation directly from your editor — no terminal required.

The extension detects your Python installation and configures itself automatically. You should be up and running without manual environment setup.

Early access testers can activate their license directly through VS Code. Clear error messages guide you through any setup issues.

Scans your project for images, sounds, and other assets that are imported but never used, helping you clean up your project and reduce build size.

Added comprehensive support for common Ren'Py asset formats including PNG and WebP images, and OGG and MP3 audio files.

Began the integration between the command-line tool and VS Code extension, allowing you to run analyses from within your editor.

Automatically identifies when your Ren'Py scripts reference images or sounds that don't exist in your project, preventing runtime errors.

Improved robustness by correctly handling file paths containing spaces and returning meaningful exit codes for use in build scripts and CI/CD pipelines.

Redesigned the command-line interface with a modular architecture, making it easier to add new analysis commands and maintain existing ones.

Enhanced the built-in help system with clearer command descriptions, usage examples, and summary outputs that are easier to read and understand.

Standardized command-line arguments across all commands, ensuring a consistent user experience and reducing the learning curve for new users.

Generate detailed reports showing all story labels, navigation jumps, function calls, choice menus, and variables used throughout your Ren'Py project.

Automatically finds broken story navigation where jumps or calls point to non-existent labels, and identifies labels that can never be reached by players.

Export your story structure as DOT format graphs that can be visualized with Graphviz, helping you see the overall flow of your visual novel.

The initial release that could parse Ren'Py script files (.rpy) and identify common navigation issues like missing jump targets and labels that are never used.

Provided simple summary reports showing file counts, label counts, and detected issues, giving developers a quick overview of their project's health.