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.
My proposal involves expanding Arti's state management subcommands: hss and hsc (very limited in functionalities at the moment). These new features will be added after the completion of GSoC: a subcommand for listing keys and certificates from the configured keystores; a subcommand for listing keystores by their identifier; a subcommand for performing consistency, validity, and integrity checks on the specified stores; an arti hss destroy subcommand, for removing the persistent state and all the keys of a onion service; an arti hss destroy-and-recreate subcommand, for generating a new identity for an existing onion service; miscellaneous low-level "plumbing" subcommands, which deal with individual files from the keystore and state directories; a C Tor to Arti key migration tool, which will enable onion service operators to seamlessly migrate from C Tor to Arti; field-formatted output to be easily parseable by other programs. These objectives will be achieved mostly by extending already existing facilities, like InertTorClient and OnionService, and by creating new ones.
<p>OAST stands for Out-of-band Application Security Testing and is used to detect Out-Of-Band (OOB) vulnerabilities, which is not possible to do with a traditional HTTP request-response interaction. Although ZAP offers excellent DAST capabilities, it falls short when it comes to OAST.</p> <p>This project aims to fill this gap. It will focus on integrating the <a href="https://github.com/marcoagner/boast" target="_blank">BOAST</a> service with ZAP via an add-on. Relevant OOB payloads sent to the target will allow BOAST to capture and process generated requests, enabling ZAP to detect and report on a new class of vulnerabilities.</p>
This proposal aims to strengthen stdlib’s linear algebra capabilities by implementing LAPACK-based solve routines for structured matrix formats such as packed, banded, and tridiagonal systems, which are widely used in scientific and engineering applications. The project focuses on enabling a complete factorization-to-solution workflow, ensuring seamless integration with existing routines while carefully handling specialized storage formats that require precise indexing and memory management. Emphasis will be placed on numerical correctness, consistency with stdlib’s APIs, and robustness through comprehensive testing and validation. Clear documentation and practical examples will also be provided to improve usability, ultimately making stdlib a more reliable and effective toolkit for real-world scientific computing.
This project addresses the challenge of unreliable LLM outputs in complex health informatics workflows by building a domain-grounded Retrieval-Augmented Generation (RAG) system within JuliaHealth. It enables users to convert natural language queries into accurate, executable FunSQL.jl workflows by grounding responses in curated resources like OMOP and OHDSI. The project will deliver a modular baseline RAG pipeline, a reproducible evaluation framework to benchmark query quality, and clear documentation with an end-to-end demonstration for usability and future extension.
The long-tail requests sometimes are inevitable between the Thanos Store Gateway and an external cache. Lowering the timeouts between the store-gateway and the cache service isn't a greater way to address this problem. Using a HTTP client to issue hedged requests to object storage and other parts of Thanos' stack could help reduce tail latency by a lot. Expected Outcome: By the end of the term, the mentee will have a deeper knowledge of Thanos and have improved our HTTP request tail latencies considerably!
DRA (https://kubernetes.io/docs/concepts/scheduling-eviction/dynamic-resource-allocation/) is a new generation device management mechanism for kubernetes. It introduces a new resource request API `ResourceClaim`, which requires kubelet, kube-controller-manager, scheduler, and third-party device management controllers to cooperate with each other to work. The kube-scheduler has implemented corresponding scheduling capabilities, Volcano also needs to implement the DRA scheduling plug-in to integrate the DRA function. Expected Outcome: - A design document describing how to integrate DRA into volcano. - Implement DRA plugin in volcano.
In this project, you will incorporate WasmEdge’s NN (Neural Network) extensions into the Python interpreter. WasmEdge provides C and Rust APIs for guest applications to access host functions in the underlying Tensorflow and PyTorch libraries. You will make those functions accessible from the CPython-based interpreter as Python wrappers. This way, Python applications can do lightweight AI inference on the WasmEdge container. - Expected outcome: * Investigate and list all C-based host function APIs for Tensorflow and PyTorch inference in WasmEdge NN. * Create CPython wrappers for those host functions. * Create high-level Python wrapper functions that are ergonomic for Python developers. * Create CI and demo apps to validate the Python wrapper API. * Create detailed documentation and tutorials.
<p>Pointer Authentication is a software security primitive that makes it much harder for an attacker to aggravate attacks targeting arbitrary code execution through malicious manipulation of code and data pointers. This project aims at doing a proof-of-concept integration of pointer authentication into Ibex.</p> <p>The focus lies on integrating pointer authentication into Ibex's processor pipeline. To this end, new custom instructions need to be added to generate and authenticate pointers. In addition, the Ibex system is 32-bit, so we will need to figure out where to store PAC (Pointer Authentication Codes) and how to load them.</p>
<p>OpenStack Manila manages shared file-systems across the cloud. Being able to create and access them with ease from the container world is showing to be quite useful - that’s what csi-manila is for. One of the features that’s also in high demand when dealing with shared file-systems is taking snapshots as well as creating new shares from those snapshots from within Container Orchestrators like Kubernetes. csi-manila itself is quite a new piece of software and is missing certain features, like snapshots for an instance. This GSoC project will try to close this feature gap.</p>
<p>The current project aims to implement the option to carry out the numerical integration part in the Brian simulator with integrators defined in external libraries, starting with the odeiv2 module that comes with the GNU Scientific Library (GSL). In addition to coming with an extensive list of different integration methods, the GSL integrator comes with an adaptable timestep. The latter functionality will have major benefits for the speed with which large simulations in Brian can run. This is because it allows the use of larger timesteps for the overhead loops in Python, without losing (likely even improving) the accuracy of the numerical integration at points where small timesteps are necessary. I have personally used Brian, and can tell from experience that this can be very useful at times - especially when working with Hodgkin-Huxley-type equations. I think this speed-up could be an important factor for people to choose to use Brian for their simulations.</p>
<p>Now, we have skunkworks-crow, which is the GSoC 2018 project. In this year, we need to improve the project and develop a new strategy to address the highest-value limiting factors to broaden the base, and propose a strategy to validate behavior on devices we may not have access to.</p>
Devfiles are YAML files that define remote development environments. The main part of a Devfile is the `components` section and that's where the containers required to code, build and test an application are specified. The Devfile can either include those containers defintions or reference external files such as Dockerfiles or Kubernetes manifests. [The Compose file](https://github.com/compose-spec/compose-spec/blob/master/spec.md) is a popular format in open source development projects to define runtime environments for testing the application but those cannot be referenced by a Devfile yet. The goal is to continue the work that has been started a couple of months ago to allow referencing a Compose file from a Devfile. The expected outcome is to create a PoC written in go that parses a Compose file such as [this one](https://github.com/microservices-demo/microservices-demo/blob/master/deploy/docker-compose/docker-compose.yml) using [kompose](https://github.com/kubernetes/kompose) (as a library, not as an executable) and that creates the objects corresponding to the Compose file services in a Kubernetes cluster.
This project focused on making patient-level prediction (PLP) more practical within the JuliaHealth ecosystem by building some of the missing foundations around OMOP CDM data. The main challenges were around data preprocessing and consistent cohort construction, which are essential before any prediction pipeline can be reliable. To address this, the project delivered two key pieces: first, a standardized Tables.jl interface in HealthBase.jl to make OMOP CDM data easier to work with and preprocess; and second, a new package, OMOPCDMFeasibility.jl, which adds tools for checking cohort feasibility and data readiness. Both were designed to work hand-in-hand with existing JuliaHealth packages like OMOPCDMCohortCreator.jl and OHDSICohortExpressions.jl. Together, these contributions provide a more reproducible, end-to-end path for building PLP models directly on OMOP CDM datasets.
This project proposes various new features for the haskell language server(HLS). While HLS already comes with the most important ones, a few haven’t been implemented yet. These important unimplemented features of Language Server Protocol(LSP) have to be implemented. Namely, Semantic Highlighting, Folding ranges, Linked editing, Change Annotation, Document links, and Completion / Code Action / Code Lens resolving.
<p>Apache VXQuery will be a standard compliant Xquery processor implemented in java. JSONiq is a query and processing language specifically designed for the popular JSON data model. It is much similar to XQuery burrowing a large numbers of ideas from XQuery. The "JSONiq extension to XQuery" allows processing XML and JSON natively and with a single language. This project aims at adding objects to the data model of VXquery allowing it to query JSON objects.</p>
This proposal aims to implement an ISO ITU-T Rec. T.814 compliant High Throughput jpeg2000 decoder for ffmpeg. The new jpeg2000 standard while being an improvement over the 1992 standard comes with a high computational complexity that makes it non-viable for current mainstream CPUs The main part being the context based binary adaptive arithmetic coder which manipulates bits(not bytes) hence has a high overhead. Part 15 of the spec seeks to replace that with a simpler and faster scheme for a high throughput decoder. This proposal seeks to implement a fully compliant ISO ITU-T Rec. T.814 for ffmpeg. Deliverables - A complete jpeg2000 decoder implementing the part 15 of the decoder for ffmpeg
<p>The release of a new NWB version makes it necessary the reintegration of this format into the awesome open-source in-browser neuroscientific simulator, Geppetto. This integration will allow any Geppetto based application to be able to provide visualization of simulated data alongside of electrophysiology recordings.</p> <p>The purpose of this project is to make the above happen.</p>
Performance-focused, production-level machine learning libraries need to leverage the resources at their disposal to the maximum extent to deliver efficient and effective machine learning workflows that ultimately result in improved user experience. SparkNLP, one such library widely adopted and used by 16% of enterprise companies(as of Feb 2019), is currently capable of taking advantage of CPU optimization capabilities using Intel-optimized Tensorflow. This coupled with other optimizations already allows it to run machine learning pipelines orders of magnitude faster than legacy libraries. Such a library would benefit from solutions like OpenVINO that offer extensive integrations in the ML ecosystem and even further optimization capabilities for inferring and deploying models on a range of hardware platforms. Exposing the OpenVINO API bindings in Java will allow integration with SparkNLP to enable the above-mentioned capabilities, and furthermore, open up avenues for a large community of developers to benefit from OpenVINO’s rich feature set in the future.
<p>With beacons being lit and the specification readily being adopted by organizations all over the world, there is a need for a toolkit which guarantees compliance with the defined beacon API. The toolkit should contain an entire compliance test suite for organizations looking to implement the beacon API, as well as adapters (or protocols for creating adapters) for organizations which want to user their current data for the beacon. My proposed project will implement the toolkit as well as generate more community documentation to further simplify the beacon creation process.</p>
This project aims to develop the frontend components for managing clusters in the Inventory and Transport Space (ITS). Users should be able to onboard and manage clusters through an intuitive UI. Objectives: - Develop UI components for cluster onboarding and management. - Implement validation and error handling for cluster registration. - Ensure smooth integration with backend APIs for real-time updates. - Provide a guided onboarding experience for adding new clusters. Expected Outcomes: - A fully functional ITS management UI. - Improved usability for adding and managing clusters. - Seamless backend integration for real-time data updates.
Package dingo is a python package that analyzes metabolic networks. It relies on high dimensional sampling with Markov Chain Monte Carlo (MCMC) methods and fast optimization methods to analyze the possible states of a metabolic network. It represents a metabolic network with a convex polytope, while the points in the interior of the polytope correspond to steady states of the network. By sampling, dingo, explores and statistically studies the flux space of the network. To perform MCMC sampling, dingo relies on the C++ library volesti. Currently, it provides MMCS algorithm which is based on Billiard Walk and on a multiphase rounding scheme. This project will provide dingo additional options for uniform sampling by exposing into it several C++ implementations of random walks that are included in volesti. Moreover, it will provide sampling from the exponential distribution using the C++ implementation of Hamiltonian Monte Carlo in volesti.
<p>Thanks to Adobe's contribution of their CFF engine, FreeType has excellent rasterization of CFF fonts. However, Type 1 fonts, a similar PostScript font format, has relatively poor rasterization results. This is due to Type 1 being a legacy format, coupled with lack of maintenance for the corresponding module in FreeType. By extending the new CFF module, we can leverage its high quality output for an old format like Type 1.</p>
The project will develop a high-performance Rust backend for graph-based spatial smoothing of hyperspectral images, delivered through an R package, hyperspec.rust. The package will bridge R’s dgCMatrix format to Rust’s faer sparse matrix structure, establishing a reusable FFI pattern for R–Rust interoperability. On the Rust side, pixel neighborhood graphs will be constructed using petgraph, with configurable connectivity to minimize data transfer. Spatial smoothing will be implemented by solving the sparse linear system (I+αL)x=b using iterative solvers (CG/BiCGSTAB) from faer. The project will include tests and benchmarking against pure-R implementations on large datasets along with documentation and a vignette to demonstrate smoothing. Additional goals include CRAN release of hyperSpec.rust, publishing the FFI bridge pattern as a Rust crate, and a JOSS paper.
The Multiple Flightpath Docking Widget in MSS is crucial for visualizing atmospheric data but lacks customization options hindering effective comparison of flight paths. This project aims to enhance the widget's functionality by introducing centralized line controls, adjustable transparency, Matplotlib linestyle options, automatic color assignment, regex filtering, select all/deselect all buttons, integrated legend, operation labeling, and saving user preferences using QSettings. (Deliverables): Enhanced UI with centralized controls. Improved backend filtering with regex. Comprehensive legend design with synchronization. Annotation feature for operation labeling. QSettings implementation for saving/loading preferences. Test cases, documentation, and future work suggestions.