Explore Projects

The NeuroHealth-Vision project aims to bridge the "Protocol Gap" in 3D medical AI by developing a standardized evaluation and transfer-learning framework for volumetric foundation models (VFMs). While current generalist models excel in common thoracic or abdominal tasks, they often struggle with specialized clinical protocols involving unique acquisition physics and contrast kinetics. This project will systematically benchmark frontier architectures (like CT-FM, etc.) across various unseen specialty downstream tasks using zero-shot, few-shot, and Parameter-Efficient Fine-Tuning (PEFT) methodologies. Deliverables include open-source preprocessing pipelines for 3D volumetric normalization and spatial alignment, alongside optimized model weights and a comprehensive benchmarking report. This work will ultimately provide the multimodal "perception engine" for the broader NeuroHealth clinical assistant, enabling it to integrate high-dimensional imaging data into its diagnostic reasoning core.

This project enhances OpenCRE’s cybersecurity compliance platform by addressing scalability, usability, and transparency gaps. The resource-intensive gap analysis tool will be optimized through Neo4j query refinements, Redis caching, and Python code streamlining to run efficiently on laptops (under 5 hours, <16GB RAM). A React-based frontend for MyOpenCRE will simplify compliance workflows with drag-and-drop CSV uploads and AI automation (leveraging NLP models) to map standards like SOC2 to CREs, while unmapped controls trigger suggestions for new CREs. The Explorer module gains debugging tools to visualize hierarchical relationships, root nodes, and metadata (e.g., shared tags), improving maintainability. Deliverables include a performant engine, intuitive UI, rigorous testing (50%+ coverage), and documentation, all merged into OpenCRE’s codebase to empower enterprises, auditors, and contributors with scalable, open-source compliance management.

Visualization is an important aspect of computer graphics because it’s useful to visualize the result of an algorithm and help to debug errors in code. Since CGAL 4.13, a basic viewer is provided in CGAL to visualize different CGAL data structures. This project aims to improve current mechanisms (e.g. Polyhedron, Surface_mesh, Linear_cell_complex, Polyhedral Surface, Linear Cell Complex, 2D Triangulations, 3D Triangulations, 3D point set, 2D polygon, a 2D polygon with hole, Voronoi Diagram, Periodic 2 Triangulation 2, Nef Polyhedron, and Arrangement 2, etc.) to allow users to coloring attributes, choose the type of appearance, working interactively in 3D mode(e.g. Add Or Drag/Drop points), mix different viewers in application like using parallelism for visualize point cloud and a surface mesh at the same time, and use new viewers technologies like WebGL(for web viewers), SDL, and Orge3D(3D Engine).

Building recommendation engine for suggesting reviewers using Natural Language Processing and Huggingface library. I will be using the editors’ abstract of the data set. Apply pre-trained Bert embedding. After I have generated encodings for all the editor’s abstract present in the data set, I need to create encodings for the words of interest from the reviewer’s information extracted and find similarity between reviewers’ research interests and the encodings of the editor’s abstract. I will cosine similarity or other similarity formulas to determine the similarity between the vectors. Higher cosine score signifies the more similarity between the two vectors. We can then query the data set using numerous reviewers’ interests and rank the cosine similarity scores along with their corresponding editors’ abstract. Deliverables: I plan to accomplish the following over the summer: - Apply BERT models from HuggingFace on editors abstract for topic modeling. - Then find similarity scores between different topics using cosine similarity. - Serve the model on the web. - Documenting, publishing on Jekyll pages.

This mentorship builds on the ""Sliderule"" Encoder and Decoder Cheat Sheets project, which is a highly visual and condensed view of the information contained in the RISC-V specification documents for consultation and education purposes. The sliderules are especially designed to facilitate manual encoding and decoding of assembly, placing instructions coherently in the binary address space. This original project was compiled by hand on a Google Sheets document and later exported to PDF: this method has the advantage of producing aesthetically pleasant results, but it is slow to create and expand, error prone, non interactive and version controllable only in a very limited way. The general goal of this mentorship consists in extending the information contained in the slide rule to RV64GC and obtaining a web page that interactively shows subsets of the sliderules to the user thanks to an information selection interface and is able to export PDFs from it. The main goal is to create a tool that serves as an education oriented consultive tool that documents the RISC-V instruction set in a more user-friendly way. The project shall be deployed from a GitHub repository.

<p>The Kalman Filter is a method of iteratively predicting the future state of a system based on previous information. Not only is a Kalman Filter more reliable about predicting future state than traditional extrapolation techniques, It also provides a confidence for the estimate. A Kalman Filter is used both to reduce the impact of sensor noise on estimations, and to determine which sensors can be “trusted” more than others. Whereas more primitive methods for estimation and extrapolation rely on some form of averaging, a Kalman Filter forecasts by developing a weighted covariance for each sensor input.</p> <p>The aim of this project is to implement a Kalman Filter in Rust. Rust has gained popularity for providing more compile-time checks than other systems-level languages, namely C and C++. Rust’s memory model ensures that there is little to no room for many of the memory pitfalls common in other low level languages, such as double-freeing memory, dangling pointers, and user-after-free errors. This, in conjunction with high runtime performance, leads writing components of a codebase in Rust to be favorable for both speed and stability.</p>

Publicly available Greek datasets like those on OpenGov are a goldmine of information but they often contain personal details that need to be hidden to comply with privacy laws like the GDPR. Doing this automatically for Greek text is tough because the language is highly inflected and the documents are usually full of OCR scanning errors. To tackle this I am proposing a standalone ML assisted anonymization tool that plugs right into the glossAPI pipeline. Instead of a heavy slow model I am using a lightweight hybrid approach. It uses fast regular expressions and custom dictionaries to catch standard info and fix OCR typos while leaning on Microsoft Presidio and the spaCy multilingual pipeline to smartly detect complex entities like names and organizations. By wrapping this engine in a simple FastAPI REST interface we keep the main glossAPI codebase clean and independent. By the end of the project I will deliver this fully functional privacy API the necessary code to link it to glossAPI and clear practical documentation so future maintainers can easily protect sensitive public data.

Neovim currently cannot run natively in web browsers because its build systems and dependencies, such as libuv rely on OS-level features unavailable in WebAssembly (WASM). This project aims to enable Neovim as a WASM build target by adapting its build systems, creating a WASM compatibility layer to stub or replace unsupported OS features, and integrating a browser frontend. It involves compiling Neovim’s core editing engine, Lua 5.1 interpreter, and runtime files into WASM, adapting asynchronous event loops, handling virtual filesystems via Emscripten, and providing replacements for system calls like signals, threads, and process management. The deliverables include a fully functional nvim.wasm binary with embedded runtime files, a browser frontend capable of rendering the UI and handling input via Neovim’s RPC protocol. This will allow Neovim to operate within the browser which increases accessibility, enables integration with online IDEs and educational platforms, and expands Neovim’s ecosystem to new users and contributors.

<p>This is the proposal for the project idea shared on OSM wiki page <a href="https://wiki.openstreetmap.org/wiki/Google_Summer_of_Code/2017/Project_Ideas" target="_blank">https://wiki.openstreetmap.org/wiki/Google_Summer_of_Code/2017/Project_Ideas</a></p> <p>"Suggested By - Zverik</p> <p>Summary</p> <p>To increase a number of public transport routes in OSM, we need a simple to use web-based editor. It would need to download stops and route relations, edit tags and relation members, keep nodes connected to ways, know about stop positions and platforms. See this write-up. The criteria for finished work will be a functioning and error-free web editor for stops and route relations. Way editing is not required (though it would be an interesting problem).</p> <p>Skills Required - JavaScript (+leaflet, +packaging, +xml processing, +some framework), HTML+CSS, OSM data model</p> <p>Difficulty - Medium</p> <p>Possible Mentors - Zverik</p> <p>Notes</p> <p>Comments"</p>

Jupyter Notebooks provide a powerful, interactive environment widely used by data scientists and ML engineers for exploratory analysis, visualization, and prototyping. However, as the scale and complexity of data workloads grow, running computations locally within notebook pods becomes inefficient and limiting. The Batch Processing Gateway integrates with Kubeflow Spark Operator to manage the full lifecycle of Spark applications in a cloud-native environment. It enables distributed computation at scale and automates job deployment, resource management, and status tracking using Kubernetes Custom Resource Definitions (CRDs). This project proposes integrating Jupyter Notebooks and the Batch Processing Gateway, enabling it to manage the notebook kernel lifecycle of remote Spark kernels as distributed Spark applications. This decouples computation from the notebook pod and scales Spark workloads efficiently in Spark. To achieve this, we will introduce Batch Processing Gateway to manage the lifecycle of Notebook kernels and introduce Jupyter Enterprise Gateway (JEG) for runtime communication to enable Jupyter messaging protocol for notebook cell execution during runtime.

<p>The Wayback Machine archives billions of webpages, with vast numbers being added to the collection every day, including news sources. Though the crawling operations are quite successful, there is still work to be done to improve the quality of webpages archived by checking for “broken” or “bad” pages. I propose developing a methodology to assess the quality of news sources, both in terms of bias/factual reporting and in terms of technical viability such as geoblocking, paywall blocks, and CAPTCHAs. I will then use this methodology to create a tool that can automatically assess quality and take an appropriate action, perhaps preserving an error message and reason for failure in the Wayback Machine. This tool will ideally be integrated with the Wayback Machine’s web crawlers. I will also use my findings to develop recommendations for circumvention tactics, such as paying for subscriptions to important news sources or negotiating agreements with CAPTCHA services to allow the Internet Archive, as a public good, to bypass the CAPTCHA. The goal of the project is to develop a system to think about the quality of archived webpages and then create tools to automate quality assessment.</p>

The RISC-V movement has massive potential to unify a fragmented industry behind a single instruction set architecture (ISA). If technology providers focus their efforts on a single processor architecture, rather than duplicating efforts among incompatible architectures, the entire computing ecosystem benefits. Inefficiency in critical base components of the ecosystem hampers this consolidation. There are numerous projects which directly serve as the base components of the software ecosystem, including assemblers, disassemblers, compilers, linkers, loaders, simulators, emulators. In most of those projects today, the human-readable documentation is consulted, and the necessary implementations are performed manually. Needless to say, these processes are time-consuming, inefficient, and error-prone. A new foundation which can serve as a base for automatically generating large swaths of the processor-dependent ecosystem is available, but is not yet effectively use. The “RISC-V Unified Database” project has transformed the salient content from within the RISC-V specifications into an accessible format, YAML, from which content for downstream projects can easily and automatically be further transformed into the content necessary to their project which is currently produced by manual effort.

With more than 1 million new diagnoses reported every year, prostate cancer (PCa) is the second most common cancer among males worldwide that results in more than 350,000 deaths annually. The key to decreasing mortality is developing more precise diagnostics. Keeping this in mind, this project attempts to develop a sophisticated diagnosing technique that will highlight the potential cancerous regions in a given ‘Prostate biopsy slide’, thereby aiding the doctors in faster and more accurate diagnosis. However, in the presence of a Subject Matter Expert (SME) (doctors, radiologists, etc.…) this task becomes trivial, but in the absence of SMEs diagnosing PCa via 'Whole Slide Images' is almost always impossible. In many developing countries, the healthcare sector is drastically underfunded and the vast majority of these countries cannot provide basic healthcare to the public. In such conditions, the availability of doctors is very unlikely. Automated analysis and classification of biopsy images without the presence of any subject matter expert is a crucial task. Thus, developing a reliable and robust system, susceptible to noise, in the form of a web app or inference engine is the project's main goal.

<p>This proposal is for adding MPI support to GeNN. GeNN is known as a GPU-enhanced Neuronal Network simulation environment based on code generation for Nvidia CUDA. However, the limitation of GeNN is that it can only support running on a single GPU or a single shared-memory machine. This proposal is to plan for expanding GeNN to multiple machine clusters. MPI is common message passing interface and infrastructure to communicate across multiple hosts and it is natural to expand GeNN with MPI interface to achieve parallel execution on multiple hosts. The key point of this project is to balance GeNN computation simulations across MPI hierarchy between hosts and block/thread on individual GPU. Furthermore, This proposal shows potential tuning directions basing on MPI-CUDA hierarchy. To bridge the gap between the destination and implementation, this proposal also describes feasible stages for the MPI-GeNN project and narrates the candidate’s motivation, background and progressive approach. Curriculum vitae is attached to the last pages for reference. The candidate is welcome to any questions, comments or suggestions through any of the contacts, such as email, telephone, and skype.</p>

<p>GeneTech allow users to develop genetic logic circuits only by specifying a Boolean function. The tool first performs Boolean optimisation, followed by synthesis and technology mapping. Currently, a user can define the desired behavior in the standard Boolean notation. I would like to add the support for designing a circuit via drag and drop method on a design canvas. This functionality would allow users, specially electrical/electronic engineers, to design a genetic circuit by constructing the circuit schematic on a design canvas using drag-drop-wire approach. GeneTech will then transform the circuit schematic into the corresponding genetic circuit and represent it in the standard SBOL notation. The results produced by the current version of GeneTech do not include the DNA basepair encoding of circuit components. I would like to update the tool to be able to embed the DNA sequence of generated circuits in the SBOL file.</p> <p>Most of the code-base of GeneTech is currently a pre-compiled version of the Java code which adds additional overhead and dependencies. We would also like to convert the Java code to Python and reduce dependencies along the way</p>

Scrum Helper currently supports only GitHub and a partially-integrated GitLab, with all platform logic tightly coupled in a 2,190-line monolithic file. This makes adding new SCM platforms nearly impossible without duplicating the entire data-fetching flow. This project refactors Scrum Helper's core into an extensible Provider Pattern architecture by defining a standardized SCMProvider interface that decouples platform-specific API calls from the report generation engine. I will then implement native providers for GitLab (including self-hosted instances), Gitea, and Bitbucket, each returning normalized data through a unified schema. Deliverables: (1) SCMProvider interface with normalized data models, (2) Refactored GitHubProvider with full regression coverage, (3) GitLabProvider with self-hosted baseUrl support, (4) GiteaProvider tested against Codeberg, (5) BitbucketProvider with OAuth 2.0 auth, (6) unified caching and cross-provider error handling, and (7) architecture guide and contributor docs for adding future providers. All 4 platforms will generate identical scrum reports by project end.

<p>loklak is free software hosted on loklak.org which provides message search results from twitter in json format. loklak is a complete search engine back-end solution with a JSON api. What is missing to provide a search web page is a web page design showing the json search results as timeline in the style of a twitter search result. Add features to the existing wall and improve the current timeline so that it becomes a common social platform for social media. Basically it should look like <a href="https://twitter.com/search?src=typd&amp;q=fossasia" target="_blank">https://twitter.com/search?src=typd&amp;q=fossasia</a> in the right column while the left column has to provided new/other search navigation tools. The data to be presented will all be within the json API of loklak. The timeline web page must also provide - switching off the left navigation columns and switching on self-refreshing which turns the timeline into a twitterwall - some kind of animation when selecting navigation options in the left column (i.e. fade-in and fade-out of select options)</p>

<p><a href="https://irde.st" target="_blank">irde.st</a> is a software suite that allows users to create an internet-independent, decentralized &amp; ad-hoc wireless mesh network. It removes all the dependencies of a user from a specific service and enables users to create a local network mesh of their own. It does not expose data or information of the user, even the IPs of the peers present in the mesh are not known, they communicate via routers and the entire communication is end-to-end encrypted between the users, thereby increasing privacy in user data. As of now, Irdest supports various functionalities to users like sharing files over the network created, call between users, and messaging.</p> <p>This summer I plan to package and implement some of these core functionalities in an android application. The project aims at first building the FFI layer for interaction between the rust lib and android, a strong, robust &amp; unbreakable CI with cross-compilation enabled, and then implementing the features required. The final product/deliverable of this project will be an android application that'll support the features which are provided by Irdest in the upstream, and a robust plus <em>modern</em> application codebase.</p>

<h3>Motivation</h3> <p>With the current trend of increasing parallelism, there is a need for a uniform way of making these parallel implementations available along with the default serial ones. Currently in PCL, this has been done by providing separate classes/functions having independent APIs.</p> <p>With the integration of execution policies and executors (part of C++23 hopefully) libraries like PCL will be able to provide a unified API to switch between different implementations. To ensure there is no sudden breakage in the existing API, a transition phase is needed to slowly phase out the old API in favour of a unified API.</p> <h3>Implementation</h3> <p>This project aims to transition the existing API to forward-compatible unified API. The basic details are: Using tag dispatching to enable function overloading, allowing user to select between different available implementations. Lack of tags allows PCL to choose best possible implementations, this allows to maintain backward compatibility with current API. Missing implementation for a tag raises compile-time errors Providing SIMD/OpenMP/CUDA implementations of existing algorithms using the proposed unified API.</p>

<p>The primary aim of this project is to make enhancements to Zulip’s REST API Documentation framework, which allows writing API Documentation based on the OpenAPI standard with built-in automated tests.<br> Major tasks include modifying the framework and testing to allow generating API pages directly from OpenAPI data and removing the redundant templates, and adding support for auto-generated API bindings by integrating different tools into the framework.<br> The docs will also be visually enhanced by improving the organisation and UI of /register and /events endpoints, and /api pages in general. This would include major design changes to the documentation pages to improve the overall user experience. Further, the OpenAPI data for currently undocumented /api endpoints will be added to improve the endpoint coverage by the docs.<br> This project would also involve fixing the currently open issues related to API Docs area, majority of which improve the testing of OpenAPI data, as well as making various API migrations with appropriate updates in OpenAPI data. Also, improvements would be made to the organisation of OpenAPI data and its testing/error messages to make it easier to maintain and work with.</p>

Java-Ranger is a path merging extension of Symbolic Pathfinder, that collapses multiple execution paths into a single region with a disjunctive constraint. Currently, it handles only integer constrains, which means, floating-point (FP) operations are either approximated unsoundly or cause solver errors. In this project, the aim is to add sound IEEE-754 floating-point support to Java ranger, enabling the correct summarization of regions containing FP arithmetic, comparisons, conversions, and library calls. The work heavily involves refactoring the underlying FP support in SPF (Modelling special values, rounding, comparisons, and conversions), then extending Java Ranger’s AST visitors, merging heuristics, and solver integration to handle the new FP constraints. The result will be an engine capable of analyzing FP-Java programs. Deliverables include: - New floating‑point expression nodes in the numeric package. - Updated bytecode handlers for all FP instructions. - Solver integration for Z3bitvector using the floating‑point theory. - Constant folding and simplification passes for FP expressions. - A test suite validating the correctness and coverage of FP handling. - Documentation of the new API and usage.

This project develops an intelligent clustering system that groups student submissions by similar patterns, algorithmic approaches, and correctness levels. The system enables TAs to efficiently manage large-scale grading while maintaining fairness and consistency. Problem: TAs face repetitive, time-consuming grading of similar submissions with risk of inconsistency and human error, especially in large courses (100+ students). Solution: Automated clustering of submissions using hierarchical agglomerative clustering with interactive dendrogram visualization. TAs can merge/split/reject clusters, bulk apply feedback templates, and flexibly grade (bulk or individual). Key Deliverables: - Feature extraction engine (68-dim for code, 389-dim for text) - Hierarchical clustering with Ward linkage - Interactive dendrogram UI for TA manipulation - Bulk feedback application system with per-student customization - Flexible grading modes (bulk, individual, hybrid) - Comprehensive testing and documentation Expected Impact: 80-90% reduction in grading time while improving consistency and feedback quality. Time savings: 45 submissions graded in 15 minutes vs 225 minutes without clustering.

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.