2025 Curtin University Capstone Project

Posted by Curtin Capstone Team on 4 November 2025

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.

Curtin Capstone

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 Optimisations

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 standup 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 practises via weekly standup calls and email. Working on Briefcase has taught me to simplify my code more. After regular code reviews from Russell, I realised 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, stabilising 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 Optimisation 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

Posted by Russell Keith-Magee on 3 November 2025

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

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?

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.

2025Q4 Roadmap

Posted by Russell Keith-Magee on 15 October 2025

In Q3, BeeWare saw the release of Python 3.14 with official Android artefacts, more Python packaging improvements, and significant improvements to our documentation infrastructure. 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.

This Q4 roadmap has been published a little later than normal so that we can fit in with quarterly planning cadence at Anaconda (who employ two of the BeeWare core team). Going forward, you can expect that BeeWare's quarterly plans will be published a couple of weeks into the quarter.

Q3 progress

The end of Q3 sees the release of a new Python version - 3.14. The 3.14 release contains official Android binary artefacts, and a number of improvements to the iOS build process that will lead to official iOS binary artefacts, hopefully in the near future. It also contains restored support for Emscripten as a Tier 3 supported platform. Landing these improvements in 3.14, and ensuring that the BeeWare ecosystem is in a position to use those changes, was a subject of considerable effort in Q3. We were also forced to respond to a number of significant changes to the GitHub Actions macOS ecosystem - work that is ongoing as a side effect of macOS 26 changes and the deprecation of Intel as a supported macOS platform.

We continued to make progress on the state of binary packaging for iOS and Android. cibuildwheel 3.1 included support for Android that we contributed; as a result, it is now possible for projects to have CI pipelines that generate both iOS and Android wheels. We now have a leaderboard of mobile wheel support in Python, and we're starting to see others in the Python community contribute iOS and Android support updates to popular Python projects. We've also been able to consolidate some of the work that we've done on establishing cross-platform environments into a single standalone package - xbuild - that can be used to replicate the functionality that cibuildwheel relies on for cross-platform builds.

We made many improvements in Briefcase's Windows installer support. This began with migrating to a current version of WiX, which then allowed us to add several new features, including displaying a license agreement, offering installation options, and running custom installer and uninstaller scripts.

BeeWare's documentation has also seen some significant improvements. Building on the improvements to the website, we've been able to begin switching our documentation from using reStructuredText to Markdown. reStructuredText is a markup standard that is historically significant in the Python community, but sees very little use elsewhere. It's clear that the rest of the online world has adopted Markdown, and Markdown is also significantly simpler as a syntax; we're hoping that these two factors should make it easier for new contributors to get involved in BeeWare development, and simplify some documentation tasks for BeeWare maintainers. We've already ported many of our READMEs, our tutorial, and Toga's documentation to Markdown format, with more changes to come.

Our students from Curtin University have almost concluded their capstone projects. As a result, Briefcase now has significantly improved deployment options for web-based projects, and the foundations for some significant improvements to how Briefcase uses virtual environments are in place. Although our students will be signing off shortly, we expect to be able to deliver some substantial improvements to Briefcase using these features in the coming quarter.

Lastly, we had a successful attendance at EuroPython, PyCon AU, and PyCon UK, presenting multiple talks, tutorials, and introducing a large number of people to Open Source contribution through the sprints. We also attended the Python Core Team sprint, providing a great opportunity to finalize some details in the 3.14 release, and discuss our plans for the upcoming 3.15 release.

Q4 priorities

In Q4, we're hoping to make one final push on binary packaging for mobile platforms. In addition to wrapping up work on some of the more notable scientific Python packages (such as NumPy and Pandas), we intend to look into packages that are built using Rust. Rust is becoming an increasingly important part of the Python binary ecosystem, and Rust already has support for iOS and Android. However, we need to make sure that Python/Rust tools like Maturin are able to support cross compilation.

We also want to wrap up our work getting iOS binary artefacts as part of the CPython release process, and work on getting those artefacts into use with Briefcase. This will require some improvements to Briefcase, making use of the xbuild package, and the work contributed by our Curtin University students.

Longer term goals

Looking to 2026, after 2 years of building a foundation for a stable, officially supported story for Python on mobile, we can turn our attention back to the apps that people build with BeeWare. This will mean filling some functionality gaps in Toga to satisfy some common app requirements, and writing more documentation and tutorials to help people write apps with BeeWare's tools.

We're also expecting that 2026 will see more integration between BeeWare's tools and other packaging tools. We're already exploring ways that Briefcase can integrate better with Conda. uv is another tool that might fit well in the Briefcase development story, and some of the changes landed by our Curtin students make exploring these options much easier.

September 2025 Status Update

Posted by Russell Keith-Magee on 1 October 2025

September has been a busy month for conference travel, but we've also managed to make some important improvements to projects in the BeeWare ecosystem.

What we've done

  • We attended PyCon AU, giving a presentation about the process of creating Android and iOS wheels.
  • We attended the CPython core team summit at the ARM campus in Cambridge, UK. This was an opportunity to finalise work on the upcoming 3.14 release, and discuss plans for the 3.15 release cycle. We also gave a short presentation about the state of the cross-compilation ecosystem in Python.
  • We attended PyCon UK, giving a presentation about writing GUI apps in Python.
  • We made the first releases of our new cross-platform build management project, xbuild. At this point, xbuild can be used to create cross-platform virtual environments, and to drive compilation of binary wheels on iOS and Android.
  • We added code to CPython to manage the compilation of an iOS XCframework artefact. This change also involved a significant reorganisation of the iOS code so that other Apple backends (tvOS, watchOS, visionOS, and MacCatalyst) can be added, sharing the same XCframework and testbed tooling. This is also an important step towards adding iOS builds to Python's CI matrix, and towards producing iOS binary artefacts as part of the CPython release process.
  • We added code to CPython that handles Apple's recently announced requirement for Privacy Manifests.
  • We updated CPython's Android CI to use the same set of test options as the other platforms.
  • We contributed changes to CMake improving the handling of Android Python modules.
  • We added an ActivityIndicator widget for Android.
  • We improved the size hinting of DateInput and TimeInput widgets on iOS.
  • We enabled focus handling on Table and Tree widgets on desktop platforms.
  • We investigated a number of reported issues relating to the macOS and iOS 26 releases, the rollout of the new "Liquid Glass" style, and what BeeWare needs to do in order to comply with this new style.
  • We continued to make progress on migrating BeeWare's documentation to use Markdown, instead of Restructured Text. A lot of the effort over the last month has related to translation tooling; but we're almost ready to switch the BeeWare tutorial over to the Markdown version. We've also made some progress on migrating Toga's documentation to Markdown. This is a much bigger project as it involves API documentation, and much more complex cross-linking relationships.
  • We performed some initial investigations into post-install and pre-uninstall scripting on Windows. This work should yield results in the coming month.

What's next?

With conference season over for another year, we'll be able to give our full focus to making improvements on BeeWare and related projects. In the next month, we're hoping to wrap up our work on adding post-install and pre scripts to Briefcase's Windows installers. October will also see the release of Python 3.14.0, and there will be some work related to finalizing BeeWare's support of that release. We also hope to start looking at the tooling for building Rust packages for iOS and Android.

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 2025 Status Update

Posted by Russell Keith-Magee on 1 September 2025

August has been a slow month due to some personal leave, and some unexpected road bumps from GitHub - but BeeWare has still made some notable progress.

What we've done

What's next?

September will involve a lot of travel - we'll be attending PyCon AU, the CPython core team summit, and PyCon UK. We'll be speaking at PyCon AU and PyCon UK, and running a sprint at PyCon UK as well. Tickets are still on sale for both events - we hope to see you there!

When we're not travelling, we're going to continue working on getting iOS binary artefacts into Python's CI and release processes, and on improving the tools for packaging binary wheels for mobile platforms.

Lastly, we're planning to look at adding post-install scripts to Briefcase installers. We'll be focussing on Windows installers initially; but the intention is that any changes we implement could also be implemented on macOS or Linux.

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.

July 2025 Status Update

Posted by Russell Keith-Magee on 1 August 2025

In July, BeeWare hit some more major milestones in our work on mobile packaging - but we also found time to make some improvements to other parts of BeeWare.

What we've done

What's next?

With cibuildwheel now supporting both iOS and Android, our work on binary packaging can now shift fully to the upstream projects that will use cibuildwheel to produce wheels. Over the coming months, we expect to submit PRs to more upstream projects; we're also planning to look at packaging that doesn't use cibuildwheel (such as Rust-based packages that use Maturin for packaging). We're also going to start documenting what we've learned about binary packaging for iOS and Android, so that the wider community can start contributing iOS and Android recipes.

We're also going to continue the process of integrating the production of iOS and Android binary artefacts into Python's CI and release processes. We've already begun this process for Android; iOS requires a little more preparatory work, which will be a major area of focus in August.

Lastly, we're planning to look at adding post-install scripts to Briefcase installers. We'll be focussing on Windows installers initially; but the intention is that any changes we implement could also be implemented on macOS or Linux.

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.

2025Q3 Roadmap

Posted by Russell Keith-Magee on 2 July 2025

In Q2, BeeWare reached some public milestones in our iOS binary packaging, and saw some unexpected improvements in our documentation and website. 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 of features that will be made available on a specific deadline.

Q2 progress

In Q2, we continued to make progress on the state of binary packaging for iOS and Android. cibuildwheel 3.0 has now been released, incorporating the iOS support that we contributed; as a result, we've been able to start the process of submitting patches to Python projects to add iOS support. We're still waiting on a formal release of meson and meson-python that includes the iOS changes that we provided; once those releases occur, we'll be able to submit patches for even more projects. We also continued to work on supporting Android in cibuildwheel. This work is still in the review phase; we're hoping it will be concluded in the near future.

A CPython buildbot for Emscripten is now live. The process of launching this buildbot revealed a number of bugs that required resolution; a small number of bugs still remain. We don't anticipate any issue resolving these before the 3.14.0 final release. The draft PEPs defining the Emscripten platform (PEP 776) and Emscripten wheel tagging (PEP 783) have not seen any major progress.

Our students from Curtin University have concluded their first semester of work, providing implementations for a range of Toga widgets on the web platform, finding (and resolving) a number of bugs along the way. They've also made a number of small improvements to Briefcase. As part of their work, they've laid out plans for more substantial contributions in the second half of the year. These contributions should result in significant improvements to the development experience for Toga's web backend.

We also saw a lot of unexpected improvements in BeeWare's documentation and website. We now have a much improved translation infrastructure for BeeWare's website. A significant review of the structure of the documentation of the major BeeWare projects is also underway, addressing both visual consistency, and the integration of the documentation projects into the overall web presence of the BeeWare project.

Lastly, we had a successful PyCon US attendance, presenting multiple talks, a tutorials, and introducing a large number of people to Open Source contribution through the sprints.

Q3 priorities

In Q3, we will have two major areas of focus for BeeWare development.

The first, unsurprisingly, is to continue working on binary packaging. We'll continue working on the cibuildwheel patch to support building Android wheels; and we'll continue the process of submitting patches for iOS support to notable packages. Some of this work is dependent on formal releases of meson and meson-python; we'll progress as fast as the published state of the ecosystem allows.

The second area of focus is generating iOS and Android binary artefacts as part of the CPython release process. This will hopefully also involve integrating iOS and Android into CPython's pre-merge CI tooling, which should limit the incidence of changes that are landed into CPython that break iOS and Android.

We'll also be attending EuroPython in July; PyCon AU, CPython core team summit and PyCon UK in September. These are important events for community outreach and for collaboration with other projects and the core team - but they'll obviously place constraints on the progress we make in the quarter.

Longer term goals

The long term goals of BeeWare remain largely the same. Once we've developed a compelling story for mobile binary packaging, we'll be able to turn our focus back to Toga. There's a number of navigation and data organization widgets that need to be developed; we also need to improve documentation of some common development patterns that are sources of common questions in BeeWare support channels. Unless pull requests are submitted from the broader community, it is unlikely that we'll make any substantial progress on this front until the end of this year, or perhaps early next year.

We're also intending to look at tooling other than pip and venv for building Briefcase packages. Integration with Conda is one obvious goal, as it provides rich tooling for distributing complex binary requirements. uv is another tool that might fit well in the Briefcase development story. Again, it is unlikely that we'll make any progress on this front before the end of this year.

June 2025 Status Update

Posted by Russell Keith-Magee on 1 July 2025

June has been a busy month, with some big improvements to BeeWare's websites and documentation, and some major milestones reached in our work on mobile packaging.

What we've done

What's next?

With the public release of cibuildwheel 3.0, we've been able to start submitting pull requests upstream for projects to officially support iOS. In July, we'll continue that work, with the aim of having some official iOS wheels for major projects that aren't published by BeeWare. We'll also continue working on adding Android support to cibuildwheel, with the hope that it will be included in version 3.1.

We're also hoping to start the process of integrating the production of iOS and Android binary artefacts into Python releases. This will hopefully also involve integrating iOS and Android into CPython's pre-merge CI tooling, which will hopefully limit the incidence of changes that are landed into CPython that break iOS and Android.

We'll also be attending EuroPython, where we will be giving a tutorial, attending the WebAssembly summit, and running a BeeWare sprint. If you can make it to Prague in July, tickets are still available - we hope to see you there!

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.

2025 Curtin University Capstone Project

Posted by Curtin Capstone Team on 13 June 2025

Over the past semester, 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. Here's a summary of what they've done so far this semester, and what they have planned for the rest of the year.

Curtin Capstone

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

What We’ve Worked On

This year, our primary focus has been on improving Toga’s Web backend and enhancing Briefcase’s support for that backend.

Throughout the first semester, our team has been focused on contributing to issues on Briefcase and Toga while working on our research to prepare for what is to come in the following semester. We’ve also worked on implementing several of the Toga Web widgets to enhance functionality on the web backend before working on the web test suite for next semester.

We were first tasked with contributing to a first timer issue before moving on to other more advanced issues.

Briefcase Contributions

  • PR #2198: Add boolean question (feature)
  • PR #2103: Add XML content escaping filter to cookiecutter.py (feature)
  • PR #2199: Add catch exception when deleting JDK (bugfix)
  • PR #2229: Accept other changelog name and extension (feature)
  • PR #2201: Add --app option to briefcase build/package (feature)
  • PR #2214: Add --app option to briefcase create/update (feature)
  • PR #2236: Normalise contribution docs with Toga (documentation)
  • PR #54: Use XML content escaping filter to Visual Studio template. (bugfix) (work in progress)

Toga Contributions

  • PR #3259: Add web screenshots (documentation)
  • PR #3466: Fix button click handling in Toga Web backend to correctly trigger event (bugfix)
  • PR #3338: DateInput (web widget)
  • PR #3405: TimeInput (web widget)
  • PR #3362: ScrollContainer (web widget)
  • PR #3425: Table (web widget) (work in progress)
  • PR #3402: Selection (web widget)
  • PR #3527: Slider (web widget)

What We're Working Towards

Now that we’re more familiar with the BeeWare ecosystem, through both our initial PRs and widget implementations, and having concluded our Semester 1 research phase, we’re shifting our focus to larger, more structural improvements for the second half of the project.

Our primary goals moving forward include:

Toga Web Testing

Toga does not currently support testing for the web platform as the test suite and testbed app run multithreaded in the same process. The web platform is incompatible with this as WebAssembly does not support multithreading. To address this, we are working on developing a general approach that allows the test suite and testbed app to run in separate processes. This will include using proxy objects in place of Toga objects in the test suite that will wrap the respective object in the testbed app, forwarding commands to it in order to change its state and retrieve data.

Additionally, to verify the rendered state of the testbed app, we plan to use Playwright to inspect the browser's DOM and compare it against what the test suite expects. This setup should allow the web platform to be effectively tested while still using the existing test suite.

More technical details and discussion can be found in our Discussion Post on Toga and the associated Issue Ticket.

PyScript Briefcase and Toga Dependencies

During Mitchell’s development of the DateInput Web Widget, we discovered some issues resulting from how PyScript APIs were being used. This issue was resolved separately but sparked broader discussions about the ownership of PyScript, Shoelace, and Bootstrap within the wider BeeWare architecture. Currently, the Briefcase web template includes these directly in index.html, but they should ideally be managed as dependencies of Toga.

We’re proposing to shift ownership of these dependencies to Toga and other toolkits, enabling them to define their own configurations and inserts while keeping Briefcase focused purely on packaging. This would allow for clearer version control, better modularity, and easier maintenance across the ecosystem. This approach builds on prior work (briefcase#1285, toga#1945 and briefcase-web-static-template#9) and introduces a mechanism for toolkit-managed inserts and configuration. We plan on reviving parts of these to allow for Toga to specify PyScript versioning.

More technical details and discussion can be found in our Discussion Post on Briefcase and the associated Issue Ticket.

Briefcase Web Development Optimisations

While contributing to Toga's web widgets, we noticed that testing even small changes requires rebuilding all project wheels (with briefcase run web -r -u), which can take a significant amount of time. This makes local development slow and interrupts the feedback loop needed for efficient frontend iteration.

To improve this we're going to be working on extending the dev command to be platform aware and make it so dev web utilises editbale installs to serve your project to the brower making it so with simple refresh of the browser you can quickly see your changes instead of waiting for a full wheel rebuild.

More technical details and discussion can be found in our Discussion Post on Briefcase and the associated Issue Ticket.

May 2025 Status Update

Posted by Russell Keith-Magee on 2 June 2025

During May, BeeWare saw a number of major improvements - many of which came as a result of our attendance at PyCon US 2025.

What we've done

What's next?

For most this year, we've been trying to get the pieces in place to support binary packaging on mobile platforms. We're now at a point where the code required to support iOS is mostly in place; and the code to support Android is almost in place; however, it will be difficult to make further progress until those changes are available in public releases.

So, in June, we'll be changing focus. We're aiming to take a look at Briefcase, with 2 major improvements in mind. Firstly, we want to upgrade our Windows packaging story, and upgrade our WiX support from WiX 3 to a current version. This should resolve some issues with packaging large apps and apps with lots of files; it should also enable us to package applications for ARM64. Secondly, we've had some requests to expose Briefcase's packaging and signing infrastructure so it can be used on projects that aren't built with Briefcase - we're hoping to add this as well.

We're also hoping to follow up on some of our discussion with the Python core team at PyCon, and begin the process of integrating the production of iOS and Android binary artefacts into Python releases. This will hopefully also involve integrating iOS and Android into CPython's pre-merge CI tooling, which will hopefully limit the incidence of changes that are landed into CPython that break iOS and Android.

Lastly, we'll continue to work on Python Emscripten support. Last month, we thought we were one issue away from a working buildbot; however, some new issues have emerged since then. We still hope to have a working buildbot before 3.14 is finalised, which will restore Emscripten to Tier 3 status.

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.

RSS 摘要

Archive