Skip to content

Project List

Jump to bottom Edit New page
Raphaël de Courville edited this page Apr 15, 2023 · 467 revisions

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.

Summer 2023

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.

Previous year GSOC reports

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.

Projects Table of Contents

Project ideas

🌸 p5.js

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.

Resolve Issues / Fix Bugs on Area:Core Issues (High Priority!)

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.

  • Expected Outcomes: Improvement of p5.js Area:Core code and documentation
  • Skills Required: JavaScript, familiarity with Github or version control
  • Possible Mentors: Kenneth Lim, Nick Briz, Tanvi Kumar, Aren Davey
  • Expected Size of Project: Either 175 or 350 hours
  • Difficulty: intermediate

Resolve Issues / Fix Bugs on Area:Image Issues (High Priority!)

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.

  • Expected Outcomes: Improvement of p5.js Area:Image code and documentation
  • Skills Required: JavaScript, familiarity with Github or version control
  • Possible Mentors: Caleb Foss, So Sun Park, Aren Davey
  • Expected Size of Project: Either 175 or 350 hours
  • Difficulty: intermediate

Resolve Issues / Fix Bugs on Area:Typography Issues (High Priority!)

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.

  • Expected Outcomes: Improvement of p5.js Area:Typography code and documentation
  • Skills Required: JavaScript, familiarity with Github or version control
  • Possible Mentors: Kevin Yeh, Paula Isabel Signo
  • Expected Size of Project: Either 175 or 350 hours
  • Difficulty: intermediate

Resolve Issues / Fix Bugs on Area:Events Issues (High Priority!)

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.

  • Expected Outcomes: Improvement of p5.js Area:Events code and documentation
  • Skills Required: JavaScript, familiarity with Github or version control
  • Possible Mentors: Kenneth Lim, Tanvi Kumar
  • Expected Size of Project: Either 175 or 350 hours
  • Difficulty: intermediate

Resolve Issues / Fix Bugs on Area:Color Issues (High Priority!)

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.

  • Expected Outcomes: Improvement of p5.js Area:Color code and documentation
  • Skills Required: JavaScript, familiarity with Github or version control
  • Possible Mentors: Nick Briz, Aren Davey
  • Expected Size of Project: Either 175 or 350 hours
  • Difficulty: intermediate

Improve Friendly Error System (FES) and documentation (High Priority!)

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:

  1. Resolve Issues / Fix Bugs on Friendly Errors Issues (High Priority!): We highly recommend selecting several open issues tagged with "Friendly Errors" and packaging them together as a GSoC proposal
  2. New FES features (Low priority!): Proposing and implementing new features, including adding a new language translation to the FES.
  • Expected Outcomes: Improvement of p5.js FES and documentation
  • Skills Required: JavaScript, familiarity with Github or version control
  • Possible Mentors: Alm Chung, Nick Briz
  • Expected Size of Project: Either 175 or 350 hours
  • Difficulty: intermediate, advanced

Improving p5.js WebGL/3D functionality (High Priority!)

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:

  • Resolve Issues / Fix Bugs on Area:WebGL Issues (High Priority!): We highly recommend selecting several open issues tagged with "Area:WebGL" and packaging them together as a GSoC proposal
  • Support for image-based lighting: Coming up with positions and colors and falloffs for 3D lighting is very time-consuming. If one could use an image of an environment, it would allow people to quickly add cohesive, natural lighting to their 3D scenes. (Resources: [1], [2])
  • Experimental shader building library: Right now, updatePixels() is an easy-to-learn way to make pixel based effects. Unfortunately, these start to slow down on large canvases. Shaders have the potential to run much more smoothly, but since they are a completely separate language, they are comparatively hard to learn. Do you have ideas on how to make shaders easy to get started with? While they may never be as easy as editing pixels, can we get it closer? Proof-of-concept ideas can be prototyped in a library for p5.

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.

  • Expected Outcomes: Implementation of expanded functionality or performance improvement for WebGL mode, updated documentation, and tests
  • Skills Required: JavaScript, experience with WebGL or GL programming, familiarity with Github or version control
  • Possible Mentors: Dave Pagurek, Adam Ferriss, Austin Slominski, So Sun Park
  • Expected Size of Project: Either 175 or 350 hours
  • Difficulty: intermediate, advanced

Support beginContour/endContour in p5.js WebGL mode (High Priority!)

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.

  • Expected Outcomes: Implementation of beginContour and endContour that works with WebGL's beginShape modes
  • Skills Required: JavaScript, experience with WebGL or GL programming, familiarity with Github or version control
  • Possible Mentors: Dave Pagurek
  • Expected Size of Project: 175 hours
  • Difficulty: intermediate

Support shader-based filters in p5.js (High Priority!)

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.

  • Expected Outcomes: Implementation of filter(yourShader), and time permitting, integration of existing shader implementations of existing filters
  • Skills Required: JavaScript, experience with WebGL or GL programming, familiarity with Github or version control
  • Possible Mentors: Dave Pagurek, Adam Ferriss, Austin Slominski
  • Expected Size of Project: 350 hours
  • Difficulty: advanced

Add the ability to create p5.Geometry using existing drawing commands (High Priority!)

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.

  • Expected Outcomes: Implementation of methods to create
  • Skills Required: JavaScript, experience with WebGL or GL programming, familiarity with Github or version control
  • Possible Mentors: Dave Pagurek, Adam Ferriss, Austin Slominski
  • Expected Size of Project: 350 hours
  • Difficulty: intermediate, advanced

Expanding p5.js accessible outputs (High Priority!)

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!)

  • Expected Outcomes: Updated p5.js accessibility functions & well documented new accessibility functions
  • Skills Required: JavaScript, HTML, GitHub version control & user testing. If interested in 3D graphics and accessibility, WebGL experience is required.
  • Possible Mentors: Claire Kearney-Volpe, Caleb Foss
  • Expected Size of Project: Either 175 or 350 hours
  • Difficulty: intermediate, advanced

Web Accessibility on p5js.org and documentation (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

  • Expected Outcomes: Updated p5js.org tutorials, documentation, and learn examples. Accessibility audit of the p5 website.
  • Skills Required: JavaScript, HTML, CSS, communication skills
  • Possible Mentors: Claire Kearney-Volpe, Caleb Foss, Paula Isabel Signo
  • Expected Size of Project: Either 175 or 350 hours
  • Difficulty: beginner, intermediate

Imagining new screen-reader accessible p5.js canvas descriptions using machine learning (Medium Priority!)

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.

  • Expected Outcomes: A prototype of p5.js accessibility functions that create screen-reader accessible descriptions of the canvas
  • Skills Required: JavaScript, HTML, GitHub version control & user testing.
  • Possible Mentors: Claire Kearney-Volpe
  • Expected Size of Project: Either 175 or 350 hours
  • Difficulty: intermediate, advanced

Continued development of p5.js Teach page (Low Priority!)

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.

  • Expected Outcomes: Update of p5js.org Teach page, with a focus on enhancing the following, but not limited to: 1) accessibility to teaching resources, 2) teacher & learner engagements (e.g. teach case submission form), 3) workflow for maintenance among and beyond Teach page stewards (@Gracia-zhang, @SarveshLimaye)
  • Possible Mentor: Inhwa Yeom
  • Skills Required: JavaScript, HTML, CSS, GitHub version control & user testing.
  • Expected Size of Project: Either 175 or 350 hours
  • Difficulty: intermediate, advanced

Continued development of p5.js Showcase (Low Priority!)

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.

  • Expected Outcomes: Updated set of p5.js examples for p5.js website showcase
  • Skills Required: JavaScript, HTML, CSS, communication skills
  • Possible Mentors: Tanvi Kumar, and TBD
  • Expected Size of Project: Either 175 or 350 hours
  • Difficulty: intermediate

Improve p5.xr library (Low Priority!)

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.

  • Expected Outcomes: Improvement to the p5.xr library through the implementation of additional features and/or performance enhancements.
  • Skills Required: JavaScript, Github, Node, WebGL, GLSL
  • Possible Mentors: Stalgia Grigg
  • Expected Size of Project: Either 175 or 350 hours
  • Difficulty: advanced

💕 p5.js Web Editor

Mobile/Responsive Design Implementation

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.

  • Should the focus be on sharing, editing, or both?
  • What does a simplified version of the editor look like that works on mobile?
  • What are iterative steps to get here?
  • Offline mode could help with this.
  • Expected Outcomes: Improved functionality of web editor on tablets and phones
  • Skills Required: UX/UI Design, Javascript, HTML, React, Github
  • Possible Mentors: Shuju Lin, Linda Paiste, Austin Slominski
  • Difficulty: Intermediate

Asset Uploading Improvements

The web editor supports the usage of images, videos, and other assets. There are a few open tickets to improve this workflow:

Internationalization and Localization

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.

  • Expected Outcomes: Integration of a React internationalization library, and addition of one translation
  • Skills Required: JavaScript, HTML, React, Github
  • Possible Mentors: Rachel Lim
  • Difficulty: Intermediate

Add Ability to Make Sketches Private

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.

  • Expected Outcomes: a public/private switch for all sketches
  • Skills Required: JavaScript, HTML, CSS, Github
  • Possible Mentors: Rachel Lim, Aren Davey
  • Difficulty: Intermediate

Accessibility

  • Reviewing current state of application for keyboard users
  • Reviewing functionality with p5.accessibility library
  • Color contrast review (there are some open issues)
  • Possible Mentors: TBD
  • Difficulty: Intermediate

Contributor Experience Improvements

  • Design principles document, as reference p5.js design principles
  • Issue label management
  • Developer/Designer Outreach
  • File Structure Documentation
  • Possible Mentors: Paula Isabel Signo
  • Difficulty: Easy to Intermediate

Adding Test Coverage

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.

  • Expected Outcomes: Testing files added to web editor repository
  • Skills Required: JavaScript, HTML, CSS, Github
  • Possible Mentors: Rachel Lim
  • Difficulty: Intermediate

💙 Processing

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.

Friendlier Error Messages for Processing

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.

  • Expected Outcomes: An improved error messaging system in Processing that is more user-friendly and provides more informative error messages.
  • Skills Required: Knowledge of Java and some technical writing ability.
  • Possible Mentor: Sam Pottinger
  • Expected Size of Project: 175 hours
  • Difficulty: Intermediate

Improving the Library Contribution Workflow for Processing

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.

  • Expected Outcomes: Upon completion of the project, the library contribution process will be streamlined and modernized, with automated deployment of library documentation to GitHub Pages and a more accessible process for submitting libraries for review. The library contribution documentation should be updated to reflect those changes, including a migration guide to help library creators move from the old Ant-based template.
  • Skills Required: Knowledge of GitHub Workflows, and GitHub Pages. Familiarity with JavaDoc and Gradle are a plus.
  • Possible Mentors: Elie Zananiri
  • Expected Size of Project: 175 hours
  • Difficulty: Intermediate

Cross-platform mobile dev in Dart (Flutter mode)

This could build upon the proof-of-concept Dart package by Andres Colubri that implements a few functions from the Processing API.

  • Expected Outcomes:
    • A github repository with code, examples, and documentation.
    • Packaging and release of mode via the Processing contributions manager
  • Skills Required: Dart Development
  • Possible Mentors: Andonaq Grozdani
  • Expected Size of Project: Either 175 or 350 hours
  • Difficulty: advanced

Update the Shader mode for Processing4

  • A mode to code GLSL shaders in the PDE was created by Izza Tariq but it hasn't been updated to work with Processing4.
  • Expected Outcomes:
    • A Pull Request or github repository with library code, examples, and documentation.
    • Packaging and release of library via the Processing contributions manager
  • Skills Required: Java Development
  • Possible Mentors: Andres Colubri
  • Expected Size of Project: Either 175 or 350 hours
  • Difficulty: intermediate

🤖 Processing for Android

Kotlin support (Android Mode)

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.

  • Expected Outcomes:
    • A pull request to the Processing for Android repository with code, examples, and documentation.
  • Skills Required: Java/Kotlin Development
  • Possible Mentors: Aditya Rana
  • Expected Size of Project: Either 175 or 350 hours
  • Difficulty: intermediate or advanced

Game controller library (Android Mode)

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.

  • Expected Outcomes:
    • A GitHub repository with code, examples, and documentation.
  • Skills Required: Java/Kotlin Development
  • Possible Mentors: Andres Colubri / Aditya Rana
  • Expected Size of Project: Either 175 or 350 hours
  • Difficulty: intermediate or advanced

Updated sound/video libraries (Android Mode)

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.

  • Expected Outcomes:
    • A GitHub repository with code, examples, and documentation.
  • Skills Required: Java/Kotlin Development
  • Possible Mentors: Andres Colubri / Aditya Rana
  • Expected Size of Project: Either 175 or 350 hours
  • Difficulty: intermediate or advanced

New VR library (Android Mode)

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.

  • Expected Outcomes:
    • A GitHub repository with code, examples, and documentation.
  • Skills Required: Java/Kotlin Development
  • Possible Mentors: Andres Colubri / Aditya Rana
  • Expected Size of Project: Either 175 or 350 hours
  • Difficulty: intermediate or advanced

AR image markers (Android Mode)

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.

  • Expected Outcomes:
    • A GitHub repository with code, examples, and documentation.
  • Skills Required: Java/Kotlin Development
  • Possible Mentors: Andres Colubri / Aditya Rana
  • Expected Size of Project: Either 175 or 350 hours
  • Difficulty: beginner or intermediate

Other Android ideas

APDE updates

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.

Processing for Android website translations

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.

New Processing for Android tutorials

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.

🐍 Processing Python

Native Python and Processing (p5py)

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:

    • Skia was integrated as an experimental backend renderer (Work Report) which can now be used to implement the missing APIs for 2D sketches.
    • Refactor whole docs to update examples for new API changes and missing doc examples for Skia Renderer. (Integrating Skia milestone)
    • Improving font support.
    • Investigate porting popular Processing libraries to p5py. For instance, adding video and audio support, GUI support using tkinter, etc. You can refer to p5.js ecosystem for ideas.
    • Fixing existing issues
    • Adding type-hints for the library
    • Adding a unit testing suite for each module
    • Any other ideas are also welcome!

  • References:

  • Skills Required: Python, OpenGL

  • Possible Mentors: Tushar Gupta (@tushar5526)

  • Expected Size of Project: Either 175 or 350 hours

  • Difficulty: advanced

Processing for Python 3.8+ with JPype (py5)

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.

Develop and Organize py5 Example Code

  • Expected Outcomes:

    • Provide py5 example code to users through the py5 Thonny Extension plugin. This project idea has two parts:
      • Add an interface to the Thonny extension plugin that has similar functionality as the Processing PDE’s example code interface
      • Organize and expand upon the existing py5 example code to create a comprehensive collection of example code for coders of all skill levels

  • Skills Required: Python coding & basic knowledge of py5

  • Possible Mentors: @villares & @hx2A

  • Expected Size of Project: Either 175 or 350 hours

  • Difficulty: Intermediate

  • References:

🦅 Swift Processing

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.

Tutorial / Example Content

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.

  • Requirements: Access to Mac hardware suitable for iOS development
  • Skills Required: Swift
  • Possible Mentors: [TBD]
  • Expected Size of Project: Either 175 or 350 hours
  • Difficulty: Beginner / Intermediate

Library Development

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

  • Requirements: Access to Mac hardware suitable for iOS development
  • Skills Required: iOS Development
  • Possible Mentors: [TBD]
  • Expected Size of Project: Either 175 or 350 hours
  • Difficulty: Beginner / Intermediate

👷‍♀️ Ongoing Projects

Processing

OpenGL Ideas

  • Central repository of shaders, ideally linked with the editor. We could also incorporate support for a shader interoperability spec, such as the Interactive Shader Format, which would allow Processing users to share shaders with other applications for creation of interactive graphics.
  • A new shader tutorial. The original PShader tutorial by Andres Colubri was not included on the new website because it wasn't up to date.
  • An advanced shader tutorial following the introductory one is also needed.
  • A library for advanced shaders (lighting, geometry, tessellation), that handles the low-level stuff. Right now it is possible to create geometry or tessellation shaders by using the GL3/GL4 API, but would be nice if that could be handled automatically by this hypothetical library. Also integration with the repository suggested above would be neat.
  • A library to do calculations on the GPU using the OpenCL API. This library could work in coordination with the OpenGL renderers to allow handling large particles systems, very complex dynamic meshes, etc. A prototype OpenCL library for an early Processing 2.0 alpha release, which implemented traer.physics solvers with OpenCL kernels, is available here.

Libraries

  • Is there something you think Processing should do, but it currently doesn't? Processing can be extended through Libraries and we're always looking for contributions. Instructions for building libraries are here on the GitHub wiki.
  • The libraries that allow Processing to communicate with the MS Kinect could use work and updating. See: includes openkinect.

Tools for the Processing Development Environment (PDE)

Smaller, Isolated Projects and Fixes

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!

Add a custom footer
Add a custom sidebar
Clone this wiki locally