| FazBrowse GitHub Viewer | Trending | | Home |
| Tools: [Download Repo ZIP] [Original HTTPS Page] |
Welcome! This page contains a list of ideas and how you can help contribute to the Processing Foundation's work on Processing, p5.js, Processing for Android, processing.py (and other Python implementations, p5py and py5), and/or Processing for ARM.
For all of our projects, it's incredibly important that things are kept as simple and user-friendly as possible. Our work is not for developers, it's for people who are less familiar with code, and/or just want to get things done. We're far less interested in features to make the environments more powerful for advanced users than we are in features that make it easier to handle tasks that are common for a wide range of our audience.
In addition to this list, we track specific bugs and enhancements via github issues:
In particular, you might take a look through all of the issues tagged "enhancement" or "help wanted" in the Processing4, and p5.js repos.
The Processing Foundation works each summer with students who are interested in contributing to open source.
Processing is participating again in Google Summer of Code for 2023. Here is how to apply.
If you have questions about an idea or need guidance on forming your proposal, please post to the Processing Forum. This is the best way to get feedback and develop your idea. This makes it possible for everyone to learn from your questions and contribute their thoughts.
The Processing Foundation participated in GSoC from 2011-2015 and 2017-2021. To get a sense of the kinds of project we work on via GSOC, take a look at these reports.
p5.js is a JavaScript library that starts with the original goal of Processing, to make coding accessible for artists, designers, educators, beginners, and reinterprets this for today's web. Using the original metaphor of a software sketchbook, p5.js has a full set of drawing functionality. However, you’re not limited to your drawing canvas, you can think of your whole browser page as your sketch! p5.js has addon libraries that make it easy to interact with other HTML5 objects, including text, input, video, webcam, and sound. p5.js is a new interpretation of Processing, not an emulation or port, and it is in active development.
When proposing p5.js projects, please read through our access statement and be sure to include in your proposal an explanation of how your project will expand access. There are a number of open issues on GitHub. Any of these could be packaged together as a GSoC proposal for a project. We recommend selecting several issues that are in one area of the project. ⚠️GSoC p5.js proposals addressing the existing issues will be given high priority.⚠️
You can use the GSoC proposal template from Berkman Klein Center as reference.
We highly recommend selecting several open issues tagged with "Area:Core" and packaging them together as a GSoC proposal, eg. Issue #3156: Confusion between .elt and .canvas.
We highly recommend selecting several open issues tagged with "Area:Image" and packaging them together as a GSoC proposal, eg. Issue #4535: Capture starts with wrong dimensions + get() on demand pauses it.
We highly recommend selecting several open issues tagged with "Area:Typography" and packaging them together as a GSoC proposal, eg. Issue #3354: Support 'justified' alignment as an option for textAlign.
We highly recommend selecting several open issues tagged with "Area:Events" and packaging them together as a GSoC proposal, eg. Issue #4223: Mouse/touch event handling bug.
We highly recommend selecting several open issues tagged with "Area:Color" and packaging them together as a GSoC proposal, eg. Issue #5654: Issue with color blending when there is alpha involved.
The Friendly Error System (FES) aims to lower barriers to debugging, especially for people new to p5js. It generates helper messages that explain common errors in simple English and provide a link that guides users to an appropriate reference. You can read more about p5.js Friendly Error System in this contributor doc.This project would involve improving the FES code and documentation. This might mean things like:
This project would involve extending the 3D API and adding to the general functionality, performance, clarity of documentation, and usability for p5's 3D API. Here are some example project ideas that might be feasible:
These are just examples to help kickstart the creative process but we welcome project proposals that suggest alternate ideas for what might signify a major improvement to p5's 3D functionality. In addition to implementing the code functionality, a successful project would also address documentation, updated examples, and unit tests. You can learn more about the current WebGl architecture.
In p5's 2D mode, one can use begin/endContour() to draw shapes with holes in them, such as the glyphs of fonts. This currently is not implemented in WebGL mode. Inside the WebGL rendering system, libtess is already used to turn complex shapes into triangles for rendering in beginShape(TESS) mode, but p5 does not yet provide users with a way to give libtess shapes with inner contours.
Currently, p5's filters work by looping through each pixel on the screen. By using shaders, each pixel can be calculated in parallel, speeding up filters significantly. With more students learning from home on modest hardware, this will help make this functionality more accessible. In Processing Java, one can call filter() with a custom shader. Adding p5 support for this would allow for easy-to-share and easy-to-integrate visual effects, and let us replace our current set of filters with faster, shader-based implementations.
When you draw shapes in p5 using beginShape/endShape, all the shape data is processed every frame. Unfortunately, this can slow down sketches on mobile and on other more modest hardware. Builtin shapes and imported 3D models create and reuse p5.Geometry for efficiency, and using it can speed up sketches significantly (e.g. from 4fps to 60fps.) If we provide a way to create these that is as easy to use as beginShape, sketches will be able to run on more people's computers and more people will be able to access them. We have a proof-of-concept library to test this idea out which could be integrated into p5.
We would like to build on the current accessibility infrastructure and expand on sketch outputs that are accessible by screen reader users. Support in any of the following areas is desired: improve description function outputs, add a feature to allow easy download of canvas graphics as SVG (for creating tactile graphics & other manipulatives), support whole canvas meaning-making by including information about the relationships between shapes (improve library generated grid output to better represent shape areas and shape overlapping), and/or extend library-generated descriptions to 3D graphics. This is an exciting learning opportunity as we expect that regardless of interest all participants will write unit tests and document accessibility functions in contributor docs, test accessibility functions and make decisions based on user experiences. We highly recommend selecting several open issues tagged with "Area:Accessibility" and packaging them together as a GSoC proposal.(High Priority!)
We would like to continue the push for accessibility within the p5.js project and community. The most promising approaches are to continue to adapt documentation to use p5.js core accessibility functions, revise accessibility of tutorials and learn examples of p5 website to use accessibility functions, write tutorials, as well as test, refine, and document the new alt-text features
We want to explore how existing machine learning frameworks could help create a prototype or add-on to p5.js with functions that generate screen-reader-accessible descriptions of canvas graphics. This will be a more experimental project where we explore the accuracy and limitations of current ML frameworks to create screen-reader-accessible library-generated descriptions.
We launched the Teach page on the p5.js website in 2020. This project would involve updating and continuing to develop this teaching resource page. This means reaching out to educators for existing teaching syllabi and slides or inviting them to make new ones, adding more materials of teaching p5.js with different skill levels, organizing teaching resources with different themes (like 'First p5.js assignment for beginners'), and adding them to the p5.js website. Note: This is a low priority project this year.
We have launched 4 iterations of curated showcase on the p5.js website. This project would involve updating and continuing to develop this gallery. This means identifying and curating a theme, an artist list, finding their contact information, reaching out to them for existing examples or inviting them to make new ones, gathering and standardizing the files, and adding them to the p5.js website. It would also involve developing the showcase webpage with consideration for accessibility and interaction. It would be good to start by looking at the write-up by Annie Zheng, write-up by Katie Chan, write-up by Connie Liu, and write-up by Ashley Kang who worked on this over the past few summers. Think about ways you might extend the project by (1) developing the site and organizing the showcase GitHub workflow and repos, and (2) adding to the curation of examples. What criteria would you use for curating? How would you reach out to people? What is missing? Note: This is a low priority project this year.
p5.xr is a library that makes it easy to create p5 sketches that use WebXR (AR & VR) functionality. This project is still in an early stage of development so you would be helping shape it in a fundamental way. The WebXR API and device/browser support is always changing with the promise of iOS support finally arriving in 2023. Currently, the project only supports VR on Android and VR Devices (Quest, Vive, etc). AR is limited to Android/Chrome devices. The project would benefit from new core features. Some examples: adding an anchor feature for AR, adding a tensorflow-based cross-browser image tracking feature, developing a new interaction feature for VR controllers, adding OVR Multiview support to VR mode, creating a 3D sound engine, or adding A11y features for XR. This list is in no way exhaustive so feel free to propose something that you are personally interested in even if you don't see it here. One note is that you should have access to a device that supports p5.xr in some capacity. See device support here. Note: This is a low priority project this year.
Currently, there exists designs for mobile/responsive views that have not yet been implemented. This project would consist of implementing a subset of these views.
The web editor supports the usage of images, videos, and other assets. There are a few open tickets to improve this workflow:
Currently the p5.js website supports translations for Spanish and Simplified Chinese; however, the web editor includes no translations. This project would add the framework for adding internationalization, and add the mostly finished translations for Spanish.
Captured as processing/p5.js-web-editor#91. Currently, all projects are public. This project would allow users to make sketches private if they chose. A possible advanced feature could authorize certain users to see a sketch.
Currently the framework exists for adding tests, using Enzyme and Jest. This is a great project as it would make contributing to the web editor easier, and is self-contained and modular, which makes it easy for a variety of skill levels to work on it.
Processing is a flexible software sketchbook and a language for learning how to code. Since 2001, Processing has promoted software literacy within the visual arts and visual literacy within technology. There are tens of thousands of students, artists, designers, researchers, and hobbyists who use Processing for learning and prototyping.
Processing has a extensive community of users, with 250,000 unique users every month and up to 30,000 people using Processing every day, yet our contribution team is comparatively tiny! This is to say, by joining the Google Summer of Code program and contributing to Processing, you can make a huge difference in the experience of thousands of users, many of whom are exploring programming for the first time.
For more information on how to contribute to the Processing project, read our Contribution guidelines.
The goal of this project is to improve the error messages for Processing, making it more user-friendly, similar to the p5.js Friendly Error System (FES). The current system for catching and rewriting error messages in Processing could be more expansive and this project aims to address that.
This project aims to improve the library contribution workflow for Processing by automating the deployment of documentation and making it more accessible for contributors. The new library contribution process will be based on the Gradle-based library template contributed by Andres Colubri.
This could build upon the proof-of-concept Dart package by Andres Colubri that implements a few functions from the Processing API.
Many Android developers have moved to the Kotlin language since Google actively started promoting Kotlin as an alternative to Java. A GSoC project adapted the Android mode to support Kotlin, and released it as its own separate mode. Finding ways to continue supporting this mode or even integrating it back into the Android mode could help bring Android developers who prefer Kotlin into Processing.
The Android SDK includes an API to support input from game controllers, either bluetooth connected like the 8BitDo Zero 2 or built-in such as those found in Android handhelds like the Anbernic RG353V or Retroid Pocket 3+. It would be convenient to expose this API through a new library for the Android mode that uses Processing conventions for input events.
Work has been done at various points in time to seamlessly support video and sound in the Android mode: Processing-video-android library by Mohammad Umair Cassette library (sound) Android port of Processing’s sound library (branch in official’s processing-android repo) However, none of these projects have been updated recently, so it would be very important if some effort could be put into creating some supported and up-to-date set of libraries for video and sound.
As noted in this issue, the VR library in the Android mode is currently broken because Google stopped maintaining the original Google VR SDK. Google created a new SDK to support VR but in a much more limited fashion with the Cardboard SDK for Android NDK, but using this SDK would require a substantial amount of work to make it accessible through the mode so it can replicate the functionality offered by the VR library.
Image markers are an important feature of AR applications, and Google’s ARCore supports them. It should not be too difficult to add this into the AR library.
APDE (Android Processing Development Environment) is a quite popular Processing IDE for creating and running sketches on Android devices (more than 100K downloads on Google Play). It would be neat to work with APDE’s author to make sure it remains in sync with the latest version of the mode and core libraries.
The Processing for Android website is available at this moment in Spanish and English, so translations into other languages are needed. The Android mode's UI is in English, but recent work has been made recently to put all the message strings in a separate language file to facilitate translation of the UI into other languages.
Currently, the website includes a number introductory tutorials on a range of topics (installation, sensors, VR), but we need new tutorials bridging the gap from simple applications to more advanced topics.
We have started work on a native (C Python) version of Processing. While it doesn't have the advantage of library support that we get from the current Jython-based implementation, it opens up other ways to extend Processing with Python's syntax, features (numpy, scipy), and considerable base of support. This has been developed by Abhik Pal, Arihant Parsoya, Mark Zhang and Tushar Gupta during the Google Summer of Code 2017, 2018, 2019, 2020 and 2022. We hope to make additional progress in 2023.
Expected Outcomes: Add missing features to bring it on par with Processing (Java) API, performance improvements and optimizations especially on Mac/Linux, code examples and documentation. In particular, we would like to focus work on:
References:
Skills Required: Python, OpenGL
Possible Mentors: Tushar Gupta (@tushar5526)
Expected Size of Project: Either 175 or 350 hours
Difficulty: advanced
py5 is a new version of Processing for Python 3.8+. It makes the Java Processing jars available to the CPython interpreter using JPype. It can do just about everything Processing can do, except with Python instead of Java code.
The goal of py5 is to create a new version of Processing that is integrated into the Python ecosystem. Built into the library are thoughtful choices about how to best get py5 to work with other popular Python libraries such as numpy or Pillow.
Expected Outcomes:
Skills Required: Python coding & basic knowledge of py5
Expected Size of Project: Either 175 or 350 hours
Difficulty: Intermediate
References:
This project is looking for a mentor! If you are interested to become a GSoC mentor, please reach out on the Processing Foundation Forum.
Swift Processing is an iOS Swift Package that brings the joy of Processing into the world of Swift iOS. It aspires to demystify the app development experience and give creative coders the ability to create their own experiences on the iPhone.
Swift Processing is in its early stages of development and would benefit from more tutorial and example content being created to showcase what can be accomplished using the package.
Swift Processing is in its early stages of development and has a growing set of issues being organized through GitHub. https://github.com/jjkaufman/SwiftProcessing/issues
Additionally, beginner friendly abstractions for native iOS APIs could be created within Swift Processing to give creative coders new tools in the sketch environment. https://developer.apple.com/documentation
There are a number of smaller projects that could be handled by someone who doesn't necessarily want to dive all the way in to the code. Often these are isolated things that we've just never had the time to get around to. We track many of these with the help label. Please help!
| Back | FazBrowse Home | New Git URL |