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.
<p>PiType is an already existing protein-protein interaction classifying tool created by my mentor. It currently exists as both a web app and a standalone software package. PiType is designed to classify proteins within a network into different categories: Mutually Exclusive (ME) vs Simultaneously Possible (SP) and Obligate (O) vs Non-Obligate (NO). To do this, PiType takes a series of proteins within a network, analyses them to determine which of the above categories they fit into, and outputs that information as a table. Because of the current input and output format, it is difficult for biologists to analyze and interpret the data. Cytoscape is open source software that provides numerous modules for studying and visualizing protein networks, and as such is the perfect tool to use for PiType. My project over the summer will thus be to create a Cytoscape plugin app using PiType’s already existent algorithms, to create a visualization tool that provides an intuitive interface for biologists. By taking the base features of PiType, and implementing them as a Cytoscape plugin, my project will widen the number of potential users, and the utility of the app.</p>
<p>This proposal considers performing modifications to the existing Operation Theater module to migrate it to the latest OpenMRS platform. The other main goal is to complete the workflow data capturing part along with scheduling to complete the OT module.</p> <p>It discusses</p> <ul> <li>the dependencies in migrating the module</li> <li>Data that needs to captured in operation theater workflows</li> <li>Running the scheduler automatically when the schedule is manually modified</li> <li>Generating reports related to the Operation theaters.</li> </ul>
<p>This project aims to provide support for survey methods in StatsModels. In particular, survey summary statistics, adding probability weighting to existing methods such as mixed effect models and Cox models, and inference for complex surveys are primary goals. Additionally, I plan to extend GEE such that the weights are allowed to be non-constant within groups and also implement Weighted Multilevel models. I will write unit tests for all implemented approaches, testing against R and Stata.</p>
<p>gopy is an excellent tool which generates (and compiles) a CPython extension module from a go package. And I hope more developers could make full use of gopy to migrate their go code into python code. To make gopy more advanced, It is necessary to provide APIs for various Python compiler versions, such as CPython 2/3 and PyPy. This can be improved with CFFI or ctypes. Moreover, many go’s implementations/features are not yet implemented in gopy. So we need to implement implementations such as slices, interfaces, and maps in the go.</p> <p>My goal is to update gopy by using CFFI to support Python3 and PyPy and write detailed documents.</p> <p>Github: <a href="https://github.com/go-python/gopy" target="_blank">https://github.com/go-python/gopy</a></p>
<p>The objective of this project is to implement a simple interprocedural register allocation that attempts to minimize register spill code by propagating register usage information through the program call graph. By examining the register usage information at each call site, the intraprocedural register allocator can avoid assigning registers already used in the called routines and minimizing spill code. Stretch goal for this project would be a link time register allocator. In this register allocation is deferred till linking of the code to optimize the allocation.</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 p5.js Web Editor has no end-to-end tests. As the team works through a TypeScript migration and backend refactor, regressions in core user flows can go undetected and only surface through manual review. This project builds a complete E2E testing suite using Playwright, integrated into GitHub Actions so every PR into the develop branch is automatically validated against real user behaviour. The three deliverables are a working CI pipeline that runs the E2E suite on every PR, a set of prioritised user flows covering unauthenticated, authenticated, and state-transition scenarios, and contributor documentation so the suite can be extended after GSoC without the original author present.
LLMs rely on floating-point arithmetic for inference, but the Logarithmic Number System (LNS) offers a compelling alternative: multiplication becomes integer addition in the log domain, and 16-bit LNS (xlns16) uses only 2 bytes per element, half the memory bandwidth of float32. This project integrates the open-source xlnscpp C++ LNS library into ggml (the compute backend of llama.cpp) as a proper ggml_backend, enabling LLM inference to run entirely in xlns16 arithmetic as a proof of concept. The implementation introduces GGML_TYPE_LNS16 as a native ggml datatype and implements the 13 operations required for a complete transformer inference pass (matrix multiply, softmax, RMS norm, RoPE, SiLU, residual add, along with some others), all using xlns16 kernels. Activations stay in xlns16 format throughout inference; weights are converted dynamically from their stored quantised formats (Q4_K_M, etc.) per kernel invocation using O(1) lookup tables. The backend is validated at two levels: a unit test confirms sub-0.6% relative error on matrix multiply, and an end-to-end run on SmolLM2-135M-Instruct confirms the full transformer executes without crashing. Deliverables: (1) GGML_TYPE_LNS16 datatype registered in ggml; (2) a complete ggml_backend for xlns16 arithmetic covering all ops needed for LLM inference; (3) integration with llama.cpp; (4) a validation test suite; (5) an accuracy analysis comparing LNS and FP output across model layers
The spdx-license-diff browser extension compares selected text on a webpage against the SPDX License List, showing the best matching license and a similarity percentage. The tool is currently broken in modern browsers due to Chrome’s Manifest V3 migration and Firefox compatibility issues. This project will restore compatibility, enhance its matching accuracy based on SPDX guidelines, improve the user interface and ensure accessibility compliance.
This project aims to build ChatPharo, an intelligent, AI-powered assistant that integrates Large Language Models (LLMs) directly into the Pharo development environment. Despite Pharo’s strengths as a live programming platform, it currently lacks a native and user-friendly interface for interacting with LLMs to assist with code explanation, generation, documentation, and debugging. To address this, the project proposes a seamless, modular, and extensible system that connects Pharo with both online (OpenAI, DeepSeek) and offline (TinyLLaMA, Mistral-7B via Ollama) models. A multi-tab chat interface will allow users to manage multiple contextual conversations, while intelligent AI commands (e.g., /explain, /generate tests, /refactor) will directly support day-to-day coding workflows. Memory optimization techniques—including smart caching, chat pruning, and lazy model loading—will ensure smooth performance even in long sessions. A key innovation includes experimenting with pseudo-parallelism in Pharo’s single-threaded architecture by spawning secondary images to offload heavy LLM processing. This enables parallel task handling without compromising the responsiveness of the main Pharo image. By midterm, users will have access to a working chat UI, multi-LLM switching, and foundational coding actions. By the final evaluation, ChatPharo will evolve into a context-aware assistant capable of inline suggestions, AI-driven debugging, and scalable architecture for future extensions. Through full documentation, tutorials, and community engagement, this project will not only enhance developer productivity but also showcase Pharo as a capable, modern AI-enhanced development platform.
Rust's std::arch module houses vendor-specific intrinsics (low-level functions that typically correspond to single machine instructions) which are intended to be used by other libraries. Currently, there is good coverage of type-based tests and instruction-based tests (checking if the assembly instruction generated is correct) in std::arch, however behavioural tests (checking if the Rust implementation of the intrinsic has the same behaviour as the C implementation) cover only the aarch32 and aarch64 targets. This project intends to restructure the way behavioral testing is performed, so that it is simpler to extend coverage to more targets in future. Additionally this project also intends to extend behavioral testing to x86, Wasm32 and LoongArch targets.
This proposal describes: - enhancement of meshsync to run as a library; - implementation of krew plugin for kubectl based on the meshsync library; - addition of integration tests to meshsync; - integration of meshsync library into meshery server.
TinyParrot is a BlackParrot RISC-V multi-core variant that aims to be small enough to fit onto educational FPGA development boards like the Pynq Z2. In order to get there, the TinyParrot variant needs to optimize and constrain itself in order to meet the physical device constraints (such as LUTs, BRAMs, and flip-flops) provided by development boards like the Pynq Z2 FPGA development board. This project will implement size optimizations that ultimately decrease the amount of resources required by TinyParrot, enabling TinyParrot to fit on the Pynq Z2. At a high level, this will be accomplished by first parameterizing the FMUL/FDIV instructions as part of an MFD parameterization effort. Then, hardware primitives will be re-mapping using the BaseJump STL library in order to standardize and optimize the existing RTL. The ultimate goal of these optimization efforts is to implement TinyParrot on the Pynq Z2.
The project primary objective would be bypassing the current usage of the webview library in Scarpe, feeding directly the HTML and Javascript code to the browser running Ruby and Scarpe directly through WebAssembly. Having done that, the project would focus on bulding an educational playground for writing GUIs through Ruby directly in browser.
This project's primary objective was to enrich the mlpack reinforcement learning framework by incorporating new agents, specifically DDPG and TD3, complemented by comprehensive testing and documentation.
Arbalest, a modern geometry editor for BRL-CAD is an improvement over the existing editors MGED and Archer which is developed during the '80s and '90s. The project aims to add a feature for selecting and resizing the primitive through mouse support and also extend the object-oriented C++ Geometry API which includes the C++ "coreInterface" & "LIBGED". The expected outcome will be an improved BRL-CAD GUI.
Publish fine-tuned MobileViT in TensorFlow Hub TensorFlow Hub is the main TensorFlow model repository with thousands of pre-trained models with documentation, sample code and readily available to use or fine-tune. The idea behind the project is to develop new State-of-the-Art models like MobileViT and publish the pre-trained models on TensorFlow Hub using the ImageNet1k dataset. MobileViT is light-weight and general-purpose vision transformer for mobile devices. MobileViT presents a different perspective for the global processing of information with transformers, i.e., transformers as convolutions. Our results show that MobileViT significantly outperforms CNN- and ViT-based networks across different tasks and datasets. On the ImageNet-1k dataset, MobileViT achieves top-1 accuracy of 78.4% with about 6 million parameters, which is 3.2% and 6.2% more accurate than MobileNetv3 (CNN-based) and DeIT (ViT-based) for a similar number of parameters. On the MS-COCO object detection task, MobileViT is 5.7% more accurate than MobileNetv3 for a similar number of parameters.
Tests for the Nix Metacall package will be written, the Nix package will have more precise dependencies , documentation and a CI/CD with Docker shall be setup to tests the packaging process in order to limit the introduction of bugs. Packaging for MacOSX using qemu-OSX in order to virtualize a MacOSX dev environnement, (mind this won't provide support for Apple M1), Metacall will be packaged for the Homebrew package manager. Tests shall be written for GitHub Actions with Docker for different programming language loaders (Python, Rust, C, NodeJS, etc.) And then in a similar manner with Windows, packaging Metacall for the Chocolatey package manager, if more time is left, a strecth goal is to make a package for apt (Debian/Ubuntu), Homebrew (MacOSX) and Chocolatey (Windows).
MapMint is a web-based Geographic Information System (GIS), which is designed to facilitate deployment of Spatial Data Infrastructure (SDI). In an SDI, geographic data, metadata, tools, and the users are connected in an interactive manner in a framework so as to use the spatial information in an efficient and flexible way. MapMint combines various different software in a complete and coherent web mapping platform, thus helping users in building their own maps and web-applications. These web-services are built on top of the ZOO-Project. Visualizing geospatial data in front end is a challenging task. For this, adding Cesium support within MapMint is a great task of building interactive web interface. My deliverables would be, Complete integration of Cesium Library within MapMint.
<p>This project aims to extend the existing <code>tensor</code> extension of uBlas by providing support for <code>subtensor</code>, i.e. views of <code>tensor</code> type, along with the auxiliary types such as <code>span</code>/<code>range</code>. The projects' scope is to improve the existing <code>subtensor</code> implementation while simplifying the overall design and usage.</p>
<p><strong>Beagle-Config</strong> is a tool-set, that aims to provide the functionality to make the most common low-level configuration changes in beagle devices easily and providing a terminal UI to do the same as well as a host-side application for ICS and many one-click enable features for seamless user experience.</p> <ul> <li>Brings down the steep curve and enables anybody to configure their beagle device</li> <li>Makes beagle devices more friendly </li> <li>More configurations can be added at any point in the time</li> <li>Safer than using scripts from a non-trusted source</li> </ul>
<p>Currently, there are no social aspects to channels in Rocket.Chat servers. Many public channels aren't visible enough for the users to view and join. To join a specific channel, they should either know its link or the exact name to search it in the Directory. Also, every single day Rocket.Chat servers have many people coming into their channels, and they are all lost. They do not realize the actual purpose of a channel. So, there can be a better way of letting the new users know what is going on within the server or even within a channel. This project aims to solve the above issue by introducing a new feature called Discovery!</p>
<p>hydrus is a set of Python based tools for easier and efficient creation of Hypermedia driven REST-APIs. hydrus utilises the power of Linked Data to create a powerful REST APIs to serve data. At the moment, hydrus does allow POST operation on hydra:Collection, but new functionalities should be added to effectively update, get or delete particular members from a Collection without actually sending the whole collection in the request payload. The flagship server hydrus can only serve static data and does not provide a way to define custom server-side logic. A new feature for dynamic endpoint could be added so that a developer would be able to define logic/functions for how the incoming data is processed on the server end. A lot of improvements are possible in CRUD operations of hydrus, including setting up constraints and handling errors on the server-side depending upon how the data is stored in a Collection. The project also aims to enhance the functionality of hydrus, optimize existing codes and keep it synced with upgrades and development in hydra-python-core, hydra-python-agent, and Hydra specifications.</p>
<p>TensorFlow (TF) and PyTorch are some of the most popular deep learning frameworks. TF exports networks in its own format; PyTorch supports export of the trained models into ONNX format, which is also very popular. OpenCV is becoming quite popular tool for Deep Learning Inference. It would be very useful to describe clearly how to train a model in TF or PyTorch so that it can be then run in OpenCV.</p>