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.
COCONUT-SVSM is a Secure Virtual Machine Service Module running at a privileged level inside Confidential VMs to provide trusted services (e.g., virtual TPM) independent of the host hypervisor. Currently, the SVSM kernel performs full TLB flushes on every context switch, discarding all TLB entries indiscriminately and causing significant runtime TLB miss overhead. This project enhances COCONUT-SVSM to leverage the x86 PCID (Process Context Identifiers) hardware feature to tag TLB entries per task, preserving them across context switches and enabling selective TLB invalidation. The work is structured in three phases: Phase 1 builds a code-generated Rust crate (x86-cpuid) from the authoritative x86-cpuid-db v2.4 XML database, replacing all scattered, magic-bit-position CPUID checks across the codebase with a type-safe cpu_has(leaf_0x1::ecx::Pcid) API unified across SNP, TDX, and native platforms via a CpuidReader trait. Phase 2 designs and implements a PCID assignment strategy for all virtual pages in the COCONUT kernel, enabling the CPU to tag TLB entries per task(same for all threads of task) and preserve them across context switches. Phase 3 converts global TLB flush operations in into selective, PCID-aware invalidations: using AMD's INVLPGB broadcast instruction to flush a specific PCID across all cores without IPIs. Key Deliverables are x86-cpuid Rust crate with code generator consuming x86-cpuid-db XML, refactored COCONUT-SVSM codebase with all open-coded CPUID checks replaced with new code generated by x86-cpuid Rust crate, PCID allocator, applying the PCIDs in the COCONUT page-tables and selective TLB flush functions (flush_tlb_pcid, flush_tlb_range_pcid) with AMD INVLPGB.
This project aims to develop a multi-modal foundation model training pipeline for end-to-end particle reconstruction in the CMS experiment. Building on last year's LorentzParT hybrid architecture (L-GATr + ParT) and its track-level masked autoencoder pretraining, I will design a unified tokenization scheme encoding particle kinematics and interaction features as distinct modality streams, and pretrain the shared encoder using a novel Cross-Modal JEPA objective that predicts masked token embeddings across modalities in latent space — combining, for the first time, JEPA-style self-supervision with Lorentz-equivariant representations. The pretrained encoder will be fine-tuned and benchmarked on multiple downstream tasks including event/jet classification and mass regression, with conditional generation as a stretch goal. Deliverables include the complete CM-JEPA pretraining pipeline, a multi-modal tokenizer, multi-task fine-tuning scripts, systematic ablation studies across pretraining methods and masking strategies, trained model checkpoints, and an open-source repository with documentation and a blog post.
This project addresses the computational cost of full Geant4 calorimeter shower simulation by constructing compact, readout-segmentation–independent point clouds from Geant4 steps for fast-simulation training. I implemented and evaluated three clustering methods—DBSCAN, CLUE-style approach, and an axis-aligned Grid Clustering approach—together with a validation suite (longitudinal/radial profiles, containment radii, raw moments, energy closure) and a side-by-side 3D viewer. Across parameter scans, DBSCAN and CLUE achieved compression but degraded radial structure (and DBSCAN showed mm-level longitudinal drift), whereas the Grid method preserved longitudinal and radial profiles while remaining fast and angle-robust.
The Bene Fundraising Platform on the Ergo blockchain uses a unique token system (APT/PFT) to support fundraising projects. This project will improve the Ergo version by adding support for multiple tokens, including stablecoins, and bringing it in line with the EVM version. Main goals include: adding stablecoin and multi-token support, integrating multiple wallets, building a referral system with protection against misuse, creating a project analytics dashboard, and improving the user interface and accessibility. These updates will make Bene easier to use, more powerful, and more welcoming to new users, helping grow the Ergo fundraising community.
This proposal aims to bolster the security measures of our application by implementing a Bloom Filter to detect malicious links efficiently. It addresses the challenges of cost and complexity associated with existing solutions by leveraging the rbloom Python library. Additionally, it explores the integration of ChatGPT into server environments such as clickbait and fake news detection, offering potential cost savings and enhanced capabilities. Furthermore, it proposes leveraging ChatGPT for text summarization tasks to improve information retrieval and knowledge consolidation. Cloud integration is a key aspect, with plans to develop a CI/CD pipeline and explore cost-effective cloud solutions like ECS, EKS, Lambda functions, Azure, GCP, and AWS free tiers. Standardizing server code structures, documentation, and implementing a testing/development server aim to streamline the development process. Overall, the proposal aims to enhance security, efficiency, and cost-effectiveness while advancing the application's functionality and user experience.
This project aims to create a user-friendly way to manage essential KubeArmor security functions from within the Rancher Manager interface. This will make it much easier for Rancher users to protect their Kubernetes environments. As mentioned in the GitHub Issue the key functionalities of this project include “a streamlined process of KubeArmor installation and configure it within a Rancher-managed Kubernetes cluster, Policy management includes viewing and listing and editing existing policies, creating new policies, integrating telemetry for alerts and visualizing security events and metrics, and functionalities to recommend predefined security policies and automatically discover policies based on the cluster's workload.”
This project aims to enhance and optimize the existing platform by implementing several important features and improvements. These changes include the addition of domains, tags, and a prize and sponsor page, as well as the introduction of a deregister process, a revamped profile page with a new tabular UI design, a participant team approval feature, and the inclusion of GMT time stamps and many more features.
The idea here is to provide both runtime support (preferably using the SymEngine library to provide the computation, as it is fast and robust) and compile time support (in ASR) to implement Symbolic Algorithms in LPython. The runtime operation could use the SymEngine library for LLVM, C and C++ backends. For Python backend, we can simply use SymPy itself. The algorithms would be implemented in the ASR code, which would make them independent of any specific frontend. Any frontend that uses the ASR code could then make use of the symbolic algorithms without having to reimplement them. LPython, in this case, would not implement the symbolic algorithms themselves, but would instead parse the syntax used by the SymPy library, which already has a rich set of symbolic algorithms, and use the ASR representation of these expressions to perform various operations. This would allow LPython to have powerful symbolic manipulation capabilities without having to reinvent the wheel.
This project aims to add support for real-time lossless compression libraries and algorithms in the data acquisition system that is being used for the FASER experiment, to reduce storage costs. This would be done after thorough exploration and experimentation, identifying suitable compression libraries which can be integrated seamlessly into the system. Detailed documentation of the entire process and support for the decompression of compressed data (for physics analysis) will also be provided.
Overall, the proposal is about adding a few missing features in the package, like addition of new models, some metaprogramming, lazy evaluation, testing, documentation and linting. Currently, the package only supports four regression models (Linear, Logistic, Poisson and Negative Binomial regression). There is a huge scope of adding many more models to the package. To start with, we can add the Gamma and Inverse Gaussian regression models, and the ARIMA model for time series. Over time, more models can be added to the package. There is also a scope of adding new macros to the package to make the syntax more clean. An example of this is in the fitmodel function of the package (and is explained via a code snippet in the proposal). From the documentation, it can also be seen that any model has many attributes which are computed when the fit function is called. When working on big data, it is possible that not all the attribute values are needed, so it is currently inefficient to compute every attribute. Instead, one can compute the attributes lazily, i.e as and when they are needed. Rigorous unit testing should be added to the package to ensure code correctness. Also, the package code can use a lot of help with its documentation and code coverage. All of these can be implemented using CI/CD. Finally, in its current state, the package lacks strict code conventions (like variable names, commit message rules etc). These are essential to ensure good quality code and to make the job easier for future contributors. To enforce this, linting can be added to the code along with Git hooks to enforce these conventions. Also, a well defined API should be documented for the models, so that new models can be added at ease.
Even though a lot of new C++ features are supported by the static analyzer automatically by the virtue of clang AST doing all the work under the hood, the C++17 "structured binding" syntax auto [x, y] = ...; requires some extra work on the Static Analyzer side. The analyzer's transfer functions need to be taught about the new AST nodes, BindingDecl and DecompositionDecl, to work correctly in all three interpretations described by the Standard. Incomplete support for structured bindings is a common source of false positives in the uninitialized variable checker on modern C++ code, such as #42387. It is likely that the Clang CFG also needs to be updated. Such changes in the CFG may improve quality of clang warnings outside of the Static Analyzer. The expected result is that the Static Analyzer correctly models structured binding and decomposition declarations. In particular, binding variables no longer appear uninitialized to the Static Analyzer's uninitialized variable checker.
This project aims to add support for on-disk encryption of backups. These are some tasks that need to be completed: Create an internal API for encryption / decryption Create an implementation using AES-256
Bhyve is a modern type 2 hypervisor originally written for FreeBSD. The goal of this project is to enhance the functionality of its debugging server. Several existing features related to single-stepping are tied to Intel-specific VM mechanisms, which severely impairs bhyve's debugging functionality on other platforms. Thus, the first major goal of this project is to rework the single-stepping mechanism to use the RFLAGS.TF VMEXIT mechanism. This will allow bhyve to support debugging guest operating systems on AMD platforms, which would facilitate kernel development for more 64-bit x86 hardware (other than Intel). The second goal is adding support for hardware watchpoints (and optionally hardware breakpoints) using the guest OS's hardware debugging registers. This will improve the kernel development workflow and allow easier and faster fixes for various kernel memory corruption bugs.
In this project, we need to implement a zero-cost abstraction using Modern C++, which can help us to switch between Structure of Arrays (SoA) and Array of Structures (AoS). This abstraction needs to be introduced at MSSpectrum and MSChromatogram levels. These are the 2 classes used in OpenMS, which currently uses vector<Peak1D> i.e. an Array of Structures.
Modernize (i.e., re-architect and largely refactor) the current "Social API" core module and most highly used SSO provider modules. The newer API would have the ability to store different accounts for different providers to the same drupal user. It will also give the users the access to implement their own client libraries, by leveraging core OAuth2 libraries. The new application would make the overall implementation a further user-oriented API.
<p>The current documentation for OpenSCAD is available online at WikiBooks for easy access, which also facilitates user edits for improvisation of the manual that can be contributed to by anyone. Since we only have an online version available as of now, this creates a problem for users who do not have access to the internet at all times.</p> <p>With this Project, we aim to provide an ‘offline’ version of the manual which can be generated once at the time of build and contains the whole OpenSCAD User Manual along with the OpenSCAD Language Docs.</p> <p>The WikiMedia Foundation currently provides a web service named MediaWiki Action API for all the Wikimedia wikis including WikiBooks. This allows easy access to many features that WikiBooks provides including the information available at the wiki. With an API-centered approach, this project aims to provide the User with an offline copy of the docs, similar to those available online at the wiki, in HTML format, which can then be easily viewed using any installed browser, along with a pdf of the same, which also is another widely used, user-friendly file format.</p>
<p>Oppia uses Angular as the frontend framework with typescript as the primary language, hence this codebase is fully typed which implies that variable assignment, procedure arguments and function return values will all be associated explicitly with a type. <code>strict</code> is a typescript compiler option which turns on a set of stricter type rules which, when enabled, helps reduce the chances of getting unpredictable results and makes the code more robust but currently, Oppia’s code base does not pass these strict rules. This makes the code prone to unexpected actions and errors.</p> <p>To avoid this, the following actions need to be taken:</p> <ul> <li>All the new files to be added should have typescript strict mode enabled</li> <li>Strict typing should be introduced to the files already present in the code base</li> </ul> <p>This project aims to change the config files to ensure that any new file added to the Oppia’s code base will, by default, have typescript <strong>strict mode</strong> enabled. Also, strict typing will be introduced to 240 files (120 files and their test file) already present in the code base and listed down in <code>UpgradedServices.ts</code>.</p>
<p>Example Zoo is an implementation of mlpack showcasing its potential usage in the real-world domain. It will provide a better starting point for new users to learn from ready-to-run code. It will showcase the usage of API, how it can be integrated with different visualization libraries for cool graphs and plots. The example will show the potential usage of Machine Learning Algorithms and Deep Neural Networks on real-life datasets. Finally, a well-documented process for creating an end-to-end machine learning project, using mlpack as a core.</p>
<p>Currently, SMI doesn’t provide connectivity over multiple Kubernetes clusters. It is becoming common for users of a service mesh to have more than one cluster.</p> <p>What if Service Meshes could be connected with associated features like observability, control, and security, etc. even when they are being managed under different organizations.</p> <p>This project focuses to provide the ability to discover traffic across different service meshes and authenticate it, where each mesh is in a different and untrusted administrative domain, where each mesh can be of the same or from different vendors, can have the same or different control and data plane implementations, be single or multi-cluster, and can provide the same or different functionality to its customers.</p> <p>Extending multi-cluster capabilities mainly depends on two core features, which are required to provide the ability to discover traffic across different service meshes and authenticate it.</p> <ol> <li>Service Catalog Federation</li> <li>Identity Federation</li> </ol>
<p>The project aims to improve the integration between <code>ScalaPy</code> and <code>Ammonite</code>/<code>Almond</code> by providing a frictionless installation experience plus a number of quality of life features such as code completion and displaying rich presentations of Python objects. The project also involves developing a Scala - Python integrated environment in which users can switch between a Scala and Python shell and exchange variables between them. The project could benefit Scala programmers seeking access to Python libraries, typically data science and deep learning frameworks, by providing them with a smoother user experience. In addition, it could also help Scala attract Python programmers, who are looking for a type safe language with better concurrency and parallelism support.</p>
<p>Differentiable optimization is a promising field of convex optimization and has many potential applications in game theory, control theory and machine learning. Unlike <code>cvxpy</code>, <code>JuMP</code> currently lacks the feature to differentiate solutions of disciplined convex optimization problems and render them as layers in machine learning libraries. I propose to develop this feature and make it accessible from the <code>JuMP</code> interface.</p>
<p>The primary motivation of the project is to enhance quantum circuit (qutip.qip.circuit) and noise simulation capabilities of the QuTIP package. By adding a number of features to the quantum circuit module, we hope to be able to further extend the NISQ (Noisy-Intermediate Scale Quantum) capabilities first introduced by Boxi Li in GSOC 2019 project.</p>
<p>With Red Hen Lab’s Rapid Annotator we try to enable researchers worldwide to <strong>annotate large chunks of data</strong> in a very short period of time with least effort possible and try to get started with minimal training. This task is aimed at extending the <a href="https://github.com/RedHenLab/RapidAnnotator-2.0" target="_blank">Red Hen Rapid Annotator</a>, which was re-implemented from scratch as a Python/Flask application during GSoC 2018 by Vaibhav Gupta and improved in last year's GSoC by Gulshan Kumar. This project mainly aims to deliver a fully usable and handy product by the end of Google Code of Summer 2020 and incorporation of <a href="https://sites.google.com/case.edu/techne-public-site/red-hen-rapid-annotator" target="_blank">new feature request and bug fixes</a>. The final product would be a complete tool for fast and simple classification of datasets and an administrative interface for the experimenters where they can conduct their annotation runs. It broadly comprises of 3 steps, namely</p> <ul> <li>Uploading their datasets to set up the experiment. </li> <li>Assigning annotators datasets for annotation.</li> <li>Keeping a track of the annotation progress.</li> </ul>
<p>LabelLab allows the user to upload images and label them using bounding boxes and polygons. Currently, there is no way for the user to build models using the labelled dataset which they have created. The goal of the project is to create a pipeline which allows the users to train classification models using the images which have been uploaded and labelled on LabelLab.</p>