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.
Drupal's admin interface is powerful, but finding the right configuration page — especially for newer users or developers who don't work in Drupal daily — often means digging through multiple nested menus with no clear path forward. This project builds a Drupal module called Config Navigator that embeds a lightweight AI-powered chat widget into the admin UI, letting users describe what they want to configure in plain English and get back a direct, permission-filtered link to the right page. The module maintains a structured index of Drupal core admin routes with keywords and synonyms, which gets passed as context to an LLM (OpenAI or Claude) so responses stay accurate and Drupal-specific rather than relying on general model knowledge. A plugin API allows contributed module maintainers to register their own admin routes into the index, making the tool extensible across the whole ecosystem. Privacy is treated as a first-class concern — no site content or user data ever leaves the server, and sites with strict data policies can point the module at a local LLM endpoint instead. Deliverables include the full Drupal module on Drupal.org, a plugin API with documentation, a feedback mechanism, test coverage, and a developer guide.
OCSMesh is a Python package designed for generating unstructured meshes tailored to ocean modeling. However, its current workflow, particularly the Digital Elevation Model (DEM) processing and JIGSAW mesh generation steps, remains highly time-consuming and not well-optimized for High Performance Computing (HPC) environments. To address this bottleneck, I propose introducing parallelism into the most computationally intensive stages of the workflow: DEM processing and JIGSAW-based meshing. My approach involves leveraging parallel computing libraries such as Dask and mpi4py to scale these operations across multiple cores and nodes. For the preprocessing stage, several components are already optimized for single-node performance and can be extended to work efficiently in an HPC setting. Regarding JIGSAW meshing, I plan to implement a domain decomposition strategy, partitioning the domain into smaller subdomains that can be meshed independently in parallel. These subdomain meshes will then be seamlessly merged to form the final unified mesh. This parallelized workflow is expected to dramatically reduce mesh generation time, enabling more scalable and efficient processing for large-scale ocean modeling tasks. I aim to integrate mpi4py support into the key functions across the codebase, while using Dask specifically for raster windowing and DEM data handling.
The project aims to make the following changes to the talawa-api: Enforce a stricter, standard graphql-pattern to get rid of the current anti-pattern nature that exists in the API. Resolve the relations that exist within the application optimally. Caching data for MongoDB collection entities having significantly higher number of read operations than write operations using Redis in memory Cache. Monitoring changes in the API schemas and relaying the changes to the client apps using Graphql-Inspector for better versioning migrations. Implement Data Normalization on the Client side(admin-portal and talawa mobile app) cache-store using Apollo Client Normalization. Providing a standard, scalable Error Handling mechanism within the graphql API using unions and interfaces to allow a consistent relay of Errors to the Client apps which will allow them to have more control over customizing UI behavior in case of errors. Implement stricter and simpler RBAC in the API resolvers in line with the business logic. Implement SSL in the client-server layer to encrypt all data exchanged between the client apps and API. Encryption of PII data within the SSL layer and in the Database at rest for added security using AES algorithm to encrypt and decrypt PII fields.
This project aims to improve the scale and navigation inside the Phoenix application which is basically an Angular-based web application written in the ThreeJS library to visualize high-energy physics events in 3D. The application renders a detector that detects the collisions of particles that have been accelerated up to speeds comparable to that of light, along with the event data that consists of tracks, jets, missing energy, etc. after the collision. The problem statement is to improve the visualization of the event, for example, by developing a customizable and interactive cartesian grid functionality, so as to better give the idea of the locations and distances of the particles to the researchers. Also, the user should be able to view the dimensions of the individual detector parts. Apart from this, the users should be able to navigate to the individual detector parts. My plan for the first problem is to introduce a 3D cartesian grid with multiple equally spaced XY, YZ, and ZX planes, as well as, to be able to display the 3D coordinates of a point on clicking. For this, I will make use of the ThreeJS raycaster intersects. Also, I am planning to render the Euclidean distance between any two points clicked. To view the dimensions of the detector, I am planning to render the dimensions of the bounding box of the component. The solution for the second problem would be to list the detector parts and let the user select any one of them, after which it will be highlighted using a ThreeJS outline pass.
This project aims to create OOT module, that uses CyberEther's GPU-accelerated framework which uses low-level graphics APIs to create high-performance sinks to visualize GNU Radio data streams in a normal GRC workflow. current implementations of these sinks rely on `gr-qtgui` which is fine but it would be a better to have the option of choosing CyberEther sinks which would be more optimized for maximum throughput and low latency along with a modern design. Main challenges are: minimizing data movement from the GR scheduler to CyberEther tensors, as in high sampling rates unnecessary copying would be expensive and undermine whole native performance edge. Also, CyberEther's current public plotting path internally manages a shared runtime built around `Jetstream::Instance`, and a normal GNU Radio flowgraph can have multiple sinks which would be tricky to manage safely. My core implementation target is a robust first sink family around lineplot and waterfall, with spectrogram support in the second half of the project if the lower-level CyberEther path is needed. These challenges(and other) can be resolved by architecting new solutions which borrow from past implementations namely `gr-cuda` for custom buffers, `gr-cyber` (an earlier prototype from Luigi, the creator of CyberEther) and `gr-fosphor` for relevant challenges.
<p>As part of our DIAL-funded project to integrate Mifos with the open source Mojaloop payments platform the team from DPC consulting built out a middleware component called the payment hub to enable the integration with the Mojaloop APIs. This middleware will also serve as the point of integration for all other external payment systems - the payment hub is extendable by additional payment connectors. This project would focus on adding the connector for the GSMA Mobile Money API. In 2016 GSMA published a first set of harmonized mobile money APIs to "ensure best practice in API design, security design, and more and to "address the complexity and fragmentation that is apparent in the fast-growing industry.</p> <p>The GSMA Mobile Money APIs are OTT (Over the Top) APIs that have been designed to cater for a core set of mobile money use cases:</p> <p>-Interoperability between mobile money and banks, or among mobile money providers</p> <p>-Merchant payments, online and offline, including delegated authentication of transactions</p> <p>-Bill payments and instant notification of payment</p> <p>-Basic account management</p> <p>-International transfers, including request for quotation</p> <p>-Bulk transactions</p> <p>-Cash in / Cash out</p>
The MIFOS Payment Hub EE (PH-EE) is a microservice-based financial infrastructure requiring high availability, security, and resilience. However, systematic architectural testing—especially under failure and stress conditions—is currently limited. This project introduces an AI-driven testing framework designed to assess and improve PH-EE’s robustness by simulating faults, generating and analyzing synthetic logs, and applying machine learning models to detect anomalies and predict failures. Using tools like OpenTelemetry, Prometheus, Elasticsearch/Kibana, and Isolation Forest/Time-Series models, the framework will monitor service behavior, generate failure scenarios, and highlight weak points in system architecture. It will provide visual dashboards, anomaly tagging, and metrics to guide debugging and resilience improvements. Deliverables include: Architecture mapping and categorization of critical PH-EE components Synthetic log generation simulating realistic failure patterns Integration of AI-based anomaly detection models Dashboards and visualization for observability (Grafana, Kibana) A reproducible proof-of-concept and documentation This project will empower MIFOS developers and adopters with actionable insights to improve system health, scalability, and fault tolerance through intelligent architectural testing
<p>Addition of required Javadoc comments and refactoring variable names, methods and some classes in the <strong>loklakj_lib</strong>, so that it can be published in the Maven repository, <em>MavenCentral</em>. Adding loklak API endpoints that are not currently implemented in <strong>loklakj_lib</strong>. Implementing static methods for generating <em>oauth_nonce</em> and <em>oauth_signature</em> in both <strong>loklakj_lib</strong> and <strong>loklak_python_api</strong>.</p> <p>Replacing Processing.org’s applet with auto-scrolling RecyclerView and ListView in the <strong>loklak_wok_android</strong> app and <strong>loklak_wok_desktop</strong> app respectively. Adding the following features to both apps:</p> <ol> <li>Search tweets using Loklak</li> <li>Post tweet using LoklakWok</li> <li>Push the posted tweet to Loklak server</li> </ol> <p>The GUI library for desktop app will be <strong>PyQt5</strong>. The above listed app features can be implemented for desktop app using <strong>loklak_python_api</strong>. Desktop app will be either a new project (new repo) or the same repository (removing the current code), depends on mentor’s decision.</p>
The Android platform, including its development tools, operates on open-source principles. Debian-derivatives have emerged as preferred platforms for Android developers. Since the release of stretch, Debian has incorporated core Android SDK tools, enabling the creation of certain apps. The Debian Android Tools team is dedicated to integrating the complete Android toolchain and SDK into Debian, facilitating the development of Android apps using exclusively free software packaged in user-friendly formats. Collaborating with the Debian Java team, this initiative addresses common tools like gradle used in Java software development. Recognizing the enormity of packaging the entire Android SDK, the team's focus extends to specific use cases, such as APK analysis tools and simplified setup of standalone components beneficial to non-Android developers, including the Emulator and NDK. Together with projects like Replicant, this endeavor aims to transform Android, the world's most popular operating system, into a fully Free Software platform. The project's deliverables primarily encompass the completion and submission of finalized packages to Debian sid, encompassing both newly created packages and updated ones. Furthermore, efforts will be made to ensure the submission and integration of patches upstream in the Android sources whenever feasible.
This project aims to build a context-first AI infrastructure to improve how contributors, maintainers, and repositories interact in open-source development. I will design and implement a system consisting of a Skill Bot (for answering contributor queries using repository-specific knowledge), a Skill Updater (to convert maintainer discussions into structured, reusable documentation), and a PR Dashboard (to help maintainers analyze and manage multiple pull requests efficiently). These components will be connected through a shared knowledge layer, ensuring that AI assistance is grounded in real repository context rather than generic responses, while maintaining a human-in-the-loop approach for reliability and control. In parallel, I will work on XOps, a CI/CD-native infrastructure for programmable value transfer in open-source workflows. This involves building a reusable execution engine that enables secure, policy-driven payouts triggered by repository events such as PR merges. The system will support multi-chain execution, configurable policies, and auditable workflows, reducing manual accounting overhead and enabling scalable, transparent contributor reward systems. Together, these systems aim to improve contribution quality, reduce maintainer workload, and introduce a standardized, automation-first approach to both collaboration and value distribution in open source.
The Splash projection mapping software allows for controlling multiple video projectors together to build a single projection. It is able to adapt to virtually any real geometry, as long as the surface is diffuse. Its rendering engine is built using the OpenGL API. It currently runs on platforms capable of running Linux and handling an OpenGL 4.5 context, and has been tested successfully on x86_64 (with NVIDIA, AMD and Intel graphic cards) and aarch64 (with NVIDIA graphic cards). However to be able to: a) optimize it further and b) support more platforms (for example Raspberry Pi), it would be interesting to support more graphics API. To do this it is envisioned to replace direct use of OpenGL with an intermediate, multi-API rendering library. Work Done: 1) Investigating available rendering libraries and APIs supported by the Raspberry Pi 4. 2) Modifying Splash's OpenGL 4.5 code to work with OpenGL ES and thus the Raspberry Pi 4. 3) Merging the old OpenGL and the new OpenGL ES codepaths to allow one binary to run both. 4). Pulling out graphics code such that application classes are only responsible for application logic, they just use the provided graphics API specific implementation. 5) Rudamentary performance profiling. 6) Bug fixes to application and graphics code.
<p>Phoenix is a web-based, experiment independent event display framework in JavaScript for visualizing HEP experiment data from multiple experiments. This project focuses on the following improvements to Phoenix.</p> <h5>Improvements</h5> <ul> <li>A more feature rich, control-oriented and intuitive GUI</li> <li>Easier selection of 3D objects and event data (like Tracks, Jets etc.)</li> <li>Keyboard controls for controlling the event display through keys</li> <li>Runge-kutta propagator for using Track parameters to calculate Track positions and decreasing data format size</li> <li>Extension of the current common JSON data format to support more diverse experiments and their event data</li> <li>Support for more CERN experiments like CMS</li> <li>Loaders for loading event data from ".root" and ".ig" files</li> <li>Loading and processing event data from cloud servers</li> <li>Animation of events to simulate the propagation of particles</li> <li>Improvement of VR features</li> <li>Investigating TGeo/GEANT4 geometries and implementing converters to display them in Phoenix</li> <li>Extending unit tests and creating UI tests</li> </ul>
Modern sandboxed applications (like Flatpaks) rely on XDG Desktop Portals for essential OS integration, such as screen sharing, opening files, or sending notifications. Tiling window managers often lack a complete and well-maintained xdg-desktop-portal backend, leaving users with a broken experience for many applications. This project will create a working xdg-desktop-portal backend for the Regolith desktop environment. Regolith is a productivity-focused Ubuntu-based desktop environment that combines tiling window managers (Sway, i3) with GNOME components for system management and GUI features. By using xdg-desktop-portal-luminous as a foundation, this project will deliver native portal implementations for complex features like Background and Clipboard, closing a major functionality gap. A key focus of this project is also on upstream contributions. The work will involve implementing the missing Usb portal in the xdg-desktop-portal-gtk backend and helping define and implement a new ScreenCast API version with audio support. This upstream work will directly benefit the entire Linux desktop ecosystem by providing a standard, secure way to capture application audio, a critical feature for apps like Discord and OBS Studio.
The ZOO-Project is an SDI manager which gives the users the capability of building their own map and web applications using Map server as the Open Geospatial Consortium (OGC) services engine. It is an open-source implementation of the OGC's Web Processing Service (WPS) standard. WPS Interface Standard provides rules for standardizing how inputs and outputs (requests and responses) for geospatial processing services (eg. polygon overlay). WPS also standardizes how a client can request the execution of a process, and how the output from the process is handled. The existing ZOO-Kernel supports C, C++, and JavaScript implementations. With this project, the objective is to have the ZOO-Kernel passing all the tests for WPS 1.0.0 and 2.0.0 OGC ETS. During the GSoC the main focus is on making the WPS 2.0.0 test suite working properly. The async tests are still wrong currently and should be fixed, this will be done during the GSoC. The next and final step will be to get the WPS 1.0.0 test suite working and comprehensive enough to get the Test Suite or the ZOO-Project fixed. Moving from OGC API - Processes - Part 1: Core to WPS 2.0.0. can also be added as second step for the project.
Problem: Installing Julia, opening a terminal, running Julia REPL, then opening the package manager, adding Pluto package, running Pluto, and then going to the browser to run it. How many steps was it? 7. Seems quite uninviting. Now think of a person who has never touched any terminal in his life. Seems like an even more daunting task. A person who is only interested in running a Pluto Notebook and running Julia on it may or may not know how to do any of these steps, and since these can be automated, why keep this task to the end user? My Plan to solve: This is where this app comes in, bundles all these steps, runs this in the background, and then only shows the user their notebook running inside the app itself, no browser required. Deliverable: An Electron app that can perform the following tasks: 1. Install Julia and pluto on the first run. 2. Show the pluto view inside the app. 3. Allow the view to interact with the server. 4. Support the native file system features of Pluto. 5. Support running more than one instance of Pluto views. 6. Support light and dark modes. 7. Be responsive (allow different screen sizes). 8. Show the Julia Package Page inside the app itself to refer to some documentation when and if required. 9. It should also have proper comments and documentation for future reference.
Monumento App Summary: Monumento, an integrated social app for sharing landmarks, visiting places, and visualizing their 3D models right from a mobile device, aims to enhance user experiences through the following key features: Desktop and Web Apps: Develop a cross-platform desktop app using Flutter. Create a web version for users to access accounts, view landmarks, and engage with the community. Ensure responsive designs and consistent interactions across devices. Social and Community Features: Implement Firebase Authentication for secure user sign-up and login. Use Firestore for real-time storage of user-generated content (posts, images, etc.). Enable user interactions such as likes, comments, and profile management. Utilize Firebase Cloud Functions for real-time notifications. 3D Visualization: Integrate 3D models of landmarks. Convert models to GLTF format for efficient loading. Augmented Reality (AR) mode allows users to see 3D models superimposed on the real world. Interactive exploration with zoom and rotation. Deployment and Scalability: Package Monumento into Docker containers for consistency. Set up CI/CD pipelines for automated deployment. Choose deployment platforms (Heroku, Firebase Hosting, or GCP) and monitor performance post-launch.
This project aims to enhance the BEAD framework for anomaly detection in high-energy physics by developing a new multi-stage architecture that combines a contrastive variational autoencoder (VAE) with a self-supervised transformer and multi-task fine-tuning layers. The key goal is to learn generator-invariant representations from 4-momentum vectors of background events by pretraining the VAE using generator labels (e.g., Pythia, Herwig, Sherpa). The latent variables produced are then masked and enriched with high-level physics features (e.g., MET, HT, Meff) and passed through a transformer trained to reconstruct them, encouraging deeper physics representation learning. The enhanced latent space is decoded using fine-tuning layers that perform multiple tasks simultaneously: reconstructing event-level features, predicting jet properties, and regressing unseen quantities. This structure encourages collaboration between the VAE and transformer components, increasing robustness against spurious correlations and improving anomaly detection performance. Deliverables will include: - A modular implementation of the full architecture within BEAD - Integration with tools like Weights & Biases for experiment tracking - Docker support for reproducibility - Evaluation benchmarks on synthetic datasets - Final documentation and presentation of findings at the CERN ML Forum
<h4>Prombench is the automated E2E testing and benchmarking for Prometheus.</h4> <p>Prombench uses Kubernetes to benchmark Prometheus using various scalable configurations of fake web servers. Prombench uses Prometheus, Grafana and Loki for monitoring difference between versions.</p> <p>Presently Google Kubernetes can only be used for prombench. This creates a scarcity of use of prombench. This problem can be resolved using following :-</p> <ul> <li>Use of another cloud provider like (AWS)Amazon web services</li> </ul> <p>Presently, Grafana Dashboard consist of many useful graphs and useful visualization but there is a scope of improvement. Various issues which aims to improve visualizations for grafana are as follows :-</p> <ul> <li>Refactor the grafana dashboards to show a more consistent memory usage(#324)</li> <li>Revisit all current dashboards to add new and remove unneeded to make them more useful for catching bugs(#186)</li> <li>Node exported does not get filesystem size metrics from SSD path /mnt/disks/ssd0(#159)</li> <li>Add explanations to all panels on the Prombench dashboard(#305)</li> <li>Loki not showing previous test prometheus instance logs(#322)</li> </ul>
Cephalopods display complex behavioral states such as stress, curiosity, aggression, and comfort, but interpreting these states currently depends on expert manual observation and lacks scalable, reproducible tools. This project will build an open source multimodal pipeline that automatically infers and classifies cephalopod behavioral sentiment from video and optional bioacoustic data using computer vision and deep learning. The pipeline will include a dataset ingestion and preprocessing module supporting common video and audio formats, a behavioral feature extractor capturing locomotion, skin pattern dynamics driven by chromatophores, and body posture changes, and a sentiment classification system mapping extracted features to labeled behavioral states. A lightweight deployment API and interactive demo dashboard will make the system accessible to researchers and educators. Key deliverables include dataset ingestion and preprocessing scripts, a multimodal model baseline combining video and optional audio streams, a behavioral feature extraction module for movement and color and posture signals, a sentiment label classifier with training and evaluation scripts, full documentation with reproducible experiments, and a REST API with a demo dashboard for inference. The system will be designed for extensibility across species, datasets, and deployment environments including edge devices.
The proposal aims to enhance Dubbo-python to meet the evolving needs of the AI sector by addressing compatibility issues, architectural limitations, and functionality gaps. Currently, Dubbo-python faces challenges due to its reliance on Python 2, deprecated libraries, and incomplete RPC communication capabilities, hindering its adoption within mainstream AI frameworks. To tackle these issues, the plan includes: 1. Upgrading Dubbo-python to support Python 3 and modernizing its architecture following the Microkernel + Plugin design principle. 2. Implementing complete RPC communication functionality, including server-side service exposure and client-side service invocation, with support for the new Triple protocol. 3. Developing service governance capabilities such as service discovery, registration, and load balancing, including the design of a GPU metric-based load balancing algorithm to address GPU workload imbalances in AI frameworks. 4. Writing comprehensive test codes to ensure the reliability of each functionality and providing detailed documentation to facilitate easier adoption and contribution to Dubbo-python. By accomplishing these objectives, the aim is to transform Dubbo-python into a robust, high-performance RPC framework compatible with mainstream AI frameworks, thus empowering developers to build scalable and efficient AI systems.
<p>FreeBSD has an audit subsystem which is responsible for monitoring a variety of security-relevant system events, such as user-logins, configuration changes, file system & network access. Although the audit framework is indispensable for security conscious organizations running FreeBSD servers, currently there is no tool to test its reliability and the intended behavior.</p> <p>The project aims to develop a regression test-suite, which will evaluate the audit framework for proper logging of most auditable system calls classified in TCP/IP & UDP sockets, File I/O, process control and device management, along with the semantics of audit trail's BSM/XML/ text output.</p> <p>BSM tokens can be obtained via synchronous I/O multiplexing on a special clonable device <code>/dev/auditpipe</code>, by configuring various preselection parameters for local mode auditing with the provided IOCTLs. Several <code>libbsm(3)</code> APIs and functions within the FreeBSD kernel can be used to analyze syscall tokens in the audit record. Finally, <code>kyua(7)</code>'s run-time engine will be used to automate regression testing of entire operating system at once, <code>audit(4)</code> included.</p>
The `loo` package is a widely used R package in the Stan ecosystem which exposes a clean API to cross-validate (CV) Bayesian models. As new CV methods and diagnostics are created and adopted by the field, the `loo` package must be updated to support them. Currently different predictive performance measures have different APIs and varying level of supported features. This project is focused on refactoring the API to unify the support for different predictive measures to make all useful features available for all predictive measures to make it easier for the modellers to use the most appropriate measures for their applications. Key technical components will include creating a flexible object which can report multiple metrics and scores. Additionally, we need to create functions to support model comparisons for all these scores and metrics. We will also allow for measures besides log score for LOO-CV to be used under the same, unified interface as existing options and create a consistent loo object for all measures. We will further unify the interface by allowing for non-log score measures for in-sample, test data, and K-fold-CV use cases. We will also be extending the model comparison functions to carry forward information on what measure is being compared, diagnostic data, and information on how to calculate the standard error (SE) of the differences of various measures.
<p>Many users of Open Ephys are using optogenetic tools to manipulate activity in genetically defined neural circuits, but there is currently no way to control these tools from the Open Ephys GUI. <a href="http://www.open-ephys.org/cyclops/" target="_blank">Cyclops</a> is a high-precision LED driver designed for precise optogenetic stimulation. Setting up a controlled closed-loop experiments, <em>where neurons can be stimulated based on real-time acquired neural data</em>, would be greatly simplified if a plugin to communicate with Cyclops is built into the GUI.</p> <p>A typical scenario would be to upload or stream waveforms to Cyclops and trigger their deployment <em>(or transformations)</em> based on events detected in GUI. An <strong>open communication protocol</strong> needs to be defined for this and also <strong>special programable processors</strong> that can generate feedback signals and control Cyclops <em>(via the protocol)</em>.<br> After configuring the processors in the pipeline, the GUI would program Cyclops and the experiment can be launched.</p> <p>In addition to this, a more powerful and upgraded Cyclops that uses a <a href="http://www.pjrc.com/teensy/" target="_blank">Teensy</a> board will be released. Cyclops and Open Ephys would still support the Arduino version though.</p>
<p><strong>Modelica</strong> is an object-oriented and declarative language specification for description/modeling of dynamic systems (mechanical, electrical, thermal, mixed, etc.). <strong>Scilab</strong> uses it inside <strong>Xcos</strong> to describe more complex blocks/components, taking advantage of existing compiler/translator implementations to generate correspondent <strong>C</strong> code for actual simulation.</p> <p>For now, <strong>Modelica</strong> in <strong>Scilab</strong> is managed by an out-of tree compiler developed by <strong>LMS</strong> released under the <strong>GPL</strong> license, which is not actively maintained and support only a subset of the current language specification. The idea of this project is to allow the usage of <strong>OpenModelica</strong>’s <strong>OMCompiler</strong> (<strong>omc</strong>) as an alternative. Being a more up-to-date solution, <strong>omc</strong> integration would provide <strong>Scilab</strong>/<strong>Xcos</strong> the ability to use more advanced features, and avoid bugs, issues and maintenance burden of the current <strong>modelicac</strong> compiler.</p> <p>Adapting <strong>Xcos</strong> blocks to support the <strong>FMI2 API</strong> standard would allow not only omc-generated code to be called but also any other FMI2-compliant applications to be easily integrate in the future.</p>