BeeWare: The Buzz

September 2026 Status Update

russell@beeware.org (Russell Keith-Magee) — Thu, 01 Oct 2026 00:00:00 +0000

In September, we've been focused on preparing for the impending release of Python 3.15, as well as adapting to updates in Xcode and Android Studio.

What we've done¶

We dropped support for Python 3.10 across BeeWare's projects and templates, adding support for Python 3.15 in its place.
We prepared for a new Chaquopy release. The actual release is dependent on the release of CPython 3.15.0, and will also include support for the latest Android Studio and Android SDK releases.
We substantially improved xbuild, BeeWare's PEP 517 build frontend for cross-compiling wheels. The updates add the ability to automatically fetch a Python install for a target platform, a full test suite, and an xpython command for running arbitrary code in a cross-platform environment.
We switched Briefcase's iOS support to use xbuild when creating cross-platform virtual environments. This also allowed switching to using the official CPython iOS binary release.
We modified Briefcase to support changes in Xcode 27, including the new Device Hub.
We added hash verification for Briefcase's asset cache, protecting against cache poisoning if a build machine is compromised.
We added support for limiting Windows MSI installer options to a specific install scope.
We added automatic device selection for iOS and Android, so briefcase run can select (and create, if needed) an appropriate default device without user intervention.
We migrated Briefcase's use of httpx to httpx2, following the shift in maintenance focus in the HTTP client ecosystem.
We dropped Briefcase's built-in support for Pygame, in favor of the actively maintained Pygame-CE, which ships its own Briefcase plugin.
We updated Toga iOS's backend to support the Scene-based application life cycle required by the iOS 27 SDK.
We migrated Toga's GTK, Cocoa, WinForms and Textual backends to use platformdirs for app-specific paths, improving support for unusual user-space platform configurations.
We continued hardening our GitHub Actions workflows, adopting zizmor and adding Dependabot cool-off delays on several repositories.
We fixed a bug where encoding_for_ctype() raised an undocumented AttributeError instead of ValueError for unknown C types.
We ensured Briefcase doesn't derive an invalid Python keyword as an app's class name, rejected bundle identifiers containing a trailing newline, and logged captured output when a non-streamed subprocess call fails.
We switched the Windows Visual Studio template to be compatible with Visual Studio 2026.
We refreshed Toga's iOS testbed, expanding the range of test devices and configurations where the testbed suite will pass.
We added a documentation guide covering the expired system certificate issue affecting macOS code signing.
We highlighted the existence of project-specific contribution guides at the top of BeeWare's general contribution guide.

Much of this work is due to the contributions of members of the BeeWare community. Thanks to Abdo (@abdnh), Deepak Thorat (@deepak25000000), Felipe Medici (@femedici), Hyuri (@hyuri), Jenish Gajera (@jenish0908), Joshua King (@jkingok), Mgs. Tabrani (@mgstabrani), Roshan Ramani (@rawsun007), @Rayan-and-beyond, Revar Desmera (@revarbat), Tanya Schlusser (@tanyaschlusser), @TianHengZhuang, and Xiaowen (@Xiaowen-Yang) for their code and documentation contributions this month.

What's next?¶

The final release of 3.15.0 is days away; once that release is out, we'll be able to make a Chaquopy, Briefcase and Toga release. We also want to explore whether cibuildwheel can make use of xbuild.

Once that work is completed, we're expecting to turn our focus back to Toga. We've made some progress against the "big picture app navigation" plan that we published at the start of the year; once the 3.15 release is behind us, we will be able to focus on delivering that plan, and adding other exciting features to Toga.

Want to get involved?¶

Want to get involved? We curate issues that should be approachable for first-time contributors to BeeWare. They're all relatively minor changes, but would provide a big improvement to the lives of BeeWare users:

If you're interested in the tooling for deploying applications to various platforms, take a look at Briefcase.
Or, if you're interested in GUI widgets, take a look at Toga.

These lists can also be filtered by platform - so you can find issues that are specific to your preferred operating system. Pick one of these tickets, drop a comment on the ticket to let others know you're looking at it, and try your hand at a PR! We have a guide on setting up a Briefcase development environment; but if you need any additional assistance or guidance, you can ask on the ticket, or join us on the BeeWare Discord server.

August 2026 Status Update

russell@beeware.org (Russell Keith-Magee) — Tue, 01 Sep 2026 00:00:00 +0000

In August, we made some major improvements hardening the security of BeeWare's tools, and attended PyCon AU 2026.

What we've done¶

We attended PyCon AU 2026, where we presented two talks and a workshop. Videos of the talks should be available on YouTube in the very near future.
We added support for using Conda as an environment manager to Briefcase.
We added hash verification for all of Briefcase's tool downloads and template downloads.
We added support for signing Linux system packages with GPG identities.
We ensured that Briefcase generates valid SPDX license identifiers for Proprietary and Other license options.
We improved the error messages shown when an Android app fails to install.
We updated the Android Gradle template to target API level 36, keeping apps compliant with the Google Play requirements that come into force at the end of August.
We added signal handler initialization to the iOS, Linux, macOS and Windows templates.
We corrected macOS toolbar handling in Toga.
We added user-space path anchors (desktop, documents, downloads and pictures) to Toga's path API.
We made Toga respect local environment configuration when determining app file storage on Linux and Windows.
We improved the documentation of widget style properties.
We fixed variable substitution in python3.pc for Android in CPython.
We updated the Android Python versions and improved Meson tests in cibuildwheel.
We modified the way SQLite is compiled for Android to better match CPython's requirements.
We fixed the display of 404 page assets on Read the Docs.
We corrected an issue with switching languages in BeeWare documentation content.
We continued hardening our GitHub Actions workflows, adding zizmor security scanning across many of our repositories, and consolidating our Dependabot configuration with cool down periods and multi-ecosystem grouping.
We added verbose Briefcase logging to debug-mode CI reruns.
We refreshed the project configuration for Colosseum,
We did some spring-cleaning of Cricket, getting the project running on a recent version of Toga.

Much of this work is due to the contributions of members of the BeeWare community. Thanks to Rahul Patel (@100jinwoo001), Alex V (@AlexVerrico), Aruna Selvam (@Aruna-Mani), Aronnax (@aronnaxlin), Ashton Lane (@Ashton321), Dipendra Paudel (@BabuDip), @bilgituncay, DawnWang (@dawnwang3692), Jainam h.maru (@Dev9269), @Georgefifth, Ivan Shamoon (@IvanShamoon), Jenish Gajera (@jenish0908), John (@johnzhou721), Jasmeen Kaur (@KAUR1984), Loi Nguyen (@lntutor), Mgs. Tabrani (@mgstabrani), Luis Palacios (@moondial-pal), Phyo Pyae Sone (@phyodev), Nishchaya Sharma (@shinzoxD), Siddhant Bayas (@siddhant-bayas), Stan Ulbrych (@StanFromIreland), and Harsh Kumar (@thisisharsh7) for their code and documentation contributions this month.

What's next?¶

In September, our focus will be on the upcoming Python 3.15 release. In addition to the basic housekeeping of updating CI configurations, we need to make some updates to support the latest Android SDKs, and get the xbuild tool to a point where it can be used to manage cross-platform builds. We're also hoping to contribute SBOM configurations for CPython on iOS and Android, as part of the wider ecosystem trend to clearly documenting upstream dependencies.

Want to get involved?¶

If you're interested in the tooling for deploying applications to various platforms, take a look at Briefcase.
Or, if you're interested in GUI widgets, take a look at Toga.

July 2026 Status Update

russell@beeware.org (Russell Keith-Magee) — Mon, 03 Aug 2026 00:00:00 +0000

In July, we added uv support to Briefcase, landed some patches for mobile support in some major Python projects, and welcomed a new member to the BeeWare core team.

What we've done¶

We welcomed Oliver Leigh to the core team, in recognition of his ongoing contributions to Toga's WinForms backend.
We attended EuroPython, where Malcolm Smith spoke about supporting Android and iOS in Python packages.
We continued the rework of Briefcase's environment management, adding isolated virtual environments for each app,and support for using uv to manage app environments. Support for using Conda to manage app environments is in the final stages of review.
We finalized Android and iOS support in NumPy. Android and iOS have now been accepted as Tier 3 supported platforms in NumPy.
We contributed iOS support for contourpy and kiwisolver.
We resolved a long-standing issue with the stability of the iOS simulator on GitHub Actions.
We exposed macOS app lifecycle notifications as hooks, giving app authors a way to respond to native lifecycle events such as activation, hiding, and termination.
We finalized Toga's switch to libgirepository 2.0, formally deprecating support for Debian 12 and Ubuntu 22.04.
We added a new WinForms event loop implementation that dramatically improves the performance of Windows apps.
We fixed a cluster of WinForms DPI scaling problems, including issues with Canvas scaling, some DPI scaling bugs, and incorrect divider positioning.
We extracted the Microsoft WebView2 binary components out of toga-winforms into their own package.
We added system-pyside6 integration for Toga's Qt backend, allowing Toga to follow the operating system's theme on Qt-based Linux desktops.
We fixed keyboard dismissal on input widgets on iOS.
We added a testbed probe for the Textual backend, allowing automated testing of that backend.
We started implementing Toga's new Scaffold layer. This is the start of the "Big Picture app navigation" design that we published earlier this year.
We corrected an issue with shut down event handling in Rubicon ObjC.
We removed a vestigial logging handler left over from the NSLog to os_log migration in the iOS Xcode template.
We added support for creating a desktop shortcut for Windows apps.
We fixed an MSI packaging bug where shortcut descriptions longer than 256 characters would break the installer.
We added a fix for the "Mark of the Web" problem with Windows apps distributed as ZIP files.
We replaced flake8 and isort with Ruff in Briefcase's project template.
We started hardening our GitHub Actions workflows, adding zizmor security scanning across many of our repositories, consolidating our Dependabot configuration with cool down periods and adding multi-ecosystem grouping.
We added Ukrainian translations of the BeeWare website.
We reworked the success stories page on the BeeWare website, and added a new success story from Juno.

Much of this work is due to the contributions of members of the BeeWare community. Thanks to Rahul Patel (@100jinwoo001), Abdo (@abdnh), Oluwatoyosi Peter Abolaji (@abj360), @alex-indi, Michaela Dušková (@amfibio), @armorbreak001, Andrew Barnes (@Bortlesboat), @ColumbusLabs, Daniel Del Rio (@ddelrio1986), Dresden (@DresdenGman), @emerardd, Jan Koprowski (@jankoprowski), @jlonsdalen, John (@johnzhou721), Kevin Turcios (@KRRT7), Aleš Laník (@Krumca97), Robin (@lrandersson), Jonathan (@mgalore), Mgs. Tabrani (@mgstabrani), Matt Van Horn (@mvanhorn), Rohit Madhavan (@ROHITCRAFTSYT), Shaurya Srivastava (@Shaurya2k06), @Solaris-star, Sneha (@suscripty), Likhitha J (@TensorDevLJ), Thomas Nguyen (@thomxsnguyen), and xintao (@xintao0312) for their code and documentation contributions this month.

What's next?¶

In the coming month, we'll be looking at Briefcase's handling of downloads. The main improvement will be adding support for hash verification of downloads. We're also hoping to develop a better workflow for bootstrapping a Briefcase installation, especially in tutorial situations.

We will also be performing some updates to Toga's Android backend. Android SDK 36 introduced some changes to the visual layout of apps. Until recently, we've been able to work around these issues. By the end of August, Google will require all apps to be fully compliant with SDK 36 to be submitted to the App Store.

At the end of the month, we will be attending PyCon AU, where we'll be presenting a workshop on building cross-platform GUI apps, plus talks on mechanisms for distributing Python code and switching your project documentation from Sphinx to Markdown. We'll also be there for the Development Sprint day. If you're able to make it, make sure you say hello!

Want to get involved?¶

If you're interested in the tooling for deploying applications to various platforms, take a look at Briefcase.
Or, if you're interested in GUI widgets, take a look at Toga.

We'll be at PyCon AU 2026!

russell@beeware.org (Russell Keith-Magee) — Wed, 29 Jul 2026 00:00:00 +0000

Russell, Katie and Kattni will be attending PyCon AU 2026 from August 26 - August 30, 2026!

PyCon AU is the national conference for everyone using the Python Programming Language.

Hosted annually since 2010, this event brings the national and international Python community together.

You can find us throughout the event:

Russell will be giving a talk entitled How to give your Python code to someone else.
Kattni will be giving a talk entitled Switching from Sphinx to Markdown.
Russell, Katie and Kattni will be hosting a sprint.
Russell, Katie and Kattni will be hosting a tutorial entitled Build a cross-platform GUI app with Python.
Katie will be hosting the DevRel Specialist Track.

Please come say hello, we'd love to meet you. We're looking forward to seeing you there!

2026Q3 Roadmap

russell@beeware.org (Russell Keith-Magee) — Wed, 22 Jul 2026 00:00:00 +0000

We've made a lot of progress in Q2. However, much of that progress wasn't in areas that we were fully anticipating, and we didn't make as much progress in some areas where we were hoping to. As always, this roadmap should be read as a guide to what we aim to focus on over the coming quarter, rather than a hard commitment to features that will be made available on a specific deadline.

Q2 progress¶

In Q2, we were able to make a number of key improvements to Briefcase's Windows packaging tools. We added support for Windows on ARM64; and we added a number of features to MSI installers, including improved customization options for installers, pre-install checks for .NET and minimum Windows versions, options for creating desktop shortcuts, and improved behavior for post-install and pre-uninstall scripts.

We're most of the way through a major rework of Briefcase's environment handling. This will allow us to provide options for using uv and conda for building Briefcase apps, and will provide more repeatable environments for app creation. This will form the basis of work required to support iOS on Python 3.15, and will provide a foundation for supporting lock files. We're expecting this work to be completed in the coming weeks.

We also launched our first (and second!) community call. We're hoping to maintain a monthly cadence on those calls on the second Thursday of the month. That call occurs at a time that isn't really convenient for Europe; once we've got the format established, we're hoping to add a second call to provide an opportunity for European users to participate.

Unfortunately, we didn't make much progress on the "Big Picture" widgets in Toga. There's an in-progress branch for some of the refactoring needed to support this work, but that work is very preliminary at this stage. We were also unable to make any progress on live reloading for iOS apps.

However, we have been able to make a lot of unanticipated improvements. We've made a number of key improvements to Briefcase's macOS 26 support, including some major changes to the way logs are handled, and resolving a long standing issue with the stability of the iOS testing environment on GitHub Actions. We've made some significant improvements to Briefcase's publication commands, making the process of publishing macOS apps in a CI environment much easier. We've resolved some long-standing issues with Windows event loop integration in Toga, and completed a major reorganization of Toga's Canvas API to provide better alignment with the HTML5 canvas API.

We've also been able to finally land support for both Android and iOS in NumPy - both are now Tier 3 supported platforms in NumPy. This is the culmination of work that has taken over a year, and required updates in a huge number of projects, including cibuildwheel, meson, and meson-python.

The discrepancy between our Q2 Roadmap goals and our Q3 goals is primarily caused by the nature of Open Source development. In a commercial environment, it's possible to have a relatively clear picture of the available resources and priorities. While unexpected events do sometimes alter plans, those events are just that - extraordinary. In an Open Source project, they're completely ordinary. We're constrained by the resources that are volunteered by contributors, and the areas where those contributors focus their contributions. That makes the planning process much less predictable.

Q3 priorities¶

In Q3, our primary focus will be on supporting the upcoming Python 3.15 release. The inclusion of official iOS binaries in Python 3.15 requires some small changes in how Briefcase builds iOS applications; we're hoping those changes will also be accepted as part of cibuildwheel. On the Android side, there's updates required to add support for the Android 36 SDK. There's also updates and testing required to support Python 3.15 for macOS, Windows and Linux; plus updates to our CI configuration to support new images (like Ubuntu 26.04), and migrate off older images (like macOS 14).

We're also going to spend some time improving the security posture of BeeWare's tools. At present, Briefcase doesn't perform any validation of downloads. We're planning to add hash-based download validation, as well as configuration options that completely prevent Briefcase from initiating downloads so that security hardened environments are able to audit what is being downloaded. Although we're tackling this to provide more secure app builds, the same approach can be used to improve the experience in tutorials by providing a mechanism to "bootstrap" a Briefcase environment when download bandwidth is limited.

We will also be attending PyCon AU, where we'll be presenting a workshop on building cross-platform GUI apps, plus talks on mechanisms for distributing Python code and switching your project documentation from Sphinx to Markdown. We'll also be there for the Development Sprint day. If you're able to make it, make sure you say hello!

Longer term goals¶

In Q1, we published a plan for "Big Picture" app development. Executing on that plan remains our primary long term goal. We're hoping that toward the end of this year, we'll be able to focus more on features in Toga that enable users to build interesting mobile and desktop apps. As part of that effort, we're hoping to show off more apps ourselves - both to demonstrate the capabilities of BeeWare's tools, and to provide example apps that others can use to learn how to use BeeWare's tools better.

Along the way, we're not going to ignore Briefcase. Briefcase already solves a number of key distribution problems in the Python ecosystem; but there's a lot of opportunity to further improve alignment with Python ecosystem standards, simplify the process of developing apps, and streamline publication of apps into app stores.

We'll be at PyOhio 2026!

kattni@beeware.org (Kattni) — Mon, 20 Jul 2026 00:00:00 +0000

Kattni will be organizing PyOhio 2026, which will happen from July 25 - July 26, 2026!

Philip will also be attending.

PyOhio is the Python Community Conference Based in Ohio. The 19th annual PyOhio is at the Cleveland State University Student Center in Cleveland, OH.

PyOhio is FREE to attend thanks to the generous support of sponsors and individual donors.

Please come say hello, we'd love to meet you. We're looking forward to seeing you there!

June 2026 Status Update

russell@beeware.org (Russell Keith-Magee) — Wed, 01 Jul 2026 00:00:00 +0000

June saw a major push on logging support for macOS 26, a continuing overhaul of Toga's Canvas API, as well as many other improvements.

What we've done¶

We hosted our first "The Buzz: Live" community call!
We migrated Apple platform logging from NSLog to os_log, as macOS 26 now marks NSLog content as private. This required Briefcase to adopt the os_log-based logger, updates to the macOS Xcode template, the Python support testbed, and upstream in CPython.
We refined the encoding of ASCII NUL characters in std-nslog.
We refactored Briefcase's handling of virtual environments, providing a cleaner interface for creating Python environments. This is the start of a larger piece of work adding support for using alternative environment managers - such as uv, Conda, or Pixi in Briefcase projects.
We added support for automatically resuming an interrupted macOS notarization, including the ability to avoid waiting for the macOS notarization response. These changes make it much easier to notarize a macOS app in a CI environment.
We added support for post-install scripts in macOS PKG installers.
We added support for enforcing a minimum OS version.
We made MSI installers more resilient when uninstalling an application that is currently running.
We improved the validation of Briefcase application names.
We added warnings to guard against project paths that are known to cause problems.
We added a warning when an app description exceeds the recommended length.
We added the ability for Linux applications to provide a custom man page.
We added validation that the requested Flatpak base is installed before building an app.
We modified how Briefcase asks questions so that if there's a single option, that response is provided as a default answer.
We documented how to generate a self-signed Windows code signing certificate.
We finished rolling out the use of Briefcase's warning banner helper, ensuring that warnings in Briefcase are consistently formatted.
We continued aligning Toga's Canvas widget with the HTML5 Canvas API, deprecating write_text in favor of fill_text and stroke_text, turning the transform methods into states, adding keyword parameters to Canvas.state(), and more clearly delineating between the Canvas API levels in the documentation.
We corrected a number of issues with Toga's Canvas implementation, including fixing an issue with reset_transform on Cocoa and iOS, issues with DrawingAction color aliasing logic, an inconsistency in the default Canvas stroke width, and the handling of line dashes on Qt Canvas objects.
We updated toga-chart to use the revised Canvas API.
We corrected the colors used on Button widgets, DetailedList widgets and WebView widgets on Windows.
We migrated the documentation for Podium and Toga Chart to Markdown and MkDocs.
We corrected some issues with how project-specific additions to our contribution guide are rendered in the documentation of Briefcase, Toga and rubicon-objc.
We fixed the ds_store CLI, and improved the rendering of .plist blob values in the ds_store CLI output.
We landed a round of Android fixes in cibuildwheel, updating to current Python versions and removing a testbed patch.
We added an "Available for hire" page to the BeeWare website.
We added Vietnamese and Tamil translations of the website.

Much of this work is due to the contributions of members of the BeeWare community. Thanks to Abdo (@abdnh), Aniruddha Nalawade (@aniruddhanalawade24-beep), Christian Clauss (@cclauss), @haikesan, Haya Asif (@haya-asif), John (@johnzhou721), Kevin Turcios (@KRRT7), Labib Bin Salam (@Labib-Bin-Salam), Luis Gómez Gutiérrez (@lucuma13), Luis Palacios (@moondial-pal), Oliver Leigh (@Oliver-Leigh), Sai Asish Y (@SAY-5), Shannon (@shannonmcin), sky (@skyswordw), Darryl Wang (@Tridwoxi), Yousuf Khan (@Yousuf24100286), and KBS (@youdie006) for their code and documentation contributions this month.

What's next?¶

We're currently doing our planning for Q3; we'll be publishing those plans in the coming weeks. However, it's safe to assume that a lot of our time will be consumed with preparations for the Python 3.15 release in October. The availability of official iOS installers will require some changes to Briefcase; the annual cycle of Android Studio releases will also require testing and verification. There are also some lingering issues with GitHub Actions macOS testing and macOS 26 support that we need to address. Lastly, we're hoping to spend some time focusing on security, adding download checksum validation to Briefcase, and possibly adding SBOM support for CPython's iOS and Android releases.

We'll be at EuroPython in July, where Malcolm Smith is presenting on supporting iOS and Android in Python packages; we'll also be at PyCon AU, where Russell Keith-Magee will be speaking about packaging Python code for distribution, and Kattni will be speaking about switching from Sphinx to Markdown. You can also Join us on Discord on July 9 at 11PM UTC (7PM EDT, 4PM PDT, 9AM AEST).

Want to get involved?¶

If you're interested in the tooling for deploying applications to various platforms, take a look at Briefcase.
Or, if you're interested in GUI widgets, take a look at Toga.

We'll be at EuroPython 2026!

smith@chaquo.com (Malcolm Smith) — Wed, 01 Jul 2026 00:00:00 +0000

Malcolm will be attending EuroPython 2026 from July 13 - July 19, 2026!

EuroPython is a week of talks, tutorials, sprints, and community. Join 1,500+ Pythonistas in July, in Kraków, Poland 🇵🇱.

You can find him throughout the event:

He will be giving a talk entitled Supporting Android and iOS in your Python package.
He will be hosting a sprint.

Please come say hello, he'd love to meet you. He's looking forward to seeing you there!

May 2026 Status Update

russell@beeware.org (Russell Keith-Magee) — Mon, 01 Jun 2026 00:00:00 +0000

May was dominated by PyCon US, where the BeeWare team ran another successful sprint, resulting in a number of improvements - many from first time contributors.

What we've done¶

We presented 2 main track talks at PyCon US - one on mechanisms for distributing Python code, and one on switching your project documentation from Sphinx to Markdown. We also presented at the Web Assembly Summit, and Packaging Summit.
We rolled out a series of updates to our GitHub Action workflows, simplifying our use of Dependabot, and adding some improvements to help users identify if they haven't filled out our PR template or provided a Towncrier change note.
We adopted the use of our new warning banner helper throughout the Briefcase repository, replacing the existing banners.
We improved Briefcase's validation of bundle identifiers, allowing single-dot bundle IDs while still rejecting invalid ones.
Now that Python.net supports Python 3.14, we have removed the warning in the BeeWare tutorial that advised against using Python 3.14 on Windows.
We modified Toga's Canvas widget to expose drawing-context attributes (fill_style, stroke_style, line_width, line_dash) along with save/restore methods, continuing the alignment with the HTML5 Canvas API, and completed a comprehensive revamp of the documentation of the Canvas widget.
We implemented dark mode detection in Toga for iOS, web, and Windows.
We addressed some reliability problems with Toga's app-level dialogs on macOS 26.
We modified Toga's Window initialization process to ensure event handlers exist before the underlying widget is constructed.
We added keyboard toggling for nodes in the Toga's WinForms Tree widget.
We modified the handling of static HTML content in the Android WebView, fixing a rendering problem observed when content contained characters such as #.
We improved Toga's GTK MapView handling of null values.
We corrected an issue with the Toga testbed app that caused tests to fail if the user had multiple monitors.
We documented the limitations of OptionContainer on mobile platforms.
We ensured Toga's codebase checks for default encoding warnings, and corrected some examples where encoding wasn't being explicitly specified.
We improved the resilience of Toga's WebView tests under Qt.
We migrated Briefcase's project template to include a Markdown README.
We improved the BeeWare overview page with details about the platforms that BeeWare supports.
We corrected a configuration issue that broke compilation of Python for iOS on macOS 26.
We landed the cibuildwheel improvements needed for building NumPy and related packages on Android, and added Android support to auditwheel. Together, these are the foundation that will let cibuildwheel build a much wider range of scientific-Python wheels for Android.

Much of this work is due to the contributions of members of the BeeWare community, many of these users contributed at the PyCon US Sprints. Thanks to Abdo (@abdnh), Abdur-Rahmaan Janhangeer (@Abdur-rahmaanJ), @AJTheDataGuy, @albertchae, Aman Sachan (@AmSach), Aqil Aziz (@aqilaziz), @atuseract, Audrey Dang (@audreydng), Campbell (@ceggy91), @changquan, Andy P Fundinger (@Ciemaar), @drewRB, Chris Patti (@feoh), Grant Wang (@gwdio), Michael Wilson (@hyperboloid), Ian Dolge (@iandolge), Joel Peter (@joelpeter-c), John (@johnzhou721), Jorge (@jvigueras), @lihua-xinghun, Matthew Wygal (@matthew-wy), Miro (@Mirochill), Jeong Kim @mrds555, Matt Van Horn (@mvanhorn), @Nando301, Oliver Leigh (@Oliver-Leigh), Taiwo Osunrinde (@osunrinde), Puneet Dixit (@puneetdixit200), Robert J Spencer (@Rjvs), @Rowlando13, Shannon (@shannonmcin), Darryl Wang (@Tridwoxi), @tylerboutwell, Vinicius Gubiani Ferreira (@vinigfer), and David_C (@YuDavidCao) for their code and documentation contributions this month.

What's next?¶

On the technical front, in the coming month, we'll also be looking into options for updating code in a running app; and continuing work on the "big picture" app navigation plan published earlier in the year. If time permits, we'll begin investigations into the use of Conda environments in Briefcase apps.

We're also planning to step up our efforts to build the BeeWare community. We've developed a reputation at PyCon US for running extremely effective sprints; but we need to do more of that outreach for people who can't make it to PyCon. We've already begun doing an audit of our outstanding issues in the hope of curating a more actionable list of work for contributors; and we're going to start being more active on social media, including reaching out to more social media channels. We're also going to host our first Community Call - a monthly live video event where members of the core team and community members can share what they've been working on. Join us on Discord on June 11 at 11PM UTC (7PM EDT, 4PM PDT, 9AM AEST) (and yes - we're planning to add calls at other times more convenient for European and Asian audiences).

Want to get involved?¶

If you're interested in the tooling for deploying applications to various platforms, take a look at Briefcase.
Or, if you're interested in GUI widgets, take a look at Toga.

These lists can also be filtered by platform - so you can find issues that are specific to your preferred operating system. Pick one of these tickets, drop a comment on the ticket to let others know you're looking at it, and try your hand at a PR! We have a contribution guide; but if you need any additional assistance or guidance, you can ask on the ticket, or join us on the BeeWare Discord server.

April 2026 Status Update

russell@beeware.org (Russell Keith-Magee) — Fri, 01 May 2026 00:00:00 +0000

April saw some extremely important improvements to BeeWare's Windows support, and some important new policy decisions.

What we've done¶

We formally adopted an AI and Autonomous code contribution policy. This policy is neutral on whether AI tools can be used for contribution, but clearly places the responsibility on a human contributor to take full responsibility for the output of any tool they use, and to declare if AI tooling has been used.
As part of adopting a format AI usage policy, we've added an AGENTS.md file, and a Spec Kit constitution to Briefcase, Toga, and Rubicon ObjC. We expect we'll be tweaking and tuning those configurations over time as we discover what does (and doesn't) work. If you've got experience in developing these foundational AI configuration files, we'd appreciate any suggestions or feedback you may have.
You can now build native ARM64 Windows binaries and installers with Briefcase.
We added support for detecting if .NET is installed as part of a Windows MSI installer.
We added the ability to customize the banner and background images in an MSI installer.
We added a utility method for formatting the banner-style warning messages that Briefcase generates. We haven't rolled out the usage of this banner across all parts of the Briefcase codebase, but it will allow us to improve consistency in the display of warning output.
We modified the new project wizard to improve the visibility of known third-party bootstraps.
We added a runtime checks for using an x86-64 Python interpreter on an Apple Silicon Mac. This configuration can cause issues when trying to run an iOS simulator.
We added the ability to create a "skinless" Android emulator. This is mostly useful for CI configurations, where the extra visual detail doesn't help, but downloading the skin will sometimes fail due to rate limits imposed by Google's servers.
We improved the verification of installed Android SDK images.
We added support for the use of .NET Core 10 in Toga. This was primarily required to support WinForms on ARM64, but it also means features like dark mode are now possible on WinForms.
We performed a major refactor of the internals of the Canvas widget, and modified the Canvas API to align better with JavaScript's HTML5 Canvas API.
We migrated Toga's Web backend to use WebAwesome, rather than Shoelace. WebAwesome is effectively "Shoelace 3", after the Shoelace project was adopted by the FontAwesome team.
We added a full implementation of DetailedList on WinForms. This was the last widget in Beta status on WinForms - WinForms is now widget complete!
We corrected some crashes that could occur on macOS when clicking on empty rows of a table, or the table header row.
We corrected an unusual bounce when calling scroll_to_bottom() on a WinForms MultilineText widget.
We made the definition of accessors optional when defining sources.
We added support for fonts that have been system-registered on iOS and macOS.
We normalized the feature set of the CPython Android build script with other platform build scripts.
We completed the migration of CPython Android build tooling to the Platforms folder.
We increased the RAM available to the Python Android testbed to accommodate more demanding test suites.
We submitted updates to cibuildwheel to support Android packages that use Fortran, NumPy's C API, and external libraries bundled with auditwheel.

Much of this work is due to the contributions of members of the BeeWare community. Thanks to Abdo (@abdnh), Keyang Zheng (@albuszheng), Filip Łajszczak (@filiplajszczak), John (@johnzhou721), Luis Palacios (@moondial-pal), Matt Van Horn (@mvanhorn), @Oliver-Leigh, @otekraden, Robert Kirkman (@robertkirkman), Matt Cooper (@vtbassmatt) for their code and documentation contributions this month.

Special thanks go to Scott Halgrim (@shalgrim), Juan (@Pulga8), and Vui Nguyen (@vuinguyen) who were contributing to BeeWare as part of Session 6 of the Djangonaut Space program. Go Team Mercury!

What's next?¶

A lot of May will be spent preparing for and attending PyCon US. We're presenting talks on mechanisms for distributing Python code and switching your project documentation from Sphinx to Markdown. We'll be there for both days of the sprints, hosting some open spaces (watch the boards at the venue for details), attending the community showcase, as well as participating in a other events and generally lurking around the hallways. Tickets are still available - if you're around, come say hi! We're actively looking for stories of how you're using BeeWare, or how you'd like to use BeeWare.

In what time that remains in the month, we'll be focused primarily on Briefcase, adding more customizations for MSI installers, and starting to experiment with mechanisms for improving the development experience for mobile apps.

Want to get involved?¶

If you're interested in the tooling for deploying applications to various platforms, take a look at Briefcase.
Or, if you're interested in GUI widgets, take a look at Toga.

2026Q2 Roadmap

russell@beeware.org (Russell Keith-Magee) — Mon, 20 Apr 2026 00:00:00 +0000

Q1 has seen some significant improvements to Toga, Android packages, and a milestone for official iOS support. As always, this roadmap should be read as a guide to what we aim to focus on over the coming quarter, rather than a hard commitment to features that will be made available on a specific deadline.

Q1 progress¶

The bulk of our activity in Q1 has focused on Toga. We completed work on Toga's new Qt backend, achieving full widget coverage. We made some significant improvements to the API for managing columns in Tree and Table widgets. On Windows, we've added an implementation of a Tree widget for the first time, and significantly improved the Table widget. We made a major change to how widgets are imported, improving load times for Toga apps, and allowing third-party libraries to register their own widgets and their own implementations of existing widgets. We also performed a major refactor of the Canvas widget API, improving consistency between Toga's Python API and the HTML5 Canvas API that we use as a reference implementation.

We also made improvements to Toga's Positron plugin. Positron is Toga's answer to Electron - a way to build cross-platform apps where the user interface is provided by a web page. However, Positron allows you to use Python web servers rather than JavaScript - and unlike Electron, allows for the development of hybrid applications and mobile application. This quarter, we added the ability to deploy a FastAPI website; improved the tooling for building an app from an existing website; and we've built a prototype of a new PyScript backend that allows client-side browser code to access server-side capabilities.

However, the biggest Toga news for the quarter is that we laid out a design plan for the next phase of Toga's development, addressing issues of "Big Picture" app design. The set of widgets offered by Toga is reasonably complete for most platforms. At this point, the issue facing application developers - especially on mobile platforms - is how to represent navigation between content in a large app. After some public discussions, we've laid out a plan for a range of improvements that should enable users to write reasonably complex applications in Toga, while retaining cross-platform, single source base compatibility. This plan will form the basis of Toga development for the coming months.

Work on Android wheels has progressed. We have published updated internal Android wheels for a number of key data science packages, including NumPy, Pandas, SciPy, scikit-learn and xgboost. Developing these patches involved developing updates to a variety of tools that are used to build wheels, including cibuildwheel, auditwheel, Meson, and Python's own Android testbed. The patches resulting from this work take time to get upstream; that work will proceed in the background over the coming months.

We have completed the work adding iOS to CPython's release artefacts. As a result, Python 3.15.0b1 should include an official CPython iOS XCFramework that can be incorporated into an iOS project. As part of this work, we've also assisted with a large cleanup of the CPython repository, moving all the platform-specific build tooling for iOS, Android and Emscripten into a single "Platforms" directory. Along the way, we've addressed some minor inconsistencies and usage issues with these build scripts.

We released Briefcase 0.4.0, which includes a major improvement to the operation of development mode operates for apps, isolating the dependencies of the app being developed from the environment that is running Briefcase. It also includes support for PEP 639 license specifications - part of an ongoing effort to align Briefcase metadata with PEP 621. We've also started experimenting with the use of ty to enforce type annotations in Briefcase's code.

After some discussion by the team, we've made the decision to adopt an AI Contribution policy. This policy adopts a neutral stance on the use of AI tooling; however, it requires formal declaration of AI tool usage, and makes it clear that the humans driving autonomous tools are ultimately responsible for the output of those tools. The policy is currently in the final stages of getting approval from the team; we expect to roll out the policy in the next couple of weeks.

Lastly, we released our new project website. The content of this website isn't significantly different to before - but it now uses the same MkDocs tooling that we use for all our other documentation, giving us much faster builds, better translation tooling, search… and dark mode! It also includes translations to some new languages, including Japanese and Russian.

Q2 priorities¶

In Q2, we have two main priorities.

Firstly, we'll be focusing on some key improvements to Briefcase. We intend to continue improving Windows MSI installers, adding some additional customization options, and adding support for Windows on ARM64. We plan to start investigating the use of Conda environments for building Briefcase apps. Lastly, we will explore mechanisms for updating the content of an existing app without having to go through an App Store review cycle. This may also open options for "live reload" of app development.

Secondly, we plan to start executing on the "Big Picture" plan that was laid out in this quarter. That plan describes a lot of changes, so we don't anticipate completing that plan for some time. However, we're hoping to see some progress on the foundational pieces of that work, which we will build on over the course of the year.

We will also be attending PyCon US. We're presenting talks on mechanisms for distributing Python code and switching your project documentation from Sphinx to Markdown. We'll be there for both days of the sprints, as well as participating in a number of other events and generally lurking around the hallways. If you're able to make it, make sure you say hello!

Longer term goals¶

Now that we've published a plan for "Big Picture" app development, our primary long term goal is to deliver on that plan.

However, there's only so much the core team can do by ourselves. The ultimate long term goal is to build the community of BeeWare users and developers so that the core team isn't the only source of new features and support. Part of the reason we spent time publishing a plan for Toga's future development rather than just doing the work ourselves is to enable community contribution. We hope to do more of this community-enabling work over the coming months.

March 2026 Status Update

russell@beeware.org (Russell Keith-Magee) — Tue, 31 Mar 2026 00:00:00 +0000

March has seen some big improvements in Briefcase, as well as some major discussions of design and policy issues in the rest of the project.

What we've done¶

We released Briefcase 0.4.0! This release makes a major change to how development mode operates for apps, isolating the dependencies of the app being developed from the environment that is running Briefcase.
We upgraded Briefcase to use PEP639 license format.
We added support for dynamic PEP 621 project metadata. This allows apps to have their version number configured by version control tags.
We addressed CVE-2026-33430, a security issue which allowed for potential privilege escalation in Windows MSI installers.
We added the ability to configure the Android ABIs that are targeted as part of a Briefcase build.
We made a retry mechanism to make project cleanup mechanisms more robust on Windows.
We started experimenting with the use of ty to enforce type compliance in the Briefcase codebase.
We added validation of MIME type definitions on document types.
We modified MSI installers to allow install scripts to inherit elevated privileges of the installing user.
In order to address some emerging issues and questions about the use of AI tools in contributions to BeeWare, we discussed the possible adoption of an AI contribution policy, and then published a draft policy and drafted a set of agent guides for Briefcase.
We published a design plan for the next collection of Toga widgets, governing "Big Picture" app navigation.
We added a FastAPI bootstrap for Toga's Positron plugin.
We experimented with a PyScript bootstrap for Positron. This work is still dependent on some experimental tools, but we hope we'll be able to release this in the near future.
We added support for column resizing in Qt tables.
We modified the API for Table and Tree to allow explicit definition of columns. This provides a much more flexible mechanism for configuring the display of Table and Tree widgets.
We added a mechanism for lazy loading and dynamic registration of widgets. In addition to reducing app startup time, this allows third party libraries to provide widget implementations that Toga doesn't provide, and to register entirely new widget types.
We added a Switch widget for Toga's Textual backend.
We added a Tree widget to the WinForms backend. This has one of the more notable missing widgets from Toga's API.
We modified how notifications from data sources are handled so that a ListSource can be a listener on other sources.
We corrected a bug in Toga's handling of presentation mode that would prevent more than one window from being put into presentation mode.
We migrated Rubicon ObjC's test suite to pytest, and performed a large refactor of the tests to break up some large test files.
We contributed a migration of CPython's iOS build code to the new "Platforms" directory, and reviewed a comparable change for Emscripten. CPython has grown a number of new platforms in recent releases; this refactor is an organizational change that allows all platform-specific build tooling to be in a single subdirectory, rather than having lots of top-level directories. A similar set of patches for Android are in development.
We made some improvements to the CPython iOS build script and Android build script for consistency with other platform tools.
We submitted Android support to auditwheel and meson-python, and enabled automated Android testing of pybind11.
After the launch of the updated BeeWare website at the end of last month, we've addressed a number of small cosmetic, linking and translation issues that were reported, including improvements to the layout of upcoming events, improvements in mobile rendering, and ensuring as much content as possible can be translated.
We added sections to the contribution guide on retrieving repository tags, and using the gh tool to open issues.
We resolved an issue with the preservation of spaces in code blocks when copying sample code content.
We optimized the build of the tutorial to build all languages in a single pass.
We replaced the use of a JSON API with an internal link under our control.

Much of this work is due to the contributions of members of the BeeWare community. Thanks to Mattijs Ugen (@akaIDIOT), Aleksei Pirogov (@astynax), Filip Łajszczak (@filiplajszczak), Johanan Oppong Amoateng (@JohananOppongAmoateng), John (@johnzhou721), Robin (@lrandersson), lif (@majiayu000), @Oliver-Leigh, @Pulga8, Scott Halgrim (@shalgrim), Tom Arn (@t-arn), Eyal Tabib (@tabibeyal), and Zyad Haddad (@Trighap52) for their code and documentation contributions this month.

What's next?¶

We'll be publishing our Q2 roadmap in a couple of weeks. In addition to some progress in Toga that is aligned with the design plans we laid out this quarter, we're hoping that Q2 will see some experimentation with how Briefcase can be used to improve the process of developing and deploying apps. The hope is by making some relatively small changes to how Briefcase starts mobile applications, we will be able to speed up the app development process, and enable some interesting use cases for deploying applications to mobile platforms.

We'll also be preparing for our attendance at PyCon US. We're presenting talks on mechanisms for distributing Python code and switching your project documentation from Sphinx to Markdown. We'll be there for both days of the sprints, as well as participating in a number of other events and generally lurking around the hallways.

Want to get involved?¶

If you're interested in the tooling for deploying applications to various platforms, take a look at Briefcase.
Or, if you're interested in GUI widgets, take a look at Toga.

We'll be at PyCon US 2026!

russell@beeware.org (Russell Keith-Magee) — Tue, 03 Mar 2026 00:00:00 +0000

Russell, Kattni and Malcolm will be attending PyCon US 2026 from May 13 - May 19, 2026!

The conference will be held at the Long Beach Convention Center in Long Beach, California, and will feature tutorials, talks, summits, sprints and more.

You can find us throughout the event:

Russell will be giving a talk entitled How to give your Python code to someone else.
Russell, Kattni and Malcolm will be hosting a sprint.

Please come say hello, we'd love to meet you. We're looking forward to seeing you there!

February 2026 Status Update

russell@beeware.org (Russell Keith-Magee) — Mon, 02 Mar 2026 00:00:00 +0000

February has seen a collection of improvements across the BeeWare ecosystem - including a couple of big milestones!

What we've done¶

We've launched a new version of our website! This primarily an infrastructure change - we've moved off Lektor, and onto a MkDocs-based site, matching the tooling that we're now using for the rest of BeeWare's documentation. This gives us much faster builds, better translation tooling, search… and dark mode! A huge shout out to Kattni for all her work getting this done.
We welcomed a new member of the BeeWare core team - Corran Webster. Over the last few months, Corran has taken Toga’s Qt backend from a bare stub to a widget-complete implementation. He’s also done some major internal design work around Toga's Table and Tree implementations, and added the long-requested ability to add bitmap images to a Canvas. That's a lot of work for a couple of months - we're excited to see what comes next!
We published new support packages for iOS and macOS, backporting some recent changes in CPython to our patches for Python 3.10-3.12.
We made significant progress on adding FastAPI and PyScript backends for Positron. The PyScript part of this backend has revealed some issues with the feature set of Android and iOS WebView widgets; we're working with the PyScript team to find a workaround for these problems.
We fixed several issues with the testbed application that is used to test Python on Android.
We added a plugin interface to Briefcase to allow for the definition of publication channels. We're working with the PythonAnywhere team to build a plugin that will allow for the publication of web apps.
We optimized the work that Briefcase does when inspecting app configurations on startup.
We added the ability to revoke permissions when running an app on Android.
We corrected an issue handling macOS wheels that have multiple platform tags.
We fixed some issues with Briefcase's version parsing logic.
We modified how Briefcase handles dependencies on Linux to ensure that package extras are preserved on packages that are specified as local dependencies.
We corrected an issue with the naming of DEB packages produced by Briefcase.
We improved the documentation for packaging apps that weren't created with Briefcase.
We finished porting all widgets for the Qt backend, adding a DetailedList and Tree widgets.
We corrected some issues with how Toga's canvas widget handles transforms in the middle of a path.
We added support for rounded rectangles on Canvas.
We corrected some edge cases in the handling of join mitering on Toga's Canvas widget.
We ensured that Toga's WebView widget can always handle HTML content provided as a string no matter how large that content is.
We modified Toga's codebase to make better use of abstract base classes (ABCs).
We added the ability for WinForms Table widgets to have an icon in every column, not just the first column.
We corrected some memory leaks in Toga's Windows backend.
We improved how corrupted icons are handled in Toga, providing a fallback path instead of a crash.
We fixed an intermittent issue with the testbed when testing Toga on Android.
We made some changes to our bug reporting template, and added a new template for reporting documentation issues.

What's next?¶

In March, we're hoping to wrap up our work on the FastAPI and PyScript plugins for Positron. The plugin is mostly done, but we're looking into some additional optimizations and improvements that will improve the experience when using the plugin.

However, most of our focus will be on design work around capabilities that are currently missing from Toga. This month saw some initial discussions on these topics. We're hoping that by the end of the month, we'll be able to resolve those discussions with some concrete designs that we can start to implement.

Want to get involved?¶

If you're interested in the tooling for deploying applications to various platforms, take a look at Briefcase
Or, if you're interested in GUI widgets, take a look at Toga

January 2026 Status Update

russell@beeware.org (Russell Keith-Magee) — Mon, 02 Feb 2026 00:00:00 +0000

We've started 2026 with a buzz — a flurry of BeeWare activity on Toga's Canvas and Table widgets, Qt backend, as well as making some major progress on Android binary packaging.

What we've done¶

We have almost completed all the widgets in Toga's Qt backend, adding OptionContainer, ScrollContainer, DetailedList, Selection, Table, SplitContainer and MapView widgets, as well as support for all dialog types.
We made some API changes and corrected some bugs to make the Canvas API more closely aligned with the HTML5 Canvas specification. This is part of a larger set of changes cleaning up the implementation of Canvas.
We added the ability to add a bitmap image on a Canvas.
We made a large internal refactor of the Table and Tree widgets. This is the first step in improving the API for defining Table and Tree widgets to exposed some long-needed capabilities like sorting and specifying column widths.
We hardened the definition for providing icons in Table and Tree column data. The documented API has been specific for some time, but hasn't been implemented consistently on all platforms.
We modified the way Source objects are used to ensure that widgets no longer listen to stale sources when data changes.
We formalized the protocol definitions for data source listeners
We corrected some issues with the display of OptionContainers on Cocoa and GTK when content is changed on a non-visible tab.
We corrected a number of layout issues on iOS and iPad apps, including introducing the ability for iPad apps to operate in non-full screen mode.
We corrected some issues with scroll handling in ScrollContainer on macOS.
We corrected some issues with widget colors in dark mode on macOS.
We corrected some memory leak issues with Android widgets.
We added the ability to use the Python standard library webbrowser module in Toga Android apps.
We corrected the use of theme colors in DetailedList on Android.
We added the ability to be notified when a website completes loading on Android. This API feature was previously possible on every platform except Android.
We corrected the handling of icon sizes on buttons on Windows
We simplified the categories used in Toga's API reference docs.
We clarified the documentation around using Toga with a Python version other than the system default.
We added documentation of Toga's platform and backend selection APIs.
We ensured that content added to an OptionContainer or SplitContainer can accurately track the Window and App they are associated with.
We completed work on patches to NumPy, Pandas, SciPy, scikit-learn and xgboost allowing these projects to be built for Android. This also involved updates to tools including cibuildwheel, auditwheel, Meson, and Python's own Android testbed. We hope to upstream these patches to the corresponding projects in the near future.
We resolved an issue with Android buildbot testing in CPython. Both Android Buildbots stopped working in mid December for two different reasons; the cause of the problems is not entirely understood, but we were able to find workarounds and restore Buildbot testing.
We are nearing completion on a replacement for BeeWare's website. The new website will use the same MkDocs infrastructure that is used for our tutorial and project documentation. This will add dark mode, search capabilities, improved event and resources pages, and some other content simplifications to our website. It will also make our job easier as maintainers, as website builds are much faster, and adding new content to the site is easier.
We released updated Apple support packages for all supported Python versions. These updated versions are the first to adopt the XCFramework layout that has been accepted upstream by CPython, including scripts for managing the process of processing binary libraries on iOS.
We added the ability to reset all runtime permissions when running an app on Android.
We added the ability to merge folders named in sources and test_sources in a Briefcase configuration. This allows projects to overlay platform-specific content over a base project layout.
We added the ability for Windows MSI installers to reference the location of the original MSI in post-install scripts.
We improved our documentation of the use of signing identities.
We added the ability to open a single Briefcase app in a project that contains multiple app definitions.
We modified our System PySide library to support some common KDE extensions.
We corrected an issue with Toga Chart that prevented the example app from running on Android.
We corrected an issue with the handling of background images in DMGs on macOS Tahoe.
We corrected some issues with parsing the size and text-size properties and color hex regexes when creating DMGs.

Much of this work is due to the contributions of members of the BeeWare community. Thanks to Alec Delaney (@tekktrik), Barak (@BarakXYZ), Corran Webster (@corranwebster), Harsh Kumar (@thisisharsh7), John (@johnzhou721), @kshivani06, Mike Maietta (@mmaietta), @MTwem, @Nabhye, @rasmusJenle, @timrid, Tom Arn (@t-arn), and @YapWC for their code and documentation contributions this month.

What's next?¶

In the coming month, we're going to start work on improving Positron to better support PyScript apps. We're also going to perform some API design work around capabilities that are currently missing from Toga. This will include a design for Table and Tree widgets for mobile platforms, as well as tackling some high-level app navigation issues. Some of these discussions have already started this month; they will continue until we have finalized designs that can be implemented.

Want to get involved?¶

If you're interested in the tooling for deploying applications to various platforms, take a look at Briefcase
Or, if you're interested in GUI widgets, take a look at Toga

2026Q1 Roadmap

russell@beeware.org (Russell Keith-Magee) — Fri, 16 Jan 2026 00:00:00 +0000

In Q4, BeeWare saw wide-ranging improvements across almost all the tools we maintain, as well as the conclusion of some long-running efforts in wheel packaging. As always, this roadmap should be read as a guide to what we aim to focus on over the coming quarter, rather than a hard commitment to features that will be made available on a specific deadline.

Q4 progress¶

We have now concluded our work on iOS packaging. We contributed support for iOS to Maturin and PyO3, and have been able to successfully publish wheels for Cryptography to BeeWare's iOS wheel repository. We need to wait for a formal release of PyO3 and cffi before we can contribute patches to Cryptography, but we know the work that needs to be done.

We have added iOS to CPython's CI processes; however we haven't been able to add iOS to CPython's release artefacts. This is due to some ongoing discussions about the need to centralize the processes of producing binary dependencies, and providing SBOMs for that work. We hope to revisit this work before the 3.15 release. Work was also slowed by a large number of issues with GitHub's macOS runners. During Q4, we saw a disturbingly large number of regressions and performance issues caused by changes made by GitHub; responding to those issues consumed a lot of our time. These issues are not yet fully resolved; but we have workarounds in place that will work until later this year. We hope that GitHub will have resolved the underlying problems before those workarounds stop working.

Work on Android wheels has not proceeded as quickly as we had hoped due to the need to address some compatibility issues with the most recent Android SDK release; but we have made some progress. We hope to wrap up Android wheels work in this coming quarter.

Toga saw the addition of a completely new Qt backend - and a large proportion of the widgets on that backend have been implemented. We also published a new system-pyside6 package that allows the use of system-provided Qt bindings in an isolated Python virtual environment - this ensures that packaged Qt apps don't need to include a complete copy of Qt in order to run. We also added support for a number of GTK4 widgets, and added initial support for Adwaita (a common Gnome desktop theme) in Toga's GTK4 backend. We've also seen a large number of fixes to Toga required by the roll out of Apple's "Liquid Glass" appearance changes in macOS 26 and iOS 26. We are continuing to find and response to these edge cases as we find them.

Briefcase saw a number of significant improvements. We were able to leverage the work done by our Curtin University capstone students to significantly improve the experience of development mode for Briefcase projects. We added support for customizing the install directory, and configuring uninstall options to Windows installers. We also added a framework for integrated debugging support for packaged apps, including plugins for PDB and Visual Studio Code.

Lastly, we completed our documentation switch to Markdown, launching a new documentation landing page on the BeeWare website, converting Briefcase and Rubicon's documentation to Markdown format, adding improved machine translation workflows, and rolling out a major refresh of our contribution guides.

Q1 priorities¶

In Q1, we have three main priorities.

Firstly, we hope to wrap up work on binary packaging of wheels on Android. We hope that we'll be able to wrap up work on Android wheel packaging this quarter.

Secondly, we've had some interest from the PyScript team on using Toga's Positron layer as a mechanism for deploying PyScript apps. As a result, we'll be spending some time to improve the integration of Positron with PyScript.

Our last goal is to return our focus to Toga's native GUI capabilities, especially for mobile platforms. Over the course of this quarter, we're hoping to see progress on Table and Tree widgets (which have long been gaps on iOS and Android), as well as the start of work on notifications and high-level navigation in iOS applications. These are all completely new capability additions for Toga, so the design process will likely take some time.

Longer term goals¶

We've spent the last 2 years establishing a firm technical foundation. We've formalized iOS and Android support in CPython itself, and we've ensured that Python binary packages can be fully supported on mobile platforms. We can now turn our attention to the things we want to build on this foundation.

Our focus for the rest of this year will be to improve Toga so that it can be used for "real world" applications. We're hoping to fill out the Toga API gaps that have historically existed, and have prevented people from building useful applications. This means more widgets, more mobile-specific capabilities - and more time spent documenting and promoting what can be done with Toga.

Part of the motivation for spending time on promotion is to encourage the development of a vibrant and growing community around Toga, and BeeWare as a whole. We want to spread the excitement that we feel about BeeWare to others, welcoming new people into our community, while ensuring that when they arrive, we have a buzzing hive of BeeWare contributors ready to provide support for newcomers, share expertise with those building complex projects, fix bugs, and add yet more features as time progresses. To that end, we hope to spend more time engaging with folks in the Python ecosystem to show how they can begin their BeeWare journey.

December 2025 Status Update

russell@beeware.org (Russell Keith-Magee) — Tue, 06 Jan 2026 00:00:00 +0000

Even with the impediment of end-of-year holidays restricting the availability of the core team, BeeWare has still seen some significant progress during December.

What we've done¶

We adopted an updated Code of Conduct, incorporating changes from Contributor Covenant 3.0.
We released Briefcase 0.3.26, Toga 0.5.3, and Rubicon Objective-C 0.5.3. These releases incorporate almost 4 months of changes.
We simplified our Dependabot and pre-commit update tasks to minimize the number of updates that need to be processed every week.
We rolled out a massive rework of our contribution guides. This update provides more comprehensive guidance on ways to contribute to BeeWare. It also allows us to share contribution content between projects, rather than duplicating that content.
We updated Briefcase to use Chaquopy 17.0.0, enabling support for Python 3.14.
We added the ability to debug Android applications with Briefcase.
We modified Briefcase to verify system requirements when running briefcase dev on Linux. This should eliminate a common source of errors when running the BeeWare tutorial on Linux.
We modified Briefcase's development mode to use an isolated virtual environment. This improves the correlation between the behavior of the development environment and the behavior of a packaged app.
We added the ability to have uninstall options in MSI installers.
We made significant improvements to Toga's Qt backend, adding PasswordInput, ProgressBar, NumberInput, DateInput and TimeInput, MultilineTextInput, WebView, Canvas, and Slider, Divider widgets, support for StatusIcon apps, and improved Font support.
We released system-pyside6, a Python package allowing Python apps in a virtual environment to use the system-provided PySide6 libraries.
We added initial support for Adwaita in the GTK4 backend.
We modified Toga's image handling to ensure that image files aren't left open after loading.
We corrected some edge cases in Toga's app name normalization.
We added documentation for Toga's color API.
We fixed the handling of nested OptionContainers on iOS 26+.
We added the ability to control whether a WebView is allowed to navigate to a new URL.
We added an API to determine the current backend being used by Toga.
We corrected an error raised when the locale defined by the system is unknown or invalid.
We improved the mechanism used to identify errors in the runtime Canvas tests.

What's next?¶

The holiday break means we haven't fully locked in our plans for January; but we're definitely expecting to see progress on Android packaging, and to wrap up some final work on iOS packaging. We expect to publish our full Q1 2026 goals late next week.

Want to get involved?¶

If you're interested in the tooling for deploying applications to various platforms, take a look at Briefcase
Or, if you're interested in GUI widgets, take a look at Toga

November 2025 Status Update

russell@beeware.org (Russell Keith-Magee) — Mon, 01 Dec 2025 00:00:00 +0000

November has been a busy month, seeing improvements in documentation, a number of improvements to Briefcase, Linux support in Toga, and the first iOS binary wheels written in Rust!

What we've done¶

We made multiple contributions to Maturin and PyO3, including a fix for iOS wheel naming strategies, adding support for iOS cross-platform virtual environments, improving the mechanism by which the build interpreter is detected when building ABI3 wheels, and ensuring libpython is linked into iOS binary wheels. As a result, we've been able to publish Rust-based iOS wheels for Cryptography to the BeeWare package repository. Once the changes to Maturin and PyO3 have been formally released, we'll be able to submit PRs adding official iOS builds to Cryptography.
We completed a large refactor of BeeWare's documentation. The BeeWare website now has a clear "Documentation" heading, and all of BeeWare's main projects serve their documentation from beeware.org subdomains.
We expanded the BeeWare tutorial to include a section on runtime icon handling.
We completed an update to Chaquopy, the tooling underpinning Briefcase's Android support, adding support for Python 3.14, as well as a number of other updates to adapt to changes in the Android ecosystem.
We released a number of Android wheels for Python 3.10, for packages which were previously only available for the end-of-life Python 3.8.
We added integration with PDB and VSCode debuggers for Briefcase apps. This allows users to use their IDE to debug Windows, Linux, macOS and iOS apps. Support for Android should be added soon. Support for PyCharm and other debuggers should also be possible given the debugging framework that has been put in place.
We added the ability to customize the install directory, and configure pre-uninstall options in Windows MSI installers.
We modified briefcase dev to install local source paths in editable mode.
We added support for a cross-platform Bluetooth permission in Briefcase apps.
We improved Python version detection when building apps on Linux.
We added a new Qt backend to Toga! This will allow Linux users with a KDE desktop to have fully native apps, instead of relying on GTK theme emulation. The Qt backend is still in development, but it already has support for a lot of simple widgets, including Button, Label, Switch and ImageView.
We added Button, TextInput, Canvas DateInput testing, and Activityindicator widgets to Toga's GTK4 implementation, as well as adding support for fonts and icons.
We added a handler for window resize events on Toga Windows.
We added support in Toga's DecimalInput for locales that use a comma as a decimal separator.
We improved Toga's WebView, ensuring that it can access SharedArrayBuffer APIs on GTK. We also modified the Positron static plugin to set headers that are necessary for using SharedArrayBuffer in an app.
We made some improvements that improve the reliability of some Toga tests.
We contributed a new feature to cibuildwheel that allows the specification of arguments to the test executor. This was primarily needed to provide a workaround for some instability in GitHub Actions, but it has the added benefit of adding configurability to some test execution functionality that was previously hard coded.
We corrected an issue with how the iOS testbed handles command-line arguments with spaces.
We made a small modification to the iOS XCFramework build process to add a lib folder. This improves compatibility of iOS XCFrameworks with traditional Unix-style build systems.

What's next?¶

December will be a short month due to end-of-year holidays; but we're still hoping to see some developments in Android packaging, an iOS package for Pandas, and some improvements to Briefcase building on the work our Curtin students have done over the course of the year. We expect to release a new version of both Briefcase and Toga in the coming week.

Want to get involved?¶

If you're interested in the tooling for deploying applications to various platforms, take a look at Briefcase
Or, if you're interested in GUI widgets, take a look at Toga

2025 Curtin University Capstone Project - Year End

Kavidu Abeykoon Mudiyanselagedara — Tue, 04 Nov 2025 00:00:00 +0000

Since February, a team of final year students from Curtin University has been collaborating with the BeeWare Project as part of a capstone project for their degrees. This is a summary of the work they have completed.Capstone is the final year project undertaken by students across all computing disciplines at Curtin University, including Computer Science, Software Engineering, Cyber Security, and Information Technology. It allows students the opportunity to work in teams on real-world projects in collaboration with industry partners, gaining practical experience and professional exposure before graduating.

This year our team has had the exciting opportunity to contribute to BeeWare for our Capstone project.

Meet the Team:

Kavidu Abeykoon Mudiyanselagedara (kavi2du); Information Technology
Callum Horton (Stringer90); Software Engineering
Caydn Lee (caydnn); Software Engineering
Jaeden Mah (JMah007); Computer Science
Mitchell Pontague (mEp3ii2); Software Engineering
Veronica Taniputra (vt37); Cyber Security

In the first semester, our team gained exposure to the BeeWare ecosystem through tackling a variety of small bug fixes within Briefcase and Toga, creating widgets for the web backend in Toga and completing small research tasks into the mechanisms within the BeeWare tools. More details about our first semester contributions can be found in our first semester report. After this, the team split off into pairs to plan out larger deliverable contributions that would add or changes features within BeeWare.

It is these deliverables that the team worked on in the second semester.

What We’ve Worked On This Semester¶

Toga Web Testing¶

This semester, we delivered a functional prototype of a testing mechanism for Toga’s Web backend. This prototype addresses the problems identified in the analysis we performed during our first semester. The problem was straightforward: there wasn’t a practical, end-to-end way to run automated tests against Toga web apps running in the browser. Our prototype addresses this by introducing a structured communication bridge between the backend, and the frontend, widget proxies, and DOM probes. This enables end-to-end tests that tests both widget logic and rendered UI. At this stage, the work serves as a proof-of-concept approach rather than a finished product. It demonstrates that the core approach works reliably, though additional features and improvements remain to be implemented. Our proof-of-concept prototype can be found within our draft pull request.

Briefcase Web Development Optimizations¶

We also laid the groundwork for web platform development mode support in Briefcase by making the dev command platform-aware, and implementing virtual environment management. We refactored the core DevCommand architecture by introducing platform-specific DevCommand subclasses like StaticWebDevCommand to handle platform-dependent workflows). Next, we implemented virtual environment management by introducing the VirtualEnvironment context manager tool, which provides isolated, configurable virtual environments for development mode, and improved the tracking of virtual environment usage by the dev command. We also modified the handling of local Python assets so they are installed in editable mode. This work establishes the foundation for exposing the app assets to a development web server allowing the live-reload workflow, ultimately speeding up the web development process.

PyScript Briefcase and Toga Dependencies¶

Lastly, we worked on redesigning the Briefcase static web build pipeline to implement a deterministic asset insertion system which replaced template-based asset management. The new system enables Toga and other toolkits to embed their configuration files and front-end resources directly into wheel packages which new Briefcase functionality will extract and insert into static web files. The web template received a redesign which established specific areas for insertion. The previous restrictions prevented Toga and other toolkits from taking full control of their front-end operations while working independently from Briefcase. The new system separates tasks while making maintenance easier and enables toolkits to manage their front-end components, with Toga now owning its own PyScript version, PyScript configuration and Shoelace HTML script.

Lessons Learned¶

This year with BeeWare has marked many valuable lessons taught outside of the class environment. Each of us have now made significant contributions to an Open Source project while meeting deadlines and attending weekly stand-up meetings. This process has allowed us to develop our skills in numerous ways. Below each of us will comment our individual lessons.

Kavidu¶

Working with BeeWare was my first professional experience outside of university. This was a huge opportunity for me to have hands-on exposure to real-world software development work within Open Source environments. I gained experience working with large community-based codebases through issue tracking and pull request management while teaming up with developers who used different time zones and technical expertise.

The experience helped me develop better abilities to work with others while improving my skills in team collaboration. The combination of weekly stand-ups and code reviews and asynchronous teamwork helped me develop skills to explain technical concepts simply and receive feedback positively while creating code that others could understand and expand. I developed better skills in Python programming, testing and I learned to create testable code that other developers could use to extend the project.

Moreover, working with BeeWare provided me with essential knowledge about Open Source software engineering through its combination of technical and collaborative aspects. Throughout the process, I learned that the development of good software requires designers to create intentional systems while they must communicate effectively to build tools which enable others to continue improving the project after their contribution ends.

Mitchell¶

One of the most valuable lessons from BeeWare came while implementing a virtual environment context manager for Briefcase.

During the planning and initial development, I was too focused on how this would work for the web development platform rather than on the actual design of the tool itself. My supervisor pointed out that this PR had applications in other areas within Briefcase and should be designed with those considerations in mind.

I had been thinking in terms of "what does the web platform need?" when I should have been asking "what capability does the system need?" This misunderstanding affected my initial timeline and resulted in a much longer development cycle than intended, but it taught me something far more valuable. The real insight was that development shouldn't be task-specific but tool-specific.

When working on something, it's not about what works for today's problem but what tool you're building that will work for any problem that emerges tomorrow. Good design means separating mechanism from policy: your tool provides the how, and each caller decides the where, when, and why. The goal isn't to predict every use case but to build tools that others can use as-is, without modification.

When someone needs virtual environment management six months from now in a completely different context, they shouldn't have to change your code—they should just be able to call it with their parameters and move on. Build it once so it works everywhere, not once per use case.

Ultimately, the best code is not the code that works today but rather the code that's still working unchanged a year from now.

Veronica¶

As this was my first experience contributing to a large, Open Source project, I learned how the workflow fits together—navigating existing code, writing clear issues and PRs, and contributing changes with clear commits and messages. I also learned to keep my work visible, pushing incremental changes, even when not fully finished, with clear notes on status and next steps so reviewers can follow my progress. That was a shift for me, as I used to wait for “finished” work before committing.

Regular stand-ups, shared planning, and pairing on tasks taught me how to work effectively in a team. Through this, I developed stronger communication and collaboration skills and gained a better understanding of how individual contributions fit within a larger shared goal, especially when it comes to coding workflows.

I've improved my Python skills and gained real experience with pytest and Playwright while working on the Toga Web Testing prototype. Most importantly, I learned how to design a cross-process system that bridges a pytest test runner to an app running in the browser, which gave me a much deeper understanding of both testing frameworks and web automation.

Jaeden¶

Beginning with limited Python knowledge increased the learning curve for me however by reflecting at the end of this journey I can see the difference in skills I have gained. I am more confident and familiar now working on a project alongside other software engineers discussing ideas whilst maintaining professional communication practices via weekly stand-up calls and email. Working on Briefcase has taught me to simplify my code more. After regular code reviews from Russell, I realized my code was always more complicated than necessary and could often be simplified either by using in built Python functions or functions already defined somewhere in the codebase that I wasn't aware of.

Callum¶

Throughout this project, I learned that effective communication is one of the most important aspects of collaborative software development. Working on the same codebase as others required constant coordination to prevent overlap and ensure our work aligned technically and conceptually. Regular discussions and updates helped us avoid duplicated effort and made it easier to maintain a shared understanding of the project’s direction.

I learned that transparency, even when work is still in progress, is far more valuable than delaying updates. This also ties closely to the importance of maintaining visibility in an Open Source context, where an up-to-date and traceable history of commits allows others to easily follow development and provide frequent, relevant feedback. Consistently sharing progress, even in small increments, made collaboration far more effective.

Finally, I learned the importance of handover reports and how essential they are for communicating the current state and future direction of a project. A well-written handover report provides clarity on what has been implemented, what has not worked as intended, and what areas require further development or refactoring. It also serves as a bridge for future contributors, ensuring that knowledge is not lost and that others can continue the work without repeating past mistakes. Through this process, I came to appreciate that clear documentation at the end of a project is just as valuable as the technical work itself, as it enables continuity and long-term maintainability.

Caydn¶

This year has taught me how to work effectively within both a small team and a large Open Source project. It's been very eye opening navigating the expectations and workflows that come with contributing to a community-driven codebase. During the first semester, I found that I didn't know how much to push or when to create a PR. This meant that Russell couldn't perceive work being completed and that I could not receive help in situations where I was stuck. With our semester 2 work, especially as we were working in pairs, I made it a goal to commit and push any slight change. This drastically improved our collaboration efforts.

I've also gained confidence and appreciation for modular architecture through working on the PyScript insertion system. Previously, having only worked on smaller codebases of my own or for group assignment work, I've never truly worked on multiple systems that would interact with each other. Having spent time reconfiguring dependencies within BeeWare, I've now learned the value of planning and researching before implementation. The untangling of Toga and the Static Web Template has been some of the most fun I've had within programming thus far. I'm looking forward to seeing how BeeWare continues to make use of and expand on this system.

Collaborative feedback and reviews from Russell, Malcolm, and the team, especially Kavidu have undoubtedly improved our code quality and allowed me to grow as a software engineer. While initially scary to have frequent check ins with my code, I've now placed much more importance in these reviews. Not only does it allow you to gain insight into what may be going wrong, but more experienced developers tend to impart their wisdom upon you. For me, this now means I pay much closer attention to deep indentation as well as the readability and traceability of my written code.

Future work¶

While we have delivered significant changes within the BeeWare ecosystem, continued efforts will be required to complete our works. Each deliverable varies in terms of remaining tasks.

The Toga Web Testing prototype provides a strong foundation for a complete testing framework but remains at a proof-of-concept stage. Future work will focus on extending test coverage across more widgets, stabilizing the proxy and RPC systems and integration with Briefcase to enable a unified startup process for web tests. More details on the current implementation and next steps can be found in the Toga Web Testing Handover Report.

The briefcase dev command now has the basic foundations to support a true development workflow for web applications, enabling live-editing and hot-reload without requiring wheel builds. The remaining work focuses on implementing a parser to locate editable source code paths from .pth files, creating symlinks or file copies in the web project’s static directory so PyScript can load modules directly from local source files, generating the necessary HTML and PyScript configuration to run these modules in the browser, and integrating the development server to bring all these components together. Once completed, these enhancements will enable developers to modify Python source files and instantly see their changes reflected in the browser. More details on the current implementation and next steps can be found in Briefcase Dev Command Optimization Handover Report.

With the majority of the insertion system completed and merged, only one small cleanup task remains. Once sometime has passed and the current changes have been released, the static CSS files in Toga's web backend will need to be converted to inserts using the new configuration format. More details can be found in the issue ticket.

October 2025 Status Update

russell@beeware.org (Russell Keith-Magee) — Mon, 03 Nov 2025 00:00:00 +0000

October saw the release of Python 3.14, which brought about a lot of release-related housekeeping. We've also seen some major improvements to BeeWare's documentation, and the addition of some useful new features in Briefcase.

What we've done¶

We completed our transition to using Markdown for all our documentation, including the tutorial, Toga, Briefcase, and Rubicon Objective-C.
In recognition of her work on the Markdown conversion, we welcomed Kattni as a new member of the core team!
Our Curtin students wrapped their year-long capstone project. This resulted in three major pieces of work: a major update to how Briefcase handles the PyScript and HTML/CSS dependencies; the introduction of a virtual environment management layer to Briefcase; and a prototype of an approach for automated testing of Toga's web backend.
Python's CI system now includes a test run on iOS. This then revealed some odd behavior on GitHub Actions that required some investigation and a workaround.
We modified CPython's Android test runner to accept all of Python's command line options, and made corresponding changes in cibuildwheel.
We corrected the handling of ctypes loading the Python library on Android and Cygwin when ABI flags are present.
We contributed a new option to cibuildwheel that allows configuration of the iOS and Android test runner.
We modified Briefcase's MSI installer handling to add support for post-install and pre-uninstall scripts, and to make the creation of a start menu item optional.
We modified how Briefcase's dev command interacts with environment variables.
We made a number of linting improvements to Briefcase, enabling more Ruff rules.
We corrected an issue with desktop icon association in GNOME apps.
We modified how we create the macOS stub app used by Briefcase. This change was necessary to ensure that Briefcase apps contain support for macOS 26 "Liquid Glass" styles.
We corrected an issue on macOS where ScrollContainer and OptionContainer would not refresh their layout while being dynamically resized.
We made a small change to the WinForms event loop that should improve performance of network-intensive code.
We landed some Toga-related upgrades to Podium, BeeWare's slide presentation app.
We completed our transition to the use of PEP 735 dependency groups across all BeeWare repositories. This means our published wheels will no longer include the list of development requirements; it also means we can retire some utility workflows that were previously required.
We added automated draft translation workflows for new tutorial content..
We upgraded all of our CI configurations to retire the use of the soon-to-be-deprecated macos-13 runner.

What's next?¶

In November, our primary focus will be on iOS and Android packaging. Rust packages will be an area of particular focus, but we're hoping to contribute some other packaging updates as well. We're also hoping to see some additional changes in Briefcase, building on the work our Curtin students have done over the year.

Want to get involved?¶

If you're interested in the tooling for deploying applications to various platforms, take a look at Briefcase
Or, if you're interested in GUI widgets, take a look at Toga