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.
Joplin users accumulate hundreds of notes over time, but existing graph plugins only visualize explicit links (:/noteId) and shared tags, leaving semantically related yet unlinked notes disconnected. This project introduces an AI-powered Joplin plugin that uncovers these hidden relationships using text embeddings as the primary mechanism, with optional LLM-based enrichment for labeling and categorization. The default embedding provider is Transformers.js, enabling fully local, zero-setup inference with no external dependencies, while advanced users can opt into Ollama, Google Gemini, OpenAI, or compatible APIs. The system combines explicit links, tag relationships, and embedding-based semantic similarity into a unified graph, ensuring comprehensive note connectivity. The plugin renders this enriched structure as an interactive graph using Cytoscape.js with the fCoSE layout, where node size reflects centrality, node color represents Louvain-detected communities, and edge styles distinguish relationship types (solid for links, dotted for tags, dashed for semantic connections). It includes features such as click-to-navigate, focus mode, filtering, and export to PNG/SVG/JSON. A SQLite-based cache stores embeddings for incremental updates, ensuring scalability and performance, while optional Pass B LLM enrichment adds human-readable relationship labels and categories. The final deliverable is a production-ready .jpl plugin with secure API key handling, provider abstraction, and a comprehensive test suite including deterministic validation of AI outputs.
Apache Fory's compiler can generate type bindings for seven languages, but neither Swift nor Dart have gRPC service generation support. The generate_services() extension point exists in BaseGenerator and is wired into the CLI, but no language implements it yet. This project adds that support for both: Dart will get a new compiler generator (dart.py) covering messages, enums, and unions alongside gRPC stub generation, while Swift will extend the existing SwiftGenerator with generate_services(). Both will emit typed service interfaces and transport bindings using Fory's serialize/deserialize APIs as the codec, covering all four RPC streaming modes with a zero-copy decode path where possible, without introducing any gRPC dependency into the Fory runtimes. Deliverables include the Dart compiler generator, gRPC stubs with golden tests for both languages, runnable server and client examples, cross-language round-trip tests against a Java server, and compiler documentation for the --grpc flag.
ARM-based processors are becoming increasingly common in HPC environments, as in the AWS Graviton, Fujitsu A64FX (one of the world's fastest supercomputers), and various aarch64 nodes at European computing centres. If basf2 can't build on these systems, it's locked out of an excellent infrastructure that the experiment might benefit from. The goal of this project is to explore and evaluate modern, sustainable alternatives to the current Makefile-based approach for externals, ones that can support both x86 and ARM in a unified, maintainable way without duplicating large sections of build logic.
In modern HPC environments, backend services such as SSH certificate management and compute allocation tracking often operate without dedicated, user-friendly interfaces, making them less efficient for administrators and researchers to manage. This project proposes the design and development of web based interfaces within Apache Airavata Custos, including an SSH Signer Admin Portal and an Allocation Management Dashboard. Using Figma for UI/UX design and React with TypeScript for implementation, the system will provide role based access to manage certificates, monitor allocations, track usage, and handle approval workflows effectively.
This project introduces Rust into GNU libcdio, with the goal of modernizing its codebase along with the benefits of Rust's memory safety. This project targets the SCSI MMC library along with a few of the bundled CLI programs to be implemented in Rust. For a start, the MMC library shall be ported to Rust, while keeping the interfaces and symbols same as C. Dependencies on libcdio shall be served through bindings. The CLI programs shall be moved into a separate repository, and implemented in Rust using the clap crate. FFI shall be used to interface with libcdio. The deliverables include a Rust port of the MMC library, along with the cd-read, iso-read, iso-info, mmc-tool commands.
OpenMRS captures every clinical data change via Hibernate Envers, but O3 users must switch to the Legacy UI to view audit logs, creating unnecessary friction. This project builds two native O3 microfrontend packages that surface this data directly in the modern interface. Deliverables include an Audit Log Dashboard on the System Administration page with filterable, paginated audit events and field-level diffs, a Change History tab inside the Patient Chart scoped to the current patient, and a small backend enhancement to openmrs-module-auditlogweb adding entityUuid filtering for efficient patient-specific queries.
RubyGems.org currently lacks transparency into critical package registry events such as gem publications, ownership changes, and deletions, making it difficult to detect supply chain compromises or unauthorized modifications. This project proposes implementing a Merkle tree–based transparency log that records these events in an immutable, append-only structure. The log will provide cryptographically verifiable records that allow maintainers to detect unexpected changes and enable security researchers to audit the Ruby ecosystem.
The majority of mapped sidewalks in OSM lack explicit names, which makes Valhalla generate vague pedestrian routing instructions. This project aims to resolve this problem with three different steps: First, parsing existing OSM tags such as (is_sidepath:of:name, street:name) that are currently ignored, as name aliases. This is a low-risk change that immediately benefits around 30,000 ways worldwide. Then, implementing spatial join in the graph enhancer that assigns street names to unnamed sidewalks by comparing them to nearby vehicular edges with matching heading parallelism and geometric proximity, using angle and distance thresholds. Third will be adjusting Odin's narrative generation so derived names produce natural phrasing instead of the current vague ones. Deliverables include Lua tag parsing with gurka integration tests, the spatial join algorithm with edge case handling, modified maneuver instructions, and performance benchmarks measuring tile build impact. Nice-to-have goals include using (is_sidepath:of) to adjust road class in the Sif pedestrian costing, detecting park entrances and the new ideas we discover during the project.
HPX's existing hierarchical communicator (PR #6834) implements four one-to-all collectives (broadcast, reduce, scatter, gather) with a configurable k-ary tree structure. This project will implement the remaining all-to-all collectives: all_reduce, all_gather, and all_to_all ,using the existing hierarchical communicator, produce rigorous three-way benchmarks (hierarchical HPX vs. flat HPX vs. tuned MPI), and prepare the implementation for integration into an upcoming HPX release.
Problem: SageMath's algebraic number fields (AA/QQbar) have performance bottlenecks in equality testing, arithmetic on high-degree numbers, and symbolic conversion—limitations that affect users in number theory and algebraic geometry. Solution: Integrate FLINT's qqbar_t (Calcium module) as an optional high-performance backend. FLINT is already a Sage dependency, and Calcium provides optimized algebraic number algorithms with rigorous numerical enclosures. Approach: >Create Cython bindings for qqbar_t in sage/libs/flint/ >Implement AlgebraicNumber_flint element and AlgebraicField_flint parent classes in sage/rings/qqbar_flint.py >Ensure coercion compatibility with existing AA/QQbar >Deliver tests, benchmarks, and documentation Deliverables: >Complete Cython bindings for core qqbar_t operations >Drop-in replacement classes for AA and QQbar with full arithmetic and coercion >Test suite and performance benchmarks >User and developer documentation The new backend will be optional initially, enabling side-by-side comparison, with the potential to become the default after validation. This will make algebraic number computations in Sage faster and more robust.
FreeCAD comes with a Robot Workbench, which is capable of 6-DOF robot simulations, trajectory planning and a vendor specific code export (KUKA). After the removal of some copyrighted model assets and years without an active maintainer, the workbench is functional but difficult to use and customise. The robots can only be defined via hand-written VRML and CSV/DH files, the bundled kinematics library has lagged behind the latest upstream release, the axis count for robots is hard coded to six and the documentation for beginners is sparse. Thus this project proposes an incremental modernization of the existing “Mod/Robot” module: 1. Standardised robot imports : Unified Robot Description Format (URDF) is one of the most common standards for describing a robot. Having an easy way to import robots directly from URDF will replace the painful CSV/DH file imports. 2. Generic joint-trajectory export : Having the possibility to export the joint & trajectory data will separate the export process from copyrighted vendor-specific pipelines. The users can post-process the exported data to their specific platform 3. Kinematics library refresh : FreeCAD currently has a local fork of KDL library that lags behind the upstream. Cleaning up this dependency will eventually prepare the path for arbitrary-DOF robots & better robot animations. 4. Documentation : This will help the existing users as well as attract a new user base towards the Robotics Workbench.
This project focuses on transforming Mogan STEM into a web-based, multi-user collaborative platform. Currently, the lack of a functional WebAssembly (WASM) version and real-time synchronization limits its use in modern collaborative research. To solve this, I will compile Mogan STEM using Emscripten, implementing a custom virtual file system to ensure stability. Furthermore, I will develop a real-time collaboration core based on Operational Transformation (OT) and WebSockets. This architecture allows multiple users to edit complex scientific documents simultaneously with "local-first" responsiveness and guaranteed global consistency. Deliverables include: 1. A stable browser-based version of Mogan STEM. 2. An OT-based synchronization server. 3. A complete end-to-end prototype supporting real-time multi-user collaborative editing.
The ECC State Machine Editor in 4diac-IDE has not received the usability improvements applied to other editors like the FB Network Editor. Engineers face friction points: incorrect state placement at zoom levels, strange spline trajectories in transition routing, unreliable Ctrl-drag transition creation, and missing error feedback for invalid conditions. This project takes a three-phase approach: (1) systematic usability analysis and codebase foundation cleanup, (2) fixing identified bugs, and (3) enhancements including Canvas Direct Edit for transition conditions, Smart Snapping, and ECC Live State Highlighting during debugging. Deliverables: Usability Analysis Document, bug fixes (spline trajectory, Ctrl-drag, error feedback, marker navigation), 6+ enhancements, all submitted as focused PRs with documentation and a final project report. Pre-GSoC work already completed: 6 PRs merged including zoom coordinate fix, CreateTransitionCommand cleanup, and documentation improvements — all under direct guidance of mentor Alois Zoitl.
Strong gravitational lenses are rare and scientifically valuable, but finding them in large imaging surveys requires automated methods. Furthermore, simulated data is used due to the lack of available data, but models trained on simulated lensing images suffer a significant performance drop when applied to real observations (the sim-to-real domain gap). This project addresses that gap by combining equivariant neural networks (ENNs), which exploit the rotational and reflectional symmetries of lensing images, with domain adaptation techniques to build a lens-finding pipeline that transfers reliably from simulated training data to real survey images. The project will also develop a hybrid adaptation strategy that chains unsupervised alignment with supervised contaminant rejection to reduce false positives from visually similar objects like spiral galaxies. Through this project, I aim to build a benchmarked ENN+DA pipeline integrated into the DeepLense codebase, a ranked list of lens candidates from an HSC-SSP subregion with catalog cross-matching and property analysis, a cross-survey generalization evaluation, and a final research report with blog post.
As the LLVM Flang frontend matures, a significant gap has emerged between compilation and diagnostic capabilities. Currently, LLDB does not provide native debugging support for Fortran. This project aims to address that gap by building the essential foundation for native Fortran debugging. The goal is to deliver a functional debugging stack that allows users to: Inspect Variables: Support for scalar variables, function arguments, and return values. Data Structures: Inspection of static arrays, character strings, and derived types. Visibility: Implementation of module and global variable lookups. Expression Evaluation: Enabling basic arithmetic and variable inspection via the print command. To achieve this, a new Fortran TypeSystem, a dedicated Language Plugin, and a DWARFASTParser to interpret and traverse Fortran-specific DWARF metadata are needed.
OpenROAD-MCP's adoption is limited by manual setup and the lack of production-grade deployment and validation workflows. This project delivers a complete Docker deployment story with GHCR publishing, cross-platform validation across Ubuntu, macOS, and WSL2, and a six-layer testing infrastructure covering integration tests against real ORFS flows, performance benchmarking, load testing, and memory profiling thus moving the project toward a reliable v1.0 release.
This project aims to improve the reliability and maintainability of the LORIS electrophysiology browser through scoped enhancements to browser behavior, validation, testing, and documentation. I plan to begin by reviewing and reproducing known issues or limitations, then implement targeted improvements in small, reviewable stages with mentor feedback. The expected deliverables include a practical browser improvement, expanded automated test coverage, and developer-facing documentation that helps make the contribution sustainable within the LORIS codebase.
LiquidHaskell is a verification tool that allows Haskell developers to prove the correctness of their code through refinement types. This proposal aims to restore the support for type class elaboration: a feature that enables the verification of typeclasses laws and instances. The work that had been done previously to support typeclass elaboration is currently broken: typeclass methods produce "Unknown logic name" errors, hence the test suite for the feature has been disabled. The aim of this project is to restore this functionality, by fixing the elaboration mechanism responsible for making typeclass methods available during verification. I will trace the elaboration pipeline, implement the necessary fixes and extend test coverage. Additionally, the project will include an in-depth analysis of the features supported by the implementation and how they compare against the expected outcomes in the original paper. The deliverables will include successfully merged contributions on the LiquidHaskell GitHub repository, with its corresponding documentation, and a post with the solution on the Tweag blog.
Perturbation biology datasets across CRISPR screens, MAVE, and scPerturb-seq remain siloed in incompatible formats, making cross-modal reasoning about genetic perturbations nearly impossible at scale. This project builds a perturbation-aware LLM by fine-tuning BioMedLM on a curated multimodal training corpus derived from the EMBL-EBI Perturbation Catalogue, enabling natural language queries such as "what happens if gene X is knocked out in cell type Y?" Deliverables include a multimodal training corpus, a fine-tuned LLM prototype, a reproducible evaluation pipeline with gene-level splits distinguishing genuine generalisation from memorisation, and full open-source documentation for reuse by the Perturbation Catalogue team.
Currently, Catrobat users have to return to the Catroid IDE every time they want to play their projects, which breaks the experience and makes their creations feel less like real, standalone apps. To address this, I propose introducing a “Pin to Home Screen” feature that allows users to launch their projects directly from the Android home screen, just like any other app. This will be achieved using a lightweight ShortcutTrampolineActivity that retrieves the project ID and opens it directly in Play mode, along with proper task configuration so each project runs independently and exits back to the home screen instead of the IDE. The project will include a smooth UI integration with adaptive icons, a decoupled StageActivity for independent execution, robust lifecycle handling to manage renamed or deleted projects safely, and comprehensive automated testing (JUnit and Espresso) to ensure reliability across different Android versions.
This project focuses on improving the performance of core processes in wagtail-localize, particularly in the construction of the page index and in translation workflows that operate on large page trees. Current analysis of the codebase reveals patterns that lead to repeated database queries and sequential processing, which can negatively impact performance as the number of pages and locales grow. These issues become especially noticeable in large, content-heavy sites, where administrative actions such as translating or updating page subtrees can become slow and less reliable. The project will begin by measuring query counts and execution time for key operations, establishing a baseline for comparison. Based on these measurements, the page index construction will be refactored to reduce database queries by fetching data more efficiently and processing it in memory. Translation workflows will be analyzed to identify opportunities to reduce sequential processing and improve performance when processing large page trees. Additionally, the current mechanism for detecting content changes will be reviewed to reduce unnecessary work when no updates are required. The main deliverables include characterization tests and benchmarks, a refactored page index implementation with reduced query counts, improvements to translation workflows, and an evaluation and potential optimization of content change detection. All improvements will be validated against the established baseline to ensure measurable performance gains.
The `loo` package is a widely used R package in the Stan ecosystem which exposes a clean API to cross-validate (CV) Bayesian models. Currently, some `loo` functions use parallelization by way of forking processes, which doesn't work on Windows but has some benefits over other parallelization schemes with respect to memory. The `mirai` package is a new approach to cross-platform parallelization which relies on daemons, allowing package developers to write parallel code without any knowledge of where the code will be executed--allowing users to scale up to any number of local or remote cores. `mirai` represents one approach to updating `loo`'s approach to parallelization. After this project, users of `loo` will be able to run some expensive calls in parallel, regardless of the OS they use, and ideally in any environment they would like--be it a SLURM cluster, SSH access to a large server, across a homelab, or just on many cores on their local machine.
The proposal titled "Event Classification With Masked Transformer Autoencoders" aims to enhance particle jet tagging by developing a Lorentz-equivariant Particle Transformer (Lorentz ParT) that adheres to the symmetries of special relativity. This hybrid architecture combines Lorentz Geometric Algebra Transformers (L-GATr) with Particle Transformers (ParT) to compute physical invariants, such as invariant mass, while tracking geometric orientations between particles. A key innovation is the introduction of Gated Particle Attention, which addresses residual bottlenecks in standard transformers by dynamically weighting contextual information against original features. The model is designed for a dual-head functionality, performing both self-supervised classification across ten unique jet classes and continuous mass regression using the JetClass dataset. To optimize learning, a Masked Autoencoder (MAE) approach is utilized to understand underlying jet symmetries before label-based training begins. Preliminary results indicate that the gated prototype can achieve a lower eta loss than original methodologies, although it currently faces challenges with "hallucinating noise" in reconstruction maps due to increased parameter counts. The proposed 12-week execution plan focuses on establishing mass regression, mitigating ROC curve issues, and validating the architecture against a scratch model to ensure stable performance
I plan to make BRL-CAD python bindings. Basically my goal is to make a Python interface for BRL-CAD using MOOSE as the core modeling backend, with a thin C bridge between Python and C++ for stability and portability. The architecture is: Python interface -> moose_rt3 adapter (ctypes) -> C bridge -> MOOSE C++ API -> BRL-CAD database engine -> .g file. I plan to work around 3 goals: 1. Database lifecycle behavior should be consistent across read-only, writable and in memory modes with clear errors when operations are invalid 2. Core primitives and CSG operations should be exported correctly and transforms must be stored as combination-member matrices so results are verifiable by MGED. 3. Unified read access: provide one Python read entrypoint for supported object families with a stable return format and desterministic errors for missing or unsupported objects