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.
<h3>Introduction</h3> <ul> <li>The BeagleWire is an FPGA development platform that has been designed for use with BeagleBone boards. BeagleWire is a cape on which there is an FPGA device (Lattice iCE40HX). The software support for BeagleWire is still in the development phase. </li> <li>In this project, I'm developing and testing the existing software support of Beaglewire. The known primary issue in Beaglewire is the interface between 32MB SDRAM and ICE40HX4K. For this Solution, I'm going to try options like LiteDRAM(a small footprint and configurable DRAM core). </li> </ul> <h3>Testing and Improvement of Subsystem Like I2C, SPI, PWM, UART</h3> <ul> <li>In this project I'm going to test all the subsystems like I2C, SPI, PWM, UART in Hardware and the primary goal will be to debug the issues related to them and fix them accordingly. Along with the driver code ready to use solutions will be added in software support.</li> </ul> <h3>Others</h3> <ul> <li>There are current Issues open on BeagleWire Repository, These will be solved during this project.</li> <li>More PMODs will be interfaced with the BeagleWire.</li> <li>Increase the Documentation and also add getting started guide for BeagleWire.</li> </ul>
<p>Opportunistic IPsec is an attempt to encrypt the internet at large. The idea is to build VPN tunnels directly to all internet hosts irrespective of the communication used. An initial proof of concept was created that leverages LetsEncrypt certificates for use with IKE and IPsec. The goal of this project is to turn this proof of concept into production quality code that makes it trivial to enrol and deploy on any server and any client.</p> <p>The project has the following objectives:</p> <ul> <li>Automate Client, Server configuration and the enrollment and updating of LetsEncrypt certificates for use with libreswan.</li> <li>Implement a DNS/DNSSEC based method for advertising Opportunistic IPsec support using LetsEncrypt for servers.</li> <li>Design a non-DNS based method for publishing support of LetsEncrypt based Opportunistic IPsec for servers.</li> <li>Enhance libreswan to allow a secure fallback to the existing NULL Authentication method.</li> <li>Ensure the working of two behind the same NAT. Along with ensuring the working of two clients behind NAT, with one not using IPsec.</li> <li>Support the recovery from server OR client reboot/crashes. Along with ensuring no lockouts happen.</li> </ul>
*OPEN TO US BASED STUDENTS ONLY* - Accepting applications until May 23, 2025 Alpine was primarily designed by Google to enable testing of an SDN-controlled fabric without an embedded control plane. However, Alpine can be extended to support traditional routing protocols that are supported by hardware SONiC switches. This project will help make Alpine more broadly useful as a virtual SONiC switch. Expected Outcomes: 1: Enable the routing container (FRR) in Alpine virtual switch image 2: Extend the Alpine configuration to include BGP configuration 3: Test the configuration in a mirror testbed 4: Identify any data plane gaps (and if found, update Lucius) 5: Run the SONiC test suites 6: Document running and configuring BGP in Alpine Recommended Skills: Kubernetes, Linux, Networking, Go Relationship to SONiC and Impact on Community: One of the main goals of Alpine is to provide a virtual switch with a dataplane to accelerate software delivery with fast test iterations. Integrating support for the widely-used BGP protocol in Alpine significantly broadens its applicability and increases its relevance to the SONiC community. Additional Information: https://youtu.be/55X1_2utiVg
<p>The internet today is rich in image-content, from entire websites like Instagram and Pinterest dedicated to curating and displaying images, to Facebook and Reddit that have large amounts of content in image form. Non-visual users find it challenging to navigate and use these websites for their intended purpose. The information in images, whether on the internet or stored locally, is also inaccessible to non-visual users. NVDA or NonVisual Desktop Access is a free, open-source, portable screen reader for Microsoft Windows. It already includes an OCR that can recognize text within images, however, it lacks any functionality to describe image content and allow users to interact with the various objects within images. This project aims to overcome these issues through two modules:</p> <ol> <li>A machine learning module to generate descriptive captions for images on the user’s screen or those manually inputted by the user.</li> <li>An object detection model that draws bounding boxes around recognized objects and outputs the object label when the user’s pointer enters a bounding box. The outputs of both these modules could be presented to the user using NVDA’s existing mechanisms such as voice or braille.</li> </ol>
<p>Brian is a free, open source simulator for spiking neural networks. It is written in the Python programming language and is available on multiple platforms. Brian is designed to be easy to learn and use, highly flexible and easily extensible. It is a simulator designed to save processing time and to ease the work of scientists.</p> <p>With this increased acceptability of NeuroML as a standard model for describing detailed models of neural systems, a need to implement support for NeuroML into Brian simulator has increased. With so many models now using NeuroML for describing their neural systems, there has been a demand to integrate NeuroML morphology extraction inside Brian. NeuroML also contain LEMS definitions of the ion channels and their distribution which will be extracted and used.</p> <p>This project is mainly divided into 3 parts:</p> <ul> <li><strong>Implement support to import NeuroML morphologies inside Brian 2</strong> </li> <li><strong>Add support to conveniently access to other information stored in the NeuroML file, like ion channels and their distribution information.</strong> </li> <li><strong>Test and evaluate differences between simulations of NeuroML models in Brian 2 and other simulators (such as NEURON)</strong></li> </ul>
<p>Systems Biology Markup Language (SBML) is a standard format for the representation and exchange of biological models between computers. The information in an SBML model file is organized as a list of components encapsulated within the model (e.g. compartments, species, parameters, reactions, etc.). However, SBML is difficult to read, comprehend and interpret by humans directly, and tools are required to provide an abstraction layer to interact with SBML objects and the relationships between them. The objective of the project SBML4Humans is to address this issue by providing an interactive and reactive report for SBML models which will allow humans (experts as well as beginners) to easily comprehend the content of a model. The key features introduced in the interactive report are:</p> <p>i) interactive SBML report with navigation between SBML objects</p> <p>ii) search and filter functionality</p> <p>iii) web application with REST API</p> <p>iv) downloadable standalone reports</p> <p>v) support for hierarchical models</p> <p>vi) support for distributions and uncertainties</p> <p>vii) support for COMBINE archives</p> <p>Such an interactive report will thus significantly enhance the process of reading and exchanging SBML models.</p>
This project aims to enhance the Checker Framework by introducing a Mutable Index Checker, which provides compile-time guarantees of index safety for dynamically sized data structures such as ArrayList, LinkedList, and Deque. Unlike the current Index Checker, which focuses on fixed-length structures like arrays and strings, this checker will track collection size changes across mutations, enabling flow-sensitive reasoning and validation of index accesses. The checker will support annotations like @IndexFor, @LengthOf, @SameLen, and custom subtyping rules to enforce both lower and upper bounds on index values. It will also provide support for aliasing-aware length consistency, post-mutation invalidation, and integration with purity annotations. Deliverables include: - A new pluggable type checker integrated into the Checker Framework. - Support for standard mutable collections with annotated APIs. - Type qualifiers and subtyping rules for index tracking. - Flow-sensitive analysis and invalidation logic on mutations. - Real-world examples, documentation, and a case study on annotating existing codebases. This tool will help developers prevent IndexOutOfBoundsException in mutable structures by enforcing correctness at compile-time—making Java applications safer and more robust.
Lumen handles tabular data through DuckDB but cannot work with N-dimensional scientific formats like NetCDF, Zarr, and HDF5. This project brings first-class xarray support to Lumen by building on my already-merged XArraySQLSource (PR #1741), wiring it into Lumen AI for natural language queries over scientific data, and extending the Pipeline to natively handle xarray.Dataset via narwhals. After this integration, a climate scientist can run "lumen-ai serve data.nc" and ask "show temperature anomalies over Europe" - the AI generates DataFusion SQL, queries the data, and renders the visualisation. Deliverables: 1. Source enhancements: cloud data support (S3/GCS/HTTP via fsspec), multi-file datasets, Dask chunked lazy loading 2. AI integration: coordinate-aware context builder, Jinja2 prompt templates, scientific analysis subclasses 3. Pipeline support: Narwhal compatibility layer, native xarray.Dataset operations without flattening 4. Documentation: user guide, API reference, 3 tutorials, 5 gallery examples Xarray has 16M+ monthly downloads, but no framework connects it to an AI-queryable dashboard today. This project fills that gap.
Geant4 is a highly accurate and detailed simulation toolkit used for simulating the passage of particles through matter. Due to its strict precision requirements, simulation is slow and has been proven to be a bottleneck for physics analysis. To overcome this bottleneck, popular machine learning techniques like generative modelling have been employed as a fast simulation alternative. This project focused on the Optimization and Inference components of the project. Very limited work is done on the model in terms of Memory Footprint Reduction. This project was aimed at implementing different post training Memory Footprint Reduction techniques by creating a pipeline using KubeFlow, consolidating all the insights from different experiments and use them to extend KubeFlow pipeline built for carrying out the experiments into a more generalized form which can be used on different ML models at CERN to output the best optimized model. I integrated different Onnx Runtime Execution Providers - MLAS (default CPU), CUDA, TensorRT, oneDNN and OpenVINO into the Geant4 Par04 inference module. I have implemented an end-to-end KubeFlow pipeline which contains CPU and CUDA optimization modules which leverage different quantization and graph optimization workflows and reduce memory footprint of models while maintaining similar performance. Optimization modules for oneDNN and TensorRT are currently in-development at the time when GSoC is ending.
<p>Additional Login Options focuses on providing more than one ways to login to a user account on Cadasta platform. The main goals of this Project are listed below priority-wise:</p> <ol> <li>Phone Support</li> <li>OAuth Login</li> <li>MultiFactor Authentication</li> </ol> <p><strong>[Goal 1] Phone Support</strong> Currently, users can only SignUp/SignIn with email ID, but there are many users who do not have email accounts. To make Cadasta Platform available to those users, we provide Phone Support, to allow the user to Register with a Phone number.</p> <p><strong>[Goal 2] OAuth Login</strong> Providing the users with an option to Sign In with Social Providers such as Google and Facebook.</p> <p><strong>[Goal 3] MultiFactor Authentication</strong> Allowing users to make their account more secure by enabling Multifactor Authentication.</p> <ul> <li>Users Sign In with the password, and then with App-based TOTP.</li> <li>Users Sign In with the password, and then with SMS OTP</li> <li>Users Sign In with the password, and then with Email OTP</li> </ul> <p>I have listed more than one ways to implement these goals in my proposal and have planned my timeline convenient to those implementations.</p>
Inspektor Gadget is an eBPF tool and systems inspection framework for Kubernetes, containers and Linux hosts. In this project, you will write a new gadget in BPF and WASM to detect deadlocks in applications. The BPF program will be attached on mutex locks and mutex unlocks functions with uprobes. The WASM program will build a mutex wait directed graph and look for cycles. Then, the gadget will display the stack trace showing the mutex locks causing the deadlock. This project builds upon previous work: - In a previous mentorship project, Inspektor Gadget gained support for uprobes and kernel stack traces (https://www.inspektor-gadget.io/blog/2024/06/supporting-uprobe-based-gadgets-lfx-mentorship-report/). - BCC tools include deadlock.py doing the same: https://github.com/iovisor/bcc/blob/master/tools/deadlock_example.txt and https://github.com/iovisor/bcc/blob/master/tools/deadlock.py However, this project still has challenging issues to resolve: - Inspektor Gadget does not support dumping stack traces from userspace applications yet Expected Outcome: A new gadget detects lock order inversion and prints the stack traces where each mutex was acquired.
<p>Addin system of MonoDevelop/Xamarin Studio (<a href="http://www.monodevelop.com/download" target="_blank">http://www.monodevelop.com/download</a>) is very flexible and allow the developers to add or extend any feature in the IDE .CBinding addin allow the developers to use C/C++ for writing the solution. However, there are still many features that are missing, some of them are :-</p> <p>1) Ability of the CBinding to use compilers present on Windows (GCC/MSVC/MinGW32), this will also require support for CMake as that's the only project format CBinding currently has .</p> <p>2) Implement support and switching between various Toolchains available in CMake.</p> <p>3) Detect missing dependencies (libclang, CMake etc) and prompt the user to install them.</p> <p>4) Adding various refactoring features .</p> <p>There are many other things that can be done to make it even more better like improving project and file templates, improving code completion, adding a test suite etc . Since old "MD1" project system is no longer supported so it can also be removed.</p> <p>Main purpose of this proposal is to come up with an idea to implement some of these features and make changes to the existing ones.</p>
DataLoom is a browser-based data wrangling workspace that enables users to upload tabular datasets, apply reversible transformations, and manage data visually without writing code, supported by a checkpoint and revert system. Currently at the MVP stage, DataLoom supports only CSV files and lacks key capabilities such as data profiling, visualization, dataset merging, and efficient column selection. This project expands DataLoom into a full data preparation platform by introducing multi-format ingestion, automated data profiling, dataset joins and concatenation, formula-based transformations, reusable pipelines, interactive visualizations, and an automated data quality engine with scoring and one-click fixes. It also adds multi-format export and downloadable reports. Key deliverables include multi-format ingestion and export, a profiling API with a reusable column selector, join and merge operations, a visualization panel, a data quality engine, a formula editor, reusable pipelines, downloadable reports, a full frontend TypeScript migration, a refactored backend, comprehensive testing, and a redesigned scalable UI. The outcome is a robust, end-to-end data preparation tool that supports the complete workflow from raw data ingestion to cleaned, analyzed, and export-ready datasets.
The Splash projection mapping software allows for controlling multiple video projectors together to build a single projection. It is able to adapt to virtually any real geometry, as long as the surface is diffuse. Its rendering engine is built using the OpenGL API. It currently runs on platforms capable of running Linux and handling an OpenGL 4.5 context, and has been tested successfully on x86_64 (with NVIDIA, AMD and Intel graphic cards) and aarch64 (with NVIDIA graphic cards). However to be able to: a) optimize it further and b) support more platforms (for example Raspberry Pi), it would be interesting to support more graphics API. To do this it is envisioned to replace direct use of OpenGL with an intermediate, multi-API rendering library. Work Done: 1) Investigating available rendering libraries and APIs supported by the Raspberry Pi 4. 2) Modifying Splash's OpenGL 4.5 code to work with OpenGL ES and thus the Raspberry Pi 4. 3) Merging the old OpenGL and the new OpenGL ES codepaths to allow one binary to run both. 4). Pulling out graphics code such that application classes are only responsible for application logic, they just use the provided graphics API specific implementation. 5) Rudamentary performance profiling. 6) Bug fixes to application and graphics code.
Problem: Installing Julia, opening a terminal, running Julia REPL, then opening the package manager, adding Pluto package, running Pluto, and then going to the browser to run it. How many steps was it? 7. Seems quite uninviting. Now think of a person who has never touched any terminal in his life. Seems like an even more daunting task. A person who is only interested in running a Pluto Notebook and running Julia on it may or may not know how to do any of these steps, and since these can be automated, why keep this task to the end user? My Plan to solve: This is where this app comes in, bundles all these steps, runs this in the background, and then only shows the user their notebook running inside the app itself, no browser required. Deliverable: An Electron app that can perform the following tasks: 1. Install Julia and pluto on the first run. 2. Show the pluto view inside the app. 3. Allow the view to interact with the server. 4. Support the native file system features of Pluto. 5. Support running more than one instance of Pluto views. 6. Support light and dark modes. 7. Be responsive (allow different screen sizes). 8. Show the Julia Package Page inside the app itself to refer to some documentation when and if required. 9. It should also have proper comments and documentation for future reference.
The objective of this project is to perform a performance and benchmarking analysis of BESU, a Hyperledger project, in private networks (QBFT, IBFT, CLIQUE) using Hyperledger Caliper. This project aims to identify the strengths and weaknesses of BESU in terms of maximum transactions per second, latency, computation power, hard disk space, etc. Additionally, this project aims to add support for more complex and well-known workloads like ERC20, ERC721 in Caliper, which are used by general Ethereum users. This project will provide valuable insights into the performance of BESU and will help developers optimise it for better performance. Learning Objectives Through this project, the mentee will: - Develop skills in benchmarking and performance analysis of blockchain networks - Gain experience in working with Hyperledger Besu and Hyperledger Caliper - Learn to add support for new workloads in Caliper - Improve their programming skills by working on a real-world open-source project - Learn to write technical research reports and documentation. Expected Outcome The expected deliverables of this project are: - A detailed report on the performance of BESU in private networks (QBFT, IBFT, CLIQUE) - A set of benchmarks for BESU in private network with different configurations - Support for ERC20, ERC721, etc workloads in Hyperledger Caliper - Documentation on how to use the benchmarking tool and the new workloads.
Apache SkyWalking BanyanDB currently supports only local file systems through the remote.FS interface, which limits its flexibility in cloud-native environments. This project aims to extend remote.FS by implementing support for major object storage services including AWS S3, Google Cloud Storage, and Azure Blob Storage. Each backend will fully comply with the remote.FS interface to ensure seamless integration. The implementation will include cloud-specific optimizations such as multipart uploads, resumable downloads, and SHA-256 checksum validation to ensure data integrity. Additionally, the system will handle rate limiting, transient errors, and support configurable retry strategies. The project will also include a unified error mapping layer and Prometheus-based monitoring metrics. Deliverables: • Production-ready remote.FS implementations for AWS S3, GCS, and Azure Blob Storage. • Unit and integration tests using tools like GoMock and LocalStack. • Logging and observability features with structured logs and Prometheus metrics. • Complete documentation and setup guides. • Community demo and contribution-ready pull requests. This enhancement will enable seamless and secure cloud deployments of BanyanDB, significantly reducing operational complexity while improving scalability and reliability.
The current FreeBSD environment lacks robust automated testing for Rust kernel modules and officially maintained Rust drivers. Past projects for Rust in FreeBSD started with Johannes Lundberg's Master's Thesis, where he created a RustKPI, e1000 Rust Network Driver, and a Rust kmod Hello World Example. From this, we saw Anatol Ulrich create a Hello World kernel module and a research article about writing FreeBSD kernel modules in Rust by David Young. Outside these contributions, Rust's current progress in FreeBSD is very shallow. This lack of depth makes it difficult for others to learn and build upon. I propose to analyze and extend the past work of others to assist anyone wanting to further the development of Rust in the FreeBSD kernel. My project will focus on these primary goals: 1. Creating tests in /usr/tests tree using ATF & Kyua for an existing Rust Driver 2. Use these tests to find errors in the driver logic, repairing them when needed. 3. Create a updated environment where developers can easily code and compile Rust FreeBSD device drivers. 4. Create both a Hello World driver and an Echo character driver with this environment. 6. Publishing clean and effective Rust device driver documentation for future developers to expand and work with the environment.
LFortran is a modern, interactive Fortran compiler built on LLVM that aims to support real-world Fortran codebases. This project focuses on enabling full compilation and correct execution of two real-world Fortran packages benchmark.f (a benchmarking library) and feq-parse (an equation parser) using LFortran. Significant pre-GSoC progress has already been made: benchmark.f currently compiles to 76% and feq-parse to 40%. The remaining blockers include missing quadruple precision (REAL(KIND=16)) support, deserialization ICEs for forward-referenced symbol tables, ExternalSymbol resolution failures for struct-scoped types, ASR verifier false positives for GenericProcedure constructor calls, and an LLVM IR type mismatch in character length handling. The project will follow an iterative, compilation-driven workflow: attempt compilation, identify failures, reduce to MREs, fix the compiler, and validate against gfortran. Every fix will be accompanied by integration tests to prevent regressions. Deliverables: - Full compilation of both benchmark.f and feq-parse with LFortran - All example programs and test suites passing with gfortran-consistent output - End-to-end quadruple precision support across parsing, ASR, and LLVM backend - All fixes merged as pull requests with integration tests
The proposed GSoC project aims at integrating support for the Faust audio programming language into HISE, an extensive framework for the creation of sample-based virtual musical instruments. There are multiple ways to accomplish the integration, ahead-of-time compilation and just-in-time compilation, each with their specific benefits and shortcomings. The most straight-forward method involves ahead-of-time compilation of the Faust code into a dynamic library which the HISE instrument can interface with. This works well for finished products which will be exported and compiled once, but run many times. During prototyping, however, build time is essential and relinking the complete instrument would be excessive. In that case machine code will be generated just-in-time (JIT) from the Faust source code whenever it is modified without recompiling or linking the rest of the instrument. Faust already provides the necessary mechanisms for just-in-time compilation via LLVM, which will be tied to suitable data structures inside HISE. Lastly HISE also provides an integrated development environment (IDE) with a syntax-highlighting text editor to the instrument developer. Programming the instruments in Faust should be an on-par experience to the developer when comparing to other supported languages, e.g., SNEX and JavaScript. Therefore the existing development environment will be extended to support the Faust language, while allowing the developer to still use their editors and tools outside of HISE.
The RISC-V Mentorship Program enables one or more 12-week internship-style projects per session, funded by RISC-V, to match mentors/project leaders together with mentees/interns . Mentees are guided through a series of milestones by one or more project mentors, with whom the mentees meet on a weekly basis. Convolution is the core operation of deep learning models and computer vision applications. MLIR supports various convolution operations. Our project is to vectorize them for the RISC-V backend. There are several methods to implement convolution vectorization, such as optimizing nested loops, implementing vectorization algorithm, converting to GEMM, etc. This project needs to choose a vectorization method and implement a conversion pass for the convolution operations. As for the vector semantic support, MLIR has the “Vector” dialect for the general vector abstraction, and it also allows the backend-specific vector dialect, such as the “x86vector” dialect, “arm_neon” dialect, and “arm_neon” dialect. Like these dialects, the project also needs to propose an “RVV” dialect and work with existing dialects and tools. Deliverables: - An MLIR “RVV” Dialect. (Operations in the dialect can support the convolution vectorization) - A conversion pass to vectorize convolution operations in “Linalg” dialect with “RVV” dialect enabled. - A conversion pass to lower the operations in “RVV” dialect to “LLVM IR” dialect. - Unit tests for “RVV” dialect and conversion passes.
This project addresses the absence of HTTP streaming support in the Rage framework, where responses are currently fully buffered before being sent to the client. This limitation prevents real-time use cases such as incremental LLM outputs, live data feeds, and large streaming responses. Even when applications generate data in chunks, the Iodine server collects all output into a buffer and sends it only after completion, making true streaming impossible. To solve this, the project introduces native HTTP streaming using chunked transfer encoding across both Iodine (C layer) and Rage (Ruby layer). A new streaming path will be added to Iodine to support incremental writes with a robust backpressure mechanism, ensuring the event loop remains non-blocking. On the Rage side, a developer-friendly API (render stream:) will be implemented using enumerators and fibers, allowing applications to stream data declaratively while seamlessly handling pause/resume behaviour under backpressure. The deliverables include implementing the http_stream transport, a Rack-compatible streaming writer with lifecycle and backpressure management, and the Rage streaming API. The project will also provide integration tests, edge-case handling (e.g., disconnects, high load), and updated documentation. This enables real-time streaming in Rage while preserving compatibility and supporting future extensions like HTTP/2.
VCell-AI is an AI-powered platform for discovering, analyzing, and exploring biological models from the VCell database. While the platform already provides a functional chatbot interface, it requires additional capabilities to support real-world usage — including authentication, usage control, and broader integration with scientific data sources. This project aims to extend the system across these dimensions. Auth0 authentication will be integrated using the existing VCell Auth0 tenant, allowing existing VCell users to log in seamlessly. On top of this, a per-user token tracking and enforcement system will be introduced, along with an admin dashboard for managing limits. The prompt handling layer will be refactored into a centralized registry to improve consistency and reduce fragmentation. Local LLM support will be exposed as a user-facing feature. The system will also be expanded with PubMed search, complementing the already implemented BioModels DB integration. To improve usability, BNGL-based molecular visualization will be integrated. Support for SBML data will be completed, and BioPAX pathway data will be introduced as an additional source for biological knowledge. Prior to the coding period, 8 pull requests have already been raised covering API standardization, local LLM bug fixes, and BNGL visualization integration as a proof of concept, demonstrating familiarity with the codebase and commitment to the project.
Fragmented cultural heritage artifacts — such as Mayan stelae displaced from their original sites — exist today as scattered, incomplete pieces that are nearly impossible to physically reassemble. This project builds an AI-driven virtual reconstruction pipeline for Stela #43 from the Naranjo archaeological site, operating on 3D-scanned .PLY fragment data. The system combines a Point Transformer V2 backbone for geometric feature learning, a Siamese network for fracture surface matching, a Graph Transformer for globally consistent assembly reasoning, and a Trimmed ICP alignment module with pose graph optimization. A synthetic fracture dataset with realistic surface degradation simulation addresses the limited availability of real labeled data. Every learned component has a geometric fallback, and uncertainty quantification ensures low-confidence matches are flagged for human expert review rather than committed automatically. Deliverables include: a modular PyTorch reconstruction pipeline, a reusable synthetic fracture data generation tool, trained model checkpoints, a robust coarse-to-fine alignment module, a global pose optimization module, a full quantitative evaluation report comparing results against the existing geometric baseline, and complete technical documentation. The system is designed to augment archaeologist judgment — not replace it — by pre-screening thousands of potential fragment matches and providing interpretable, auditable match explanations.