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.
When `urunc` is used together with a block-based snapshotter, it can take advantage of block-device backed container root filesystem and pass it directly to the sandbox as a disk image. This approach avoids filesystem conversion and enables efficient access to the container root filesystem. However, in order to spawn the sandbox, urunc requires access to the guest kernel and the initrd (if present). Since these files are part of the container rootfs, `urunc` must first extract and store them elsewhere before attaching the block-based root filesystem to the sandbox. As a result, this process introduces unnecessary file copies and additional I/O overhead. A more efficient approach is to leverage read-only (view) snapshots. Instead of copying files, `urunc` could request a read-only snapshot of the container root filesystem and mount it separately. The kernel binary and other required artifacts could then be read directly from this snapshot without modifying or duplicating data. Since view snapshots simply redirect read requests to the underlying snapshot layers, this approach is expected to introduce little to no additional storage overhead while simplifying the runtime flow. - Expected Outcome: - A document explaining block-based snapshots in containerd, along with the respective APIs to snapshot creation and management. - An implementation in `urunc` that requests and mounts a read-only snapshot of the container root filesystem. - Evaluation of performance
This project aims to integrate the Sloan sparse matrix ordering algorithm from the Boost Graph Library into pgRouting, enhancing its capabilities for graph optimization for both undirected and directed graphs. The Sloan algorithm generates optimal vertex ordering that reduces profile and bandwidth of graphs, significantly improving the efficiency of matrix operations in network analysis applications. While pgRouting includes several matrix manipulation algorithms, it lacks specific matrix ordering algorithms like Sloan ordering that are essential for optimizing sparse matrices in network analysis. Current workarounds require users to export data to external tools, breaking workflow continuity. I plan to develop a new function pgr_sloanOrdering() with complete integration, comprehensive error handling, and support for both directed and undirected graphs. The implementation will leverage the Boost Graph Library's existing algorithm with careful adaptation to pgRouting's architecture. The project deliverables include a fully implemented Sloan ordering algorithm integration, comprehensive documentation and usage examples, an extensive test suite with performance benchmarks, and support for various graph types with configurable parameters. This project will benefit the community by expanding pgRouting's graph analysis capabilities, particularly for applications in transportation networks, utility network management, and scientific computing where matrix ordering significantly impacts computational efficiency.
Proposal Summary: The project aims to achieve two primary objectives: efficient and precise particle identification and the development of effective lossless data compression techniques for the CMS Experiment at the Large Hadron Collider (LHC). Efficient and Precise Particle Identification: Traditional particle identification methods involve complex algorithms analyzing data from the CMS detector. Recent advancements suggest using convolutional neural networks (CNNs) directly on raw detector images, known as the "end-to-end" approach, for streamlined processing and competitive identification efficiency. The project seeks to explore and enhance vision transformers (ViTs) for particle reconstruction, benchmarking against established CNN models. Development of Effective Lossless Data Compression Techniques: The CMS experiment generates massive amounts of data from particle collisions, posing challenges in processing and storage. Data compression techniques are crucial for extracting relevant information while reducing data volume for efficient processing and analysis. The project aims to develop innovative masked auto-encoders (MAEs) with vision-transformer-based encoders for efficient data compression, enhancing downstream tasks' performance. Overall, the project endeavors to contribute to advancing particle physics research by improving particle identification accuracy and optimizing data handling through innovative data compression techniques.
<p>The aim of this project is to enhance some portions of the application that implement the Internet Message Access Protocol (IMAP). Specifically :</p> <h5>CONDSTORE</h5> <p>The Conditional Store extension, defined in <a href="https://tools.ietf.org/html/rfc7162" target="_blank">RFC 7162</a>, adds an additional mod-sequence value to every message. This makes it possible to reference changes made to the mailbox made since a particular point in time, which is extremely useful for mobile clients that are not always connected to the internet. Adding support for the CONDSTORE extension will help to greatly reduce the time and data spent on resynchronization.</p> <h5>Search</h5> <p>K-9 Mail has a basic search feature that searches the local database as well as the remote server for messages. The project aims to add features that make it more modern, such as suggestions, nested search, filters and proper full-text search.</p> <h5>Miscellaneous improvements</h5> <p>Support for some additional IMAP operations will also be added :</p> <ul> <li>Using the UID EXPUNGE command when available so that messages deleted by other clients are not expunged by accident.</li> <li>Switching between and modifying namespaces.</li> <li>Moving messages across different IMAP accounts.</li> </ul>
<h3>Implementation of Newsfeed (a social feature) in Rocket.Chat Server</h3> <p>This project adds a newsfeed for every user. In it, the users can follow other users. Whenever a user posts something in a public channel or does any public activity, it would appear in the newsfeed of all his followers with a link to the original post in the original channel. This would greatly help in discovering new conversations, increasing accountability of people in the organisation & increasing many folds the time a user spends on RC</p> <p><strong>The most challenging part of creating the newsfeed is to make it scalable to support a large number of concurrent users (by using an adaptive follower/following relation model) and to benchmark the server performance in relaying the correct messages with filters. This is being done by using proper schema and proper database queries. Messages in newsfeed are fetched in real-time from messages stored for other channels.</strong></p> <p><em>Key Features:</em></p> <ul> <li>Support for Rich Message blocks</li> <li>Auto-summarization of messages to prevent spam in newsfeed</li> <li>Expandable embedded conversations</li> <li>Upvoting System & Trending messages</li> <li>Group messages by origin user, date, channel etc.</li> <li>Integration with other projects</li> </ul>
capa is an open-source tool that identifies program capabilities using an extensible rule set. Currently, the project relies purely on static analysis of code structures to identify patterns. This project extends capa to work on dynamic execution data such as sandbox run traces or code emulation analysis. The introduction of dynamic analysis to capa is set to make analyzing samples that feature anti-analysis techniques a much easier task. This is an issue of concern since a large number of distributed software nowadays gets packed with commercial or private packers, which means that capa would fail to profile these executables' capabilities successfully. However, this can be circumvented by introducing dynamic analysis to the problem, which it would enable capa to get a view of the program after it had been unpacked in memory, thereby making it possible to extract the capabilities from the executable at hand. Deliverables: 1. Add support for the future integration of several sandbox solutions by means of an associated feature extractor. 2. Implement a feature extractor for the Cuckoo-based CAPE Malware Configuration and Payload Extractor. 3. Introduce capa features that are specific to dynamic analysis (such as captured network traffic). 4. Add dynamic-based support for function call arguments. 5. Write novel rules that make use of the newly introduced dynamic capability extraction.
The proposal aims to enhance Eclipse Winery, a web-based environment for modeling OASIS TOSCA topologies, by implementing basic security measures. Currently, Winery focuses on providing a graphical editing environment for modeling application topologies. However, the proposal suggests adding a Language Server Protocol (LSP) provider for OASIS TOSCA YAML files. This would allow Winery to support the latest version of the OASIS TOSCA standard and handle dynamic type additions. The expected outcomes of the project include: 1-Developing an LSP server that supports the latest OASIS TOSCA 2.0 standard. 2-Ensuring that the LSP server is aware of newly introduced types and makes them available in the service template. 3-Enabling the LSP server to handle multiple files. 4-Demonstrating the functionality of the LSP server using compatible IDEs such as Eclipse Theia, Visual Studio Code, or Eclipse IDE. 5-Writing clean and maintainable code, with a preference for using modern Java (version 21 or later). The proposal indicates that the project's size is estimated at 350 hours and rates its difficulty as medium. Overall, the proposal aims to improve the security and functionality of Eclipse Winery by implementing an LSP server for OASIS TOSCA YAML files, thereby providing a more robust and comprehensive modeling environment.
The current Kubeflow SparkClient (KEP-107) provides a solid foundation for running interactive Spark workloads on Kubernetes, but it is still missing key capabilities required for real-world usage, such as batch job submission, consistent job lifecycle management, and production-level observability. This project focuses on extending the SparkClient to support complete, production-ready Spark workflows. The primary goal is to implement a robust submit_job() API for batch job execution using the SparkApplication CRD, supporting both script-based and function-based workloads. Alongside this, I will design a consistent set of lifecycle APIs such as job listing, status tracking, log retrieval, and cleanup, ensuring they align with existing Kubeflow SDK patterns. To improve usability in production environments, the project will also introduce observability features, including metrics collection from the Spark REST API, structured event tracking, and basic health monitoring. These additions will help users better understand job execution, debug failures, and monitor resource usage. The implementation will build on the current architecture without breaking compatibility, focusing on reliability, validation, and consistency. The final outcome will be a more complete and production-ready SparkClient that enables users to run, monitor, and manage Spark workloads on Kubernetes in a simple and consistent way.
<p><a href="https://community.kde.org/KDEConnect" target="_blank"><strong>KDE Connect</strong></a> is an application to sync your connected devices. Some of the features of KDE Connect include:-</p> <pre><code>- sync mobile and desktop device notifications - send and receive files between devices - use mobile device as a presentation remote - sync clipboard on both devices - use mobile device as keyboard and/or mouse. </code></pre> <p>KDE Connect also supports plugins that extend the utility of KDE Connect, like- pausing the music or other playing media on a desktop if the mobile device starts ringing, preventing desktop from going to sleep if a device is connected, <em>et al</em>. All these plugins can be fully controlled by the user.</p> <p>KDE Connect for Windows currently builds using <a href="https://community.kde.org/Craft" target="_blank"><strong>Craft</strong></a>, but has a lot of problems and is currently not suitable for an official release. This project aims to release a port for Windows OS, by fixing the existing plugins accordingly to also support Windows OS, adding system integrations and publishing the official build to the Windows Store.</p> <p><strong>By the end of this project, we should have a release-able installer shipped to the Windows Store for review.</strong></p>
<p>Current Red Hen Lab’s Audio Pipeline can be extended to support speech recognition. This project proposes the development of a deep neural-net speech to text module for the pipeline, based on the paper Deep Speech. The aim is to use both audio and visual modalities for achieving speech recognition.</p> <p>The initial goal is to extend current Deep Speech model (audio only) to Red Hen lab's TV news videos datasets. The next goal is to develop a multi-modal Speech to Text system (AVSR) by extracting visual modalities and concatenating them to the previous inputs.</p> <h5>Project Outline</h5> <p>I plan to develop four versions of Speech to Text during 12 weeks time.</p> <ul> <li>Version 1: Rewriting the Deep Speech model to support audio inputs from Red Hen Lab datasets. </li> <li>Version 2: Improving results using either N-gram model or a spell check system</li> <li>Version 3: Extracting visual features, concatenate them with Audio features and modify Deep Speech’s Input</li> <li>Version 4: Improving results using the same approach as in 2, tracking actual speaker’s lips, etc.</li> </ul>
The project focuses on upgrading the Eventyay platform components to VueJS 3 within the unified Eventyay codebase. While minor adjustments are required for the ticketing components, the primary focus lies on modernising the talk and video modules, which currently rely heavily on VueJS 2, as well as on updating project-specific plugins. The objective is to replace all existing VueJS 2 code with VueJS 3 across the entire platform while preserving existing functionality and API compatibility. As the Eventyay platform is being consolidated into a single repository, the project also includes implementing additional API features where necessary to support the unified infrastructure. The upgrade improves the maintainability and performance of the platform, aligns it with current best practices, and ensures long-term sustainability of the frontend codebase. Throughout the project, Vue dependencies are upgraded, and components are systematically refactored to address breaking changes introduced in Vue 3. Extensive compatibility testing is carried out to ensure stability across all migrated features. Updated components are made fully functional under Vue 3, with a gradual transition from the Options API to the Composition API where appropriate, leveraging the benefits of improved structure, reusability, and maintainability. In parallel, the continuous integration pipeline is refined to support automated testing and deployment, including the seamless rollout of updated documentation that reflects the evolving architecture and feature set of the unified platform.
Liquid Galaxy is an open-source panoramic multi-display system used in museums, universities, and science centers worldwide. Its entire installation infrastructure install.sh and all supporting configuration files was written for Ubuntu 16.04 LTS, which reached End of Life in April 2021. As a result, Liquid Galaxy cannot be installed on any currently supported Ubuntu version, leaving existing deployments without security patches and blocking new ones entirely. This project is a systematic, layer-by-layer migration of Liquid Galaxy to Ubuntu 24.04 LTS (Noble Numbat). Rather than patching each broken line individually, I will introduce an OS abstraction layer a lib/ directory of functions that encapsulate every OS-dependent operation, from network detection and display manager configuration to package management and service control. This ensures the system can survive future Ubuntu LTS releases without requiring a full rewrite each time. Deliverables: 1) Updated install.sh working end-to-end on Ubuntu 24.04 2) lib/ OS abstraction layer with testable, version-aware functions 3) GitHub Actions CI pipeline 4) Post-install smoke test suite 5) MIGRATION.md, TROUBLESHOOTING.md, and updated README.md with complete architecture documentation.
This project aims to develop a comprehensive Out-of-Tree (OOT) module for GNU Radio that enables amateur radio enthusiasts to incorporate FT8 and WSPR functionality directly into their applications. Currently, most operators rely on standalone applications like WSJT-X, limiting flexibility and integration possibilities. The proposed solution is to create modular, reusable components for encoding, modulating, demodulating, and decoding FT8/WSPR messages. These components will include: FT8/WSPR Message Encoder: Implementing standard message formats with validation for callsigns, grid locators, and signal reports FT8/WSPR Modulator: Building 8-FSK modulation for FT8 and 4-FSK modulation for WSPR with proper timing and tone spacing FT8/WSPR Demodulator: Creating components to detect signals, handle frequency drift, and extract weak signals from noise FT8/WSPR Message Decoder: Implementing error correction algorithms and partial decode support Integration Components: Developing example flowgraphs, time synchronization, and potentially QSO tracking features This module will allow experimentation with weak signal protocols, enable integration into complex signal processing chains, provide educational value for understanding digital mode implementation, and support development of new applications leveraging these protocols—ultimately bringing more skilled contributors to the GNU Radio community.
Premature birth is highly prevalent with every one in ten births being premature. A common complication in premature birth is hypothermia (the baby cannot regulate its body temperature). Low-middle income settings limit access to neonatal incubators and radiant warmers. Thus, there arises a need to develop low-cost solutions to support premature newborns in their early and vulnerable stages of life. KMC (Kangaroo Mother Care) is a technique widely practiced to provide thermal support to newborns. During KMC, a caregiver maximizes contact with the newborn by laying the newborn, skin-to-skin on their chest. Since KMC is a highly burdening activity, the caregiver might need breaks for personal care making the baby vulnerable to a loss of a thermal source. The patented NeoWarm device is a low-cost solution to this problem. It not only augments the natural KMC session by providing extra heat but also regulates and monitors the temperature of a newborn even when the caregiver-newborn dyad is not engaged in KMC (standalone mode). The NeoRoo app provides a digital interface to the NeoWarm device by monitoring the vitals of the baby over BLE and sending alerts to responsible medical professionals and parents if the baby's vitals are found to be abnormal. It also establishes a mode of communication between the medical professionals and the guardians of the baby so that there are shared goals, coordinated tasks along with exchange of information for better neonatal care.
@nightwatch/mobile-helper is a tool that allows developers and testers to set up a fully functional Android Emulator environment in just a few minutes, without the need to download the complete Android Studio IDE software. This tool comes in very handy, especially for testers who wish to perform end-to-end tests for their website or native app on Android Emulators, by allowing them to set up everything they need in under 5 minutes, as opposed to having to set up the hefty Android Studio IDE and figuring everything out themselves.This project aims to take this tool one step further, by building on its usability and allowing users to do much more with the tool such that it not only benefits the testers but the developer community as a whole, or anyone who wish to quickly set up Android Emulators on their machines, while only downloading what is necessary, saving both internet bandwidth and storage capacity. To achieve this, this project proposes: a) Adding support for wireless adb connection to avoid the inconvenience of using USB cable. Users will be able to connect and manage multiple devices, both real and emulator. b) Adding support for downloading and managing multiple system images and emulators to facilitate use of a wider range of emulator devices. c) Adding functionality to update the installed SDK tools. d) Document all important SDK commands for easy accessibility of the users. The tool will help users to perform all these tasks with a very interactive and easy to use command line interface.
The {torchvision} library in mlverse is already near-feature-parity with the PyTorch library, but certain performance optimisation and state-of-the-art computer vision model support gaps need to be bridged. This project aims to bridge the performance optimisation and state-of-the-art computer vision model support gaps in the current mlverse library. The performance optimisation objective is to improve the performance of the library by moving computationally intensive functions, e.g., region proposal networks and non-maximum suppression, from R to C++. This will allow for seamless integration with libtorch, providing production-grade speed and performance for detection and segmentation tasks. The state-of-the-art computer vision model objective is to improve the library by adding YOLO, RT-DETR, and SAM models, among others, into the torchvision library. This will be achieved by providing end-to-end documentation of the models, e.g., using the R documentation system, roxygen. This project will result in improved performance by providing an R interface for performance-critical functions using Rcpp, as well as improved state-of-the-art computer vision models by adding YOLO, RT-DETR, and SAM models, among others, into the torchvision library. This will improve the performance, usability, and adoption of R as a deep learning library for computer vision tasks, making mlverse a competitive alternative
Spack is a dominant HPC package manager that automates scientific software installation, widely used in the HEP community. Spack builds software in temporary staging directories and installs the resulting binaries into a final prefix; this workflow complicates debugging, as debug symbols embedded in binaries reference source paths that no longer exist after installation. This proposal aims to enable debuggable installations by preserving staged source trees in the final prefix. The initial scope targets a subset of build systems with native out-of-source support, prioritizing CMake workflows. It promotes staged sources into the installation prefix as a dedicated source tree while excluding unnecessary build artifacts, and relocates debug information by rewriting source paths embedded in DWARF debug symbols to match the installed source locations. Robustness will be validated through a structured set of test cases integrated into Spack’s pytest framework and debugging tools (GDB/LLDB), covering source preservation, symbol resolution, and relocation compatibility. Current standard debugging approaches with spack develop and spack dev-build will be compared with the new workflow. The result is a practical foundation for debuggable Spack installations that improves developer workflows in HPC environments, with a potential extension to external debug symbol distribution (e.g., debuginfod) for lightweight binaries with on-demand debugging support.
Harbor is a widely adopted container registry. As one of the most widely adopted container registries, it is a critical component in modern software supply chains. This project aims to enhance its security capabilities by extending Harbor's Pluggable Scanner specification to support Runtime Behavior Profiles (also known as a Behavior of Bill, or "BoB"). While Software Bill of Materials (SBOMs) describe what an artifact contains, a BoB describes how it behaves at runtime. By integrating kubescape-node-agent as a scanner, Harbor will be able to retrieve, store, and display these runtime profiles for OCI artifacts. This allows software producers to ship secure-by-default configurations and provides consumers with a way to verify runtime behavior, detect anomalies, and report unexpected activity. This feature will create greater trust in artifacts and help users meet emerging compliance requirements, such as the EU's CyberResilience Act, by enabling active breach identification through anomaly detection. Expected Outcome: Propose and document the minimally necessary modifications to the Harbor Pluggable Scanner Spec to support the retrieval of runtime profiles. Implement a scanner adapter that integrates kubescape-node-agent with Harbor. The adapter must be able to retrieve and process SPDX-compliant Runtime Profiles (SBOBs). Extend Harbor's UI to allow users to view runtime profiles and see potential mismatches between expected and observed behavior.
The problem I am solving: The existing HDF5 asynchronous I/O feature supports the C/C++ interface. This project involves the development and performance evaluation of a Python interface that would allow more Python-based scientific codes to use and benefit from the asynchronous I/O. The h5py package provides both a high- and low-level interface to the HDF5 library from Python. The low-level interface is intended to be a complete wrapping of the HDF5 API. The h5py package currently only supports synchronous I/O. And this project I am going to add the Asynchronous I/O. The plan to solve it: Milestone 1: create a new Python API. Milestone 2: convert existing c tests to python tests. Milestone 3: test my implementation with the tests. Milestone 4: evaluate the performance with a scientific python application. When all tests pass we will have a usable Python interface for the asynchronous I/O. An example: the H5Fcreate_async function: First, prepare the H5Fcreate_async.h file, H5Fcreate_async.c file, and we create the cyH5Fcreate_async.pyx file. Second, use the command to Parse pyx source code into c code. Next, use some commands to compile c files into object files (*.o files) Next, use some commands to link multiple object files into dynamic link library files (*.so files) In this way, the file of H5Fcreate_async.so is obtained, and then the library can be imported in the Python application.
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.
<p>Search_API_Location module provides the geospatial search experience to Drupal. Geo-spatial search mainly refers to searching data that is associated with a particular location. Queries such as give me all the restaurants that serves meat within 20 miles from me, or create a distance heat map of them are example of spatial search. Here, some live websites like <a href="https://www.airbnb.co.in" target="_blank">Airbnb</a>, <a href="https://www.tripadvisor.in" target="_blank">TripAdvisor</a> , <a href="https://www.yelp.com" target="_blank">yelp</a>, <a href="https://www.olx.in/" target="_blank">olx</a> etc use Geospatial searching functionality with different type of features which are still missing in Drupal domain.</p> <p>As we know location based search is slowly becoming popular and a must have for any content website in the recent era, Drupal 8 needs to have a drop-in solution for geospatial search. Right now there are some alpha modules existing but these modules need some serious investment for it to become production ready. As well as it should support both Apache solr and MySql server as backend for indexing location data.</p> <p>Search_API_Location module is an extension for Search_API module and it mainly does two things</p> <ul> <li>Adds support for indexing location values</li> <li>Helps in filtering and sorting location values</li> </ul>
The project aims to develop an intelligent code review agent that integrates with GitHub and other version control systems (VCS). This tool will provide automated, insightful feedback on code quality by combining traditional static analysis with AI-powered insights. Problem Being Solved Code reviews are often time-consuming and inconsistent, especially when identifying complex issues such as security vulnerabilities, performance bottlenecks, and maintainability concerns. This project addresses these challenges by automating the review process while providing actionable, contextual feedback. Proposed Solution The solution employs a modular webhook-based architecture with the following components: 1. A webhook receiver to capture GitHub events (e.g., pull request creations/updates). 2. A code fetcher to retrieve and parse changed files. 3. An orchestrator to coordinate multiple analysis tools. 4. A result aggregator to combine findings and remove duplicates. 5. A response handler to post intelligent comments directly on pull requests. Key Deliverables 1. A system that provides actionable, contextual feedback rather than merely flagging issues. 2. Support for multiple programming languages (initially Go, JavaScript, and Python). 3. Implementation of dependency vulnerability detection. 4. An AI-powered layer to enhance basic linter outputs. 5. Extensibility for future language support and additional features.
<p>The job control feature of Neovim introduced great multitasking support that added new capabilities and enhanced important tasks by allowing them to be done asynchronously (e.g.: online linting, as in <a href="https://github.com/dense-analysis/ale" target="_blank">ALE</a> for instance). This improved the overall user experience and reduced editing latency.</p> <p>We aim to add multiprocessing support to VimL, the built-in scripting language of Neovim, by allowing functions to be invoked asynchronously in separate processes and enabling the retrieval of their results through callbacks and by waiting for them on demand in the parent process. This multiprocessing feature will have a noticeable positive impact on the performance of parallelizable computations and tasks.</p> <p>This is achieved by introducing the following built-in multiprocessing primitives based on the job control feature:</p> <ul> <li><code>call_async({callee}, {args}[, {opts}])</code></li> <li><code>call_parallel({callee}, {arglists}[, {opts}])</code></li> <li><code>call_wait({ids}[, {timeout}])</code></li> <li><code>:&:{cmd}</code> (invokes <code>{cmd}</code> asynchronously; has a custom predefined handler for <code>:[l]vimgrep[add]</code> commands)</li> </ul> <p>Complementing the multiprocessing feature, is the context feature, which is a set of built-in functions to save and restore parts of the current editor state.</p>
Neural weather prediction models like neural-lam rely on graph neural networks, but the current graph construction pipeline is locked to rectangular grids — blocking support for irregular data sources like weather stations, satellite swaths, and icosahedral model grids (ICON, MPAS). This project replaces the hardcoded pipeline with a flexible, topology-agnostic architecture spanning two repositories (weather-model-graphs and neural-lam). The core work delivers three things: (1) a two-step mesh architecture that decouples node placement from connectivity, enabling any layout (triangular, prebuilt, density-adaptive) to combine with any connectivity mode; (2) a bridge layer that eliminates 600+ lines of duplicated code by making neural-lam call weather-model-graphs directly, validated through a shared schema contract; and (3) migration to PyTorch Geometric's HeteroData for type-safe, self-documenting graph representation. As stretch goals, the project introduces a graph quality metrics framework for comparing mesh topologies without training, density-adaptive meshing driven by data or prediction error, and spherical coordinate support to fix systematic distortion at high latitudes. I have already contributed the foundational PRs (#81, #91, #92, #123, #258) and authored the two strategic issues (#384, #385) that define this project's architecture.