Find open source projects actively accepting contributors. Search repositories, filter by program milestones, difficulty tags, or tech stack.
Use our Orbit AI Matcher to find out! Get instant matching scores based on your developer skills, preferred frameworks, and contribution experience.
Convert your selected open-source project into a winning GSoC, LFX, or Outreachy application using Proposal Studio.
This proposal focuses on enhancing the kotlinx-benchmark library API and user experience, fostering community growth and collaboration in Kotlin multiplatform development. The kotlinx-benchmark library is an open-source solution for benchmarking Kotlin code across multiple platforms. Although it provides a foundational structure, it currently lacks several essential quality-of-life features that would streamline its usage. This project aims to address these limitations by introducing fine-grained benchmark configuration options, ensuring feature parity between JVM and Kotlin/Native benchmarking, developing a command-line API, and integrating modern Gradle support. Furthermore, the project will enhance the library's documentation, integration tests, and examples to provide a comprehensive user experience. The anticipated outcomes of this project encompass: - Comprehensive documentation with practical usage examples - A user-friendly API that simplifies the benchmarking process - Versatile options for benchmarking Kotlin/JVM code across various platforms To successfully execute this project, proficiency in Kotlin and an understanding of Gradle internals are essential. By undertaking this project for Google Summer of Code, I aim to contribute significantly to the Kotlin ecosystem and promote a thriving open-source community centered around multiplatform development.
This project aims to implement a Visual Attribute Mapping System that enables users to automatically map node and edge attributes to visual properties within the GraphSpace interface. This system will allow users to generate meaningful graph visualizations where the appearance of graph elements directly reflects underlying attribute data — turning raw data into visual insight. There are two main components in this project: User Interface for Visual Attribute Mapping — A new Visual Attribute Mapping panel integrated into the GraphSpace Layout Editor. This interface will allow users to select graph attributes and map them to visual properties through an interactive configuration panel. Users will choose between Discrete Mapping (categorical attributes) and Continuous Mapping (numerical attributes). The interface will dynamically display configuration options based on the selected mapping type and visual property. Backend Support for Attribute Mapping — Backend services that read graph attributes, validate mapping configurations sent by the frontend, compute Cytoscape-compatible style rules, and store them via the existing layout update API. This component integrates with the existing update_layout controller and the style_json storage mechanism — requiring no new database tables.
This project aims to develop a Cables.gl plugin that compiles Faust DSP code into a WASM AudioWorklet in real-time. The plugin’s features will be focused on composability, modular I/O, and integration with Cables.gl’s WebGL backend. This is in addition to foundational development goals such as creating a pleasant UX, robustness, and elegance. This plugin would allow users to create DSP programs without boilerplate and have those programs integrate on a signal flow level with Cables.gl WebGL functionality. There are currently no tools that allow for this to my knowledge, this plugin would offer a unique opportunity for creative coding in both the audio and visual realms including simultaneously live-coding audio and visuals on one platform. This signal flow level integration would allow for passing arbitrary data to both the WebGL and WebAudio portions of Cables.gl programs, as well as between these different portions. This includes using shader buffers as audio input, enabling GPGPU for massively parallel audio computations, or audio output as sources for visual effects such as vertex displacement, SDF distortion, and other audio-reactive visual effects. This is in addition to simpler modulation schemes such as passing MIDI or OSC to both audio and graphics portions of programs in parallel or doing the same with Javascript sequencing.
<p>ABioTrans is a bio-statistical/informatics tool, developed in R for gene expression analysis. The tool allows the user to directly read RNA-Seq data files deposited in the Gene Expression Omnibus or GEO database. It provides easy options for performing very commonly used statistical techniques, namely, Pearson and Spearman rank correlations, Principal Component Analysis (PCA), k-means and hierarchical clustering, Shannon entropy, Noise (square of the coefficient of variation), differential expression (DE) analysis, and gene ontology classifications</p> <p>This project aims to develop the 2nd version of ABioTrans. ABioTrans version-2 will be web-based and will provide extensive analysis options to the gene expression analysis results such as pathway enrichment analysis, gene function, t-SNE, Protein Protein Interaction, SOM , SVM as well as publication-ready visualization options including network visualization using Cytoscape.JS As the current version of Abiotrans is not online, it gets very difficult and time consuming process for the biologist who want to perform few analysis. As it's a very time consuming & tedious process. So, taking it online will solve a huge problem.</p>
<p>The Page Forms extension provides a spreadsheet-style editing display in two places-</p> <ol> <li>In the page Special Pages: MultiPageEdit - Using this user can edit multiple pages that are using a particular template in a spreadsheet-style display which makes it easier to modify the pages or add new pages.</li> <li>In regular forms, with the form definition setting "display=spreadsheet"- Using this user can edit the values of different fields of multiple instances of the template within the same page in a spreadsheet-style display.</li> </ol> <p>Currently, the spreadsheet-style display uses the jExcel JavaScript library, jExcel provides a number of input types (dropdowns, dates, etc.) but it does not by default allow for autocompletion using an arbitrary list of values. So, this project will allow autocompletion using "values from external data" and "value dependent on"(autocompletion where one field's value depends on what was chosen for previous fields). This auto-completion will support all the pages that match a specific category, Cargo field, SMW property, or SMW concept. This autocompletion will be implemented with WikiMedia's OOUI which will help in maintaining consistency across all other extensions too.</p>
In Blender, geometry nodes provide the user with a visual scripting interface to manipulate 3D geometry, allowing the creation of custom modifiers and procedural tools. In most cases, the input of geometry nodes is the source geometry to which the geometry node is attached. File import nodes would allow more source data to be fed into geometry nodes, expanding the use case for geometry nodes. Currently, Blender has source nodes for primitive shapes, allowing the user to inject more geometric data into the geometry nodes graph. The user can inject data into the geometry node graph with dedicated file import nodes. Dynamically loading file formats like STL, OBJ, Alembic, and CSV with a geometry node would simplify everyday data visualization tasks. Also, it would reduce memory consumption on disks because the data would not have to be stored in a .blend file. As part of this year's Google Summer of Code, I'll be aiming to deliver the following 1) Multiple file import nodes for STL, OBJ, Alembic, PLY, and CSV formats 2) Refactoring for existing bf_io_* projects to expose Mesh loading functions 3) New importer project for CSV import support 4) Technical and user documentation Integrated tests
<p>Open Event Orga App is an Android client for the Open Event Orga API for event management. The app allows organizers to sign up and log in, view sale analytics, scan QR code and check in attendees, manage and create tickets.</p> <p>The app also contains following features:</p> <ul> <li>Sales overview with graphs</li> <li>More fluent QR scan workflow</li> <li>Background job scheduling for offline support</li> <li>Event and Organizer Info</li> <li>Uniform and modern material look</li> </ul> <p>We have also followed best practices for Android and maintained high standards in terms of code quality and structure so that there is no compromise in app performance and stability:</p> <ul> <li>Model View Presenter (MVP) architecture</li> <li>Use of RxJava for asynchronous programming</li> <li>Use of abstractions for ease in testing</li> <li>Dependency injection using Dagger</li> <li>Distributed code following separation of concerns</li> <li>High quantity of unit tests for models and presenters for high code coverage</li> </ul>
<p>GitHub Importer is an XWiki Extension which imports GitHub pages and wikis into XWiki.</p> <p>The extension provides the following features:</p> <ul> <li>Ability to import GitHub wiki pages into XWiki.</li> <li>Ability to convert the files content to Default syntax (XWiki Syntaxes Administration).</li> <li>Ability to use <a href="https://developer.github.com/v3/auth/#basic-authentication" target="_blank">Basic Authentication</a> for GitHub page repositories that are not public.</li> <li>Ability to create pages hierarchically in XWiki according to the sidebar (_Sidebar.md).</li> <li>Ability to import through file / directory.</li> <li>Supports <a href="https://www.mediawiki.org/wiki/MediaWiki" target="_blank">MediaWiki</a> and <a href="http://www.wikicreole.org/wiki/Home" target="_blank">Creole</a> syntax files.</li> <li>Fixes relative links (with limitations) while converting syntax from Markdown to XWiki.</li> </ul> <p>More details are available on the <a href="https://extensions.xwiki.org/xwiki/bin/view/Extension/GitHub%20Importer%20Application/" target="_blank">Extension page</a>.</p>
Scikit-bio offers a great toolkit for working with biological data that has a tree-like structure. Although the current implementation, TreeNode, can accommodate a large variety of use-cases, its pointer-based nature limits its scalability to large trees with billions or even trillions of nodes. This project aims to remedy this problem by implementing a succinct data structure for trees based on its balanced parentheses representation, such that the memory usage and the time required for operations are minimized. There are two main components to this project. The first component pertains to the implementation of the data structure proposed in using Numba and NumPy based on improved-octo-waddle, a previous implementation using Cython. The other component relates to integrating the new data structure into the back-end of the existing TreeNode class within the library to enable compatibility with the existing APIs. The core deliverables include: an implementation of the new data structure that can be interfaced via TreeNode, an extensive suite of tests for correctness and benchmarking to ensure performance uplifts, and documentation to guide users on the usage of the new data structure. As a potential extension, GPU support will be investigated along with the exploration of an alternative solution proposed by Córdova, J. and Navarro, G. (2016).
Virtual niche simulations are a powerful tool for testing ecological theory, and nicheR provides an integrated, R-native framework for ellipsoid-based virtual niche construction, prediction, and data generation. This project will deliver a Shiny graphical user interface for nicheR, making these tools accessible to researchers regardless of their programming background. The app will guide users through a complete virtual niche workflow across six tabs: data input, niche design, prediction, bias preparation, data sampling, and reproducibility. Throughout, contextual messages will explain the ecological meaning of key parameter choices, ensuring users understand the theory behind what they are building rather than just clicking through steps. A key feature is that every interactive session generates a fully reproducible R script, so users can transition seamlessly from the GUI to scripted workflows. Deliverables include a fully functional Shiny app packaged within nicheR with a run_app() launcher, test cases for each module, and two vignettes. By lowering the technical barriers to ellipsoid-based niche modeling, this project expands access to rigorous, theory-driven tools for ecologists, conservation practitioners, and students across the R community.
<p>There are several applications where we need to work with ordered data (e.g. Time-series). This includes financial data, climate data, radio signals, genome data in bioinformatics etc. Often it is of interest to find patterns or structure in this data and to detect abrupt changes in structure to model the data effectively. There are a class of dynamic programming algorithms that can solve the optimal partitioning problem and find optimal segments given a statistical criteria.</p> <p>A quadratic time algorithm described in <a href="https://link.springer.com/article/10.1007/s11222-016-9636-3" target="_blank">https://link.springer.com/article/10.1007/s11222-016-9636-3</a> is one such algorithm that solves the optimal partitioning problem given square error loss function.<br> Currently there are no R packages available that provide a reference implementation to this algorithm.</p> <p>This project provides a C++ reference implementation to this optimal partitioning algorithm in an R package (opart) using square error loss function which is easy to understand and can be modified to support different loss functions when developing other change-point models.</p>
<p>Currently the following important functions of the HPX API:</p> <ul> <li><code>hpx::util::unwrapped</code></li> <li><code>hpx::wait_(all|any|each|some)</code></li> <li><code>hpx::when_(all|any|each|some)</code></li> <li><code>hpx::dataflow</code></li> </ul> <p>only offer nonsatisfiable capabilities for nested <code>hpx::future</code> types inside homogeneous and heterogeneous containers.</p> <p>In order to fully support the requirements for accepting argument types described in <a href="https://github.com/STEllAR-GROUP/hpx/issues/2456" target="_blank">#2456</a>, <a href="https://github.com/STEllAR-GROUP/hpx/issues/1404" target="_blank">#1404</a>, <a href="https://github.com/STEllAR-GROUP/hpx/issues/1400" target="_blank">#1400</a> and <a href="https://github.com/STEllAR-GROUP/hpx/issues/1126" target="_blank">#1126</a> this proposal intends to extend the capabilities of the functions listed above to access nested <code>hpx::future</code> types as well as unwrapping such types. When the proposal is implemented, all the functions listed above should accept the same set of arguments (unification).</p>
<p>DeepChem has enabled powerful and practical applications for machine learning in many disciplines of the natural sciences. While its name recognizes its historical origins as a tool for analyzing chemical molecules, its reach has more recently broadened to encompass neighboring fields such as materials science and biology. The goal of this proposal is to expand DeepChem’s burgeoning infrastructure to better support protein modeling.</p> <p>This proposal will add a simple codon featurizer to DeepChem, which will be the first DeepChem featurizer capable of directly processing RNAs and protein sequences.</p> <p>It will also add new model classes to DeepChem’s models directory. These classes will act as wrappers for models in Facebook’s Evolutionary Scale Modeling (ESM) repository. They will enable DeepChem users to use ESM’s Multiple Sequence Alignment transformer and Protein BERT models to perform efficient, scalable transformer learning.</p> <p>Also including carefully planned additions to DeepChem’s documentation, unit tests, tutorials, and the MoleculeNet benchmarking suite, this proposal will empower DeepChem users to perform large scale protein modeling while staying within our ecosystem.</p>
Many HPC applications rely on GPUs for fast and efficient computation. At the same time, there is an effort to bring more programmability and portability when writing code for the GPU. One of such efforts is the implementation of the libc and libc++ in LLVM project for execution on the accelerator itself. This allows standard host applications to run on the GPU automatically, without modification to the user code. One consideration of such an approach is that some functions are not natively supported on the GPU and rely on RPC calls to the host. This poses a limitation on the bandwidth of data transfer. Thus, this project aims to improve current file operations triggered by GPU, leveraging the new Linux io_uring interface. io_uring allows the program to register a queue to asynchronously request file operations and pool the completion by interacting with such a queue. Apart from registering the queue, requesting and polling operations do not require a syscall, making it faster and more flexible than regular POSIX operations or Linux AIO calls. We will map and register/pin a memory region on the GPU side and use that region for io_uring interaction, driven by the GPU. We expect such a process to deliver more performance than current RPC round-trips to complete I/O transfers, which require a CPU polling thread for each request and do not come close to the theoretical bandwidth of PCIe interfaces.
NetBSD allows the execution of Linux binaries with compat_linux, a NetBSD kernel module that translates Linux system calls into NetBSD system calls. But, not all of Linux's system calls have been implemented in compat_linux, which means that not all Linux applications can be ran on NetBSD. One relevant application that can't be ran is bubblewrap, a tool for constructing sandbox environments. By tracing the system calls executed by the bubblewrap Linux binary and comparing with the ones in compat_linux's source code, we can identify the system calls that need to be implemented. One required but currently missing Linux system call is unshare, a system call to create Linux namespaces, which provide isolation of multiple parts from the host, this makes it a complicated system call to emulate. Unshare will be the main system call of this project but there will be others as well, such as the capabilities family of system calls, we will study each system call individually to understand if we need to create a completely new system call, or if we can simply translate the Linux system call's arguments to ones used by an equivalent NetBSD system call. The successful completion of this project will result in a patch to compat_linux, which will allow bubblewrap to be ran on NetBSD under compat_linux, bringing a new way of sandboxing to NetBSD.
<p>The new package "Surface mesh topology" will be available in the next CGAL release. It is concerned with the computation of topological invariants of curves on surfaces. The goal of this project is to add a new functionality to this package in order to decide if an input cycle on a given surface can be continuously deformed to a simple curve, i.e. a curve without self-intersection. The goal is to implement the algorithm described in this paper <a href="https://arxiv.org/pdf/1511.09327" target="_blank">https://arxiv.org/pdf/1511.09327</a> (Computing the Geometric Intersection Number of Curves. Vincent Despré and Francis Lazarus. Journal of the ACM 66(6), Article 45, Nov. 2019.). The implementation will strongly rely on the current package functionality for the homotopy test. Another interesting possibility could be to add a new functionality to this package in order to repair mesh surfaces that contain undesired non-trivial topology (small handles or tunnels). A first step is to compute a shortest cycle that is essential on a given surface, i.e. that is neither deformable to a point nor to a boundary cycle of the surface. See Computing the shortest Essential Cycle. P. Worah and J. Erickson. Discrete and Computational Geometry, 2010.</p>
<p>My proposal is about improving the current search functionality in GNOME Logs.</p> <p>The current search functionality doesn't have any graphical option to specify from which journal field (PID, GID, process name, systemd unit etc.) the user would like to search the logs. Also, it lacks a filter to specify the date-time (timestamp) range of the journal between which the user would like to see the logs.</p> <p>So, for this purpose, a search popover will be added besides the search entry where the user can select the journal field and the journal timestamp range filters. The user will also be able to enter a custom journal timestamp range in a submenu in the search popover. The search popover will also support an option to match the exact string or match in any part of the entered string.</p> <p>A search provider will be implemented for GNOME Logs to expose the search results to GNOME Shell using a shell search provider D-Bus API. The user can see the logs related to the entered search term in the GNOME Shell overview using this functionality.When the user clicks on a search provider result, a new window will open showing the details of the selected log.</p>
For the last 200 years research into human cognition and decision-making has revolved around rational choice theory, which assumes that actors are utility maximizers capable of searching and finding rational and optimal decisions. However human behavioral data doesn’t support the assumptions that we have infinite time nor infinite cognitive energy to search the full space of candidate choices to produce optimal decisions. Take for example a hiker, who has an infinite number of paths to choose from. It's irrational to assume that the hiker is capable of fully evaluating each of the infinite paths available to them to then choose the most rational/ optimal path. And yet that is the operating assumption for most modern cognitive models. To remedy this problem, I propose three axiomatic principles of energy-efficient decision making, along with an optimal-control based model and Deep Q learning model that capture those principles. I hope that a formalization of my theory of energy-efficient decision making along with the open-source python library we develop can be used by researchers in private and academic settings to develop more accurate computational models of human decision making, that can be used to model agent behavior in a number of fields ranging from market behavior to crowd dynamics, along with improving LLM infrastructures.
This project focuses on improving the Geometry Verification and Validation (V&V) GUI in Qt for the Arbalest application in BRL-CAD. Currently, the prototype GUI provides basic validation output but has several usability limitations such as truncated full-path display, flat result presentation, and limited export options for validation results. These issues make it difficult for users to clearly interpret geometry validation outcomes. In this project, I plan to improve the usability and clarity of the existing V&V GUI by restructuring how validation results are displayed, fixing the full-path column visibility issue, and adding grouped result visualization for easier navigation. I will also implement a downloadable validation report feature that allows users to export results in structured formats such as TXT or JSON, making validation outputs easier to review and share. The expected deliverables include updating the existing V&V GUI implementation to work with the current Arbalest codebase, improving the results panel layout based on a proposed UI mockup, and adding a report generation module integrated into the GUI workflow. These improvements will make the validation interface more practical and user-friendly while keeping the scope aligned with the current prototype architecture.
<p>The first part of this project involves improving certain parts of Zulip's webhooks/integrations system.</p> <p>1.Make it much easier to quickly and conveniently test any incoming webhook integrations. This will make things a whole lot easier for developers creating or reviewing new bots. I plan on creating a web-based GUI for this purpose.</p> <p>2.Enable us to store the headers for each sample payload alongside their fixtures. But at the same time allow them to be dynamically generated (instead having them necessarily be fixed/static).</p> <p>3.Allow user's to configure their incoming webhooks bots based on certain parameters that we can specify on an integration-per-integration basis.</p> <p>4.Create a systematic and convenient way to allow integrations to make a callback request to a third-party API to gain extra information about events as required.</p> <p>5.Making miscellaneous improvements and tweaks that pop up over the course of the summer to specific integrations. Add new integrations as needed.</p> <p>The second part of this project involves improving Zulip's OpenAPI documentation system (the supporting code and tests, not necessarily writing the actual documentation itself).</p>
Prerequisites: Ubuntu and ROS 2 development environment, no need for specialized hardware. Necessary programming skills: Familiarity with C/C++/Python, CMake, ABI/API. Difficulty level: Medium. Potential mentors: Tomoya Fujita Expected size: 100 hours to 150 hours. Expected outcome: A ROS 2 command line interface ros2cli with doctor sub-command and ros2_documentation. Detailed description: Currently, the ROS 2 doctor subcommand, ros2 doctor, is lacking a lot of useful information, such as ROS environment variables, RMW-specific environment variables, and configuration and service information (number of endpoints, QoS compatibility status, etc). This information is really important and useful for debugging issues with ROS 2, and would greatly improve our ability to support issues reported by our user community. In other words, adding this new information to our existing ROS 2 Doctor command would accelerate community communication and make bug reports much more precise! Aligned with ros2cli development, this project also targets the implementation of improved documentation on how to create an issue report with a new issue template. Reference pull requests: Add default github issue templates, add: get clients, servers info
The 2010s decade marked a beginning for widespread compiler testing with the release of programs like Csmith, a C program generator that since its release has found and reported over 400 compiler bugs. However, as highlighted by a recent study, the research on compiler testing has critically neglected the front-end component of compilers, leaving unfound bugs in the type checking procedure of compilers. More specifically, this could lead to the compilers of statically-typed languages, which utilize features such as type inference, both accepting erroneous programs and rejecting correct ones. Hephaestus is a tool designed to test the compilers of three languages, namely Java, Kotlin, and Groovy. It has already successfully detected over 150 bugs in the compilers of these languages. I propose a way to extend Hephaestus for it to be able to successfully test and detect bugs in the compiler of TypeScript. This can be a great contribution to the user-base and community of TypeScript, a language that has risen in popularity and usage in the past years. Hephaestus detects bugs by: 1. generating semantically-valid programs that (a) utilize parametric polymorphism and (b) are abstract 2. generating these programs in an intermediate representation (IR), an OOP language that supports parametric polymorphism and type inference 3. using translators to convert the abstract IR program to the desired language.
NiiVue is a versatile tool for visualizing and handling neuroimaging data, but insufficient documentation creates friction in using it in deploying workflows. This makes it challenging for developers to integrate, reducing the usability of NiiVue. As demand grows for secure and efficient web-based processing, this project aims to provide a demo that helps developers implement and customize cloud providers and analysis tools for scalable, secure neuroimaging workflows. This project will develop a full-stack solution for scalable neuroimaging analysis, integrating client-side preprocessing with Niimath and visualization using NiiVue. A PostgreSQL database will be designed to manage neuroimaging tasks and results. Two backend approaches will be tested: one using Flask with Nipype to interface with neuroimaging tools like FSL and FreeSurfer, supporting parallel processing, and another using Flask with containerized neuroimaging tools managed via Docker orchestration (Kubernetes/ECS) for greater flexibility. The system will be deployed on AWS with secure infrastructure, including EC2 and S3, ensuring data security through encryption and access control. A minimal demo will showcase the workflow using FSL BET or FreeSurfer, accompanied by clear documentation for easy replication and deployment by developers with their own cloud provider.
This project aims to improve how Asyncapi objects are visualized in AsyncAPI by introducing a new preview feature. By combining Markdown and MermaidJS Class Diagrams, and flowcharts, users can seamlessly integrate with AsyncAPI schema and Avro (.avsc) files, creating dynamic and interactive representations of object structures. The project focuses on building clear class diagrams, and flowcharts with MermaidJS, connecting entities with channels, schemas, and operations, and providing additional info for a visually intuitive understanding of message payloads in AsyncAPI. I have planned to take the following action points to accomplish this goal: 1. Set up the project by installing all necessary dependencies and organizing the structure. 2. Develop a new Preview Panel resembling the HTML rendering panel in asyncapi-react standalone. 3. Integrate a components folder to facilitate markdown generation for all asyncapi objects, including mermaid diagrams. 4. Implement mermaid support for diagrams and utilize EJS as a template. 5. Introduce a tool for converting HTML to Markdown, such as turndown, to enable export functionality. Additionally, I plan to incorporate flowcharts, Class Diagrams, and display relationships among AsyncAPI specifications objects. A fully-fledged Preview Panel of Markdown for VS-Code will become the outcome of this project.