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>Apache Fineract CN is an Application Framework for Digital Financial Services. It is a system to support nationwide financial transactions and to support the creation of an inclusive, interconnected digital economy for every nation in the world.</p> <p>Fineract CN operates on the principle that financial services are an innovative space and so each fineract microservice encapsulates a domain that can be combined with other microservices to create new platform offerings. Fineract CN microservices can be combined to create new software platforms for digital financial service providers.</p> <p>The purpose of this project is to create a back-office UI and implement required backend features on Fineract CN to be used by the up and coming digital and neo banks that are focused on individuals.</p>
<p>Intel Owl is an Open Source Intelligence, or OSINT solution to get threat intelligence data about a specific file, an IP or a domain from a single API at scale. The current web interface is very limited, so I propose a Frontend Client Application (written in Angular 8) that provides a dashboard with visualizations of large sets of data, analyzer's management, easy way to request new scans and a Tabular/Graph view of the analyzer's report. A prototype of this web app can be found here: <a href="https://intelowlclient.firebaseapp.com/" target="_blank">https://intelowlclient.firebaseapp.com/</a>. I will also work on adding new analyzers and observable types.</p>
<p>Storage is one of the main limiting factors to the recording of information from proton-proton collision events at the Large Hadron Collider at CERN. This project aims to implement an autoencoder based deep-compression algorithm on an ATLAS trigger machine to reduce this storage requirement and improve accessibility time of the collision data captured by a trigger system. We also plan to design an autoencoder model that has a better compression factor and adequate execution time and memory requirements in order to be deployed on a trigger system.</p>
<p>Many industrial robot applications specify a Cartesian end-effector path, that could be under-constrained. The MoveIt’s RobotState function, “computeCartesianPath”, fulfills only a small part of this demand. OMPL has advanced capabilities to handle constraints that are not integrated with MoveIt yet. Examples of applications that can benefit from this integration are robot welding, grinding, painting, and many more.</p> <p>Concretely this would mean integrating OMPL’s Cartesian planning capabilities in the existing planning plugin. If time allows it, I would like to add support for Cartesian path constraints in TrajOpt. All deliverables should include documentation, tutorials, and tests.</p>
<ul> <li>Bassa has been deployed on a single node Kubernetes cluster with good orchestration yet there is a need for a dedicated monitoring and alerting system integrated into this cluster. </li> <li>Bassa has a dedicated API server that serves the purpose of an automated download queue. Writing efficient client libraries would surely be a great use for other developers to easily integrate the automated download queue into their projects.</li> </ul>
<p>In the ten years since its creation, the Pharo programming environment has evolved greatly: it now has Github support and many cool tools; it’s faster, better and more convenient to use both for people who have been familiar with Smalltalk for decades and for complete newbies. However, there’s one thing that is behind in improvements -- code completion. And so having already had some experience with it, this is something I want to work on and improve.</p>
<p>The project features new attributes designed towards usefulness and perfection. Implementing the Provider Module can improve doctor and patient management. In this proposal, Feedback / Bug Report System, Vitals, Visual Improvements and Scheduled Queries will be discussed as well as a projected timeline for the project.</p>
<p>The 'mConference Framework' project aims at developing an Android Framework which allows organizers to create apps for conferences and events. Using this framework, the organizers can create apps for any event, conference or meetup by creating and adding data in the configuration file (XML) from a static webpage.</p>
<p>In this proposal, I discuss my approach on improving the existing reporting platform with more data formats to download, with more visualizations and more statistics.</p>
<p>CuckooML will deliver a mechanism to find similarities between malware through analysing reports about them. Additionally, the software will be able to detect new types of malware - reports not similar to anything seen before (anomalies) - hence, it will constitute an invaluable tool for security researchers.</p> <p>Through the project a state of the art data science and machine learning approaches will be developed and integrated into Cuckoo package being accessible through both: command-line toolkit and as a web based interface.<br> First and foremost, a set of <em>features</em> that well represents the diversity of malware reports will be engineered; it is a common knowledge that the classification - clustering in particular - can only be as good as the features that are used.<br> The development will be focused on <strong>fuzzy</strong> (<em>soft</em>) clustering approaches that can be easily <em>calibrated</em> to maximise their performance. Additionally, the <em>probabilities</em> returned by the classifier will be adapted to serve as <strong>novelty detection</strong> mechanism.<br> Finally, developed approach will be <em>versatile</em> in a sense that user will be able to choose a <strong>context</strong> based on which clustering is performed e.g. platforms at risk, type of threat, etc.</p>
This solution addresses the problem that BanyanDB / BydbQL has a high usability barrier, making it difficult for users to accurately translate natural language queries into executable query statements. In real-world observability and operations scenarios, users often lack deep understanding of query syntax, schema structures, and query patterns, resulting in low efficiency and high error rates. To solve this, the proposal designs and implements an NL2BydbQL intelligent query agent. Leveraging large language models and the LangGraph reasoning framework, the agent converts natural language into executable BydbQL. The system combines RAG (grammar rules, few-shot examples, schema semantics), MCP-based real-time schema awareness, and a multi-stage reasoning pipeline to form a complete loop from intent understanding to query generation and validation. The core approach includes: Building a structured knowledge system (Grammar Rules, Few-shot Examples, Schema Semantic Docs) Designing a dual-path reasoning mechanism (QA vs. Workflow) with dynamic routing based on query complexity Introducing an intermediate representation (IR) to unify generation and repair Ensuring query correctness via parser validation and automatic repair Incorporating runtime feedback and session memory for continuous improvement The deliverables include: A production-ready NL2BydbQL agent (based on LangGraph) A set of structured RAG datasets (grammar, examples, schema descriptions) A complete and extensible reasoning workflow design End-to-end capabilities including query generation, auto-correction, clarification interaction, and execution feedback loop This solution significantly lowers the query barrier and improves the usability and efficiency of SkyWalking and BanyanDB in intelligent operations scenarios.
My work involves porting the game SNKRX from Lua to Atmos, a versatile programming language that is based on concurrency, event-driven programming. The project focuses on replacing imperative Lua patterns—such as manual flag management and nested callbacks—with the main functionalities of Atmos to simplify complex game logic. Specific tasks include refactoring the screen management system into a hierarchy of scoped tasks, converting global variables into linear sequences, and modularizing character ability chains. Throughout the process, the project will measure how these reactive and parallel features improve code maintenance compared to the original implementation.
This project will integrate the Scrutiny Embedded instrumentation library to RTEMS. The result of this project will be an instrumentation interface that provides in-field debugging and an alternative to JTAG-based stop mode debugging, which is particularly useful for hobbyists and beginners, or for those debugging systems which are live. Deliverables will include a working two-way UART transport, integration of Scrutiny functions to RTEMS, the ability to expose specific metrics from RTEMS to Scrutiny, a user facing API for developers, a package under the RTEMS Source Builder titled rtems-scrutiny, and the necessary test suites for all use cases. This effort will provide RTEMS users with an effective Scrutiny port which can then successfully be hooked up to their respective clients for streamlined debugging.
The Pharo VM is written in Slang, a Smalltalk subset that is transpiled to C by the CCodeGenerator. Currently, the entire VM is generated into a handful of large monolithic C files where code from completely different subsystems the garbage collector, the interpreter, and the JIT compiler are all merged together into a single output stream. This makes the generated code difficult to read, navigate, and maintain, and means that changing a single method triggers recompilation of the entire VM rather than just the relevant module. This project introduces separate compilation to Slang by refactoring CCodeGenerator to route generated C code into multiple files, one per class hierarchy, while correctly tracking and emitting #include dependencies between them. The approach involves extending CCodeGenerator to maintain per-hierarchy output streams, implementing a dependency graph builder to determine which hierarchies reference which others, generating corresponding header files with the necessary forward declarations and prototypes, and updating the CMake build system to automatically discover the new files. The deliverables are: a working dependency graph builder for TMethod objects, a refactored CCodeGenerator supporting multiple output streams, successful extraction of the SpurMemoryManager garbage collector hierarchy into its own standalone C file with correct includes as a proof of concept, header file generation for all separated modules, extension of separate compilation to the Cogit JIT compiler and remaining hierarchies, and an updated CMake build configuration. All existing VM tests will pass throughout, ensuring no regressions in the generated code.
This project will rebuild the LateNight skin as a 100% native QML interface, serving as an act of architectural liberation for the Mixxx codebase. By unwiring decades of complex, hardcoded C++ widget logic, the skin will be migrated to a dynamic, GPU-accelerated declarative ecosystem. This involves writing a dedicated C++ QmlThemeProvider bridge to manage dynamic JSON color palettes and assets, converting legacy WidgetStacks to fluid QML state machines, and assembling the deck structure using scalable DelegateChooser layouts. This deep structural re-engineering ensures the LateNight skin remains performant, responsive, and infinitely customizable for community derivatives on modern and portable hardware.
The CVE Binary Tool is a widely used open-source vulnerability scanner that identifies components in binaries and matches them with known vulnerabilities from the CVE database. However, the current implementation requires downloading a 2.5GB CVE database, which is time-consuming and resource-intensive. Many users have expressed the need for a No-Scan mode that allows generating Software Bill of Materials (SBOMs) without downloading CVE data. This project aims to introduce a lightweight SBOM generation feature that extracts component metadata without querying an external database.
This project enhances SymPy’s Beam, Column, and Structure2D modules in the continuum_mechanics package by addressing key limitations in the current implementations. The work focuses on improving method robustness to handle a wide range of edge cases, adding missing features, and ensuring comprehensive testing across various scenarios. Key improvements include: Beam module: Enhanced input validation, improved error reporting for better user experience, and modifications to existing methods to support more complex and symbolic cases. Column module: Introduction of features such as max_axial_force() and max_extension() methods to support horizontal (axial) force analysis, manual support applicataion using apply_load() and bounadary conditions. Structure2D module: Integration of the Column module into Structure2D, enabling full horizontal and vertical structural analysis, making it more flexible and complete.Adding plots like plot_axial_force(), plot_deflection(), plot_extension().adding plots on the structure for better analysis like plot_shear_force_on_structure(), plot_axial_force_on_structure() and plot_bending_on_structure(). and also a plot to show the deformation of the structure under load applications. These enhancements aim to ensure reliability, clarity, and ease of use for students, engineers, and researchers working with symbolic structural mechanics problems in SymPy.
Arterial Spin Labeling (ASL) is a non-invasive MRI technique that measures cerebral blood flow and supports studies on Alzheimer’s disease, stroke, and other neurological conditions. Yet existing software remains rigid, difficult to customize, and often restricted to brain-only research. Flexible ASL (PyASL) introduces a redesigned, developer- and user-friendly architecture that makes advanced ASL analysis accessible to a wider scientific community. Key innovations include: (1) Minimum programming knowledge required — run complete pipelines with more intuitive alternatives, such as YAML config, python notebook, command line interface, etc; (2) Mix & match preprocessing steps — combine algorithms from different pipelines without rewriting the code; (3) Easy plug-ins — add new preprocessing modules with minimal setup; (4) Support for integrating machine-learning models, custom statistics, and quality-control tools; (5) Extensibility beyond the brain to other organs, promoting cross-disciplinary imaging research. This system can cut integration time for new models or analysis steps by 60–80%, reduce development overhead, and foster reproducibility and cross-functional collaboration among clinical and technical teams. By bridging clinical imaging and modern AI, Flexible ASL lowers barriers for both novices and experts, helping to accelerate innovation in non-invasive perfusion imaging.
The primary aim of this proposal is to fix code quality issues in talawa-api, a project under The Palisadoes Foundation. One major requirement for this fix is replacement of the library mongoose, which is an ODM for mongoDB, the primary database for the project. Since, the ODM is to the replaced all together, migration to the relational database postgreSQL is feasible and will also be done under this proposal. The replacement for mongoose ODM will be drizzle ORM. Other than this there are other minor fixes needed that are related to lax code quality constraints and legacy packages used in the project.
The CVE Binary Tool helps the users to determine if their system includes any known vulnerabilities or not. This project idea focuses on creating a GitHub Action for cve-bin-tool which will produce CVE reports in the GitHub Security Tab and will be able to split the issues on the basis of triage. It will be smart enough to scan dependency lists of various languages and suggest version upgrades in the form of pull requests. Also it will produce reports in the form of html and pdf by default in the Security Tab. The GitHub Action will be configurable through yml config file and will be able to scan repositories and SBOMs.
Matching papers to reviewers based on topics is a crucial task for the Neurons, Behavior, Data Analysis, and Theory (NBDT) journal. However, the current automatic reviewer assignment tool that uses SciBERT embeddings, cosine similarity, and linear programming may not capture the semantic meaning of the text accurately. This project aims to address this limitation by finetuning SciBERT on the relevant corpus of data and selecting the appropriate optimization objectives. SciBERT can learn from both the left and right contexts of words and has a vocabulary that is more suitable for scientific texts than BERT. The project will involve creating a training dataset, pre-processing it, generating the appropriate features, selecting and fine-tuning SciBERT, generating the word embeddings from the fine-tuned SciBERT and choosing the appropriate optimization objectives (Contrastive Learning, Learning to Rank Diversely, and LambdaRank) according to the dataset obtained and the subsequent evaluation of its performance. The expected outcome is an improved tool that more accurately matches papers to reviewers for the NBDT journal and can potentially be useful in other domains as well.
The main goal of this project is to improve the user experience of Zulip Terminal by porting features from Zulip web which are not already implemented in ZT. The features to be implemented include supporting unsubscribed streams, direct message side panel and custom profile fields, while also improving unread cycle algorithms and topic matching.
This project aims to develop a user-friendly interface for configuring and managing popular VPN protocols like WireGuard and OpenVPN on Linux servers within the Cockpit web interface. By simplifying the process of setting up and managing VPNs on Linux servers, this project will enable users to easily and securely connect to their servers. I will collaborate with the Cockpit community to develop the necessary backend functionality and user interface features for the project.