Fetching the latest programs, projects, and workspace data.
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.
COCONUT-SVSM is a Secure Virtual Machine Service Module running at a privileged level inside Confidential VMs to provide trusted services (e.g., virtual TPM) independent of the host hypervisor. Currently, the SVSM kernel performs full TLB flushes on every context switch, discarding all TLB entries indiscriminately and causing significant runtime TLB miss overhead. This project enhances COCONUT-SVSM to leverage the x86 PCID (Process Context Identifiers) hardware feature to tag TLB entries per task, preserving them across context switches and enabling selective TLB invalidation. The work is structured in three phases: Phase 1 builds a code-generated Rust crate (x86-cpuid) from the authoritative x86-cpuid-db v2.4 XML database, replacing all scattered, magic-bit-position CPUID checks across the codebase with a type-safe cpu_has(leaf_0x1::ecx::Pcid) API unified across SNP, TDX, and native platforms via a CpuidReader trait. Phase 2 designs and implements a PCID assignment strategy for all virtual pages in the COCONUT kernel, enabling the CPU to tag TLB entries per task(same for all threads of task) and preserve them across context switches. Phase 3 converts global TLB flush operations in into selective, PCID-aware invalidations: using AMD's INVLPGB broadcast instruction to flush a specific PCID across all cores without IPIs. Key Deliverables are x86-cpuid Rust crate with code generator consuming x86-cpuid-db XML, refactored COCONUT-SVSM codebase with all open-coded CPUID checks replaced with new code generated by x86-cpuid Rust crate, PCID allocator, applying the PCIDs in the COCONUT page-tables and selective TLB flush functions (flush_tlb_pcid, flush_tlb_range_pcid) with AMD INVLPGB.
<p>The project aims to improve the integration between <code>ScalaPy</code> and <code>Ammonite</code>/<code>Almond</code> by providing a frictionless installation experience plus a number of quality of life features such as code completion and displaying rich presentations of Python objects. The project also involves developing a Scala - Python integrated environment in which users can switch between a Scala and Python shell and exchange variables between them. The project could benefit Scala programmers seeking access to Python libraries, typically data science and deep learning frameworks, by providing them with a smoother user experience. In addition, it could also help Scala attract Python programmers, who are looking for a type safe language with better concurrency and parallelism support.</p>
<p>Since cache performance is one of the essential metrics that may bottle-neck the overall performance of the system, monitoring it and identifying points of weakness (and resolving them) may drastically improve the performance of the system.</p> <p>In this project, a cache modelling QEMU TCG-plugin is proposed and implemented, with simplicity rather than intricacy in mind, that models the behavior of caches when given the working set proposed by a program, or system-wide working set, report the cache performance, and identify the frequently cache-missing instructions.</p>
<p>The name Scala comes from the word scalable, and true to that name, the Scala language is used to power busy websites and analyze huge data sets. Scala is one of the leading languages in implementation of big data systems. It is widely used in streaming data. Similarly, Python has become the language of choice for data scientists with its many high-quality scientific libraries. ScalaPy is that bridge which gives an opportunity to use Python libraries in Scala. Last year a new version of Scala was introduced. At the moment it is not released but Scala 3 brings many new features and changes. The aim of this project is to discover those new features and implement support for ScalaPy in Scala 3. ScalaPy will possibly help Scala 3 to become more popular among scientists and maybe this will be the core moment in combining data processing and data analysis worlds in Scala 3.</p>
Currently, dotty-cps-async does not support effect systems, hindering its further development. Additionally, there is no mechanism to automatically convert existing standard monads to effect system monads, resulting in increased boilerplate code. To address these issues, a macro will be used to assemble code-based effects to CpsMonad. Additionally, automatic conversion of existing monads to effect system monads will be developed using additional monad converters that will be implicitly applied. The outcome will be the ability to use effect system monads through the async[[X] =>> Monad[R, X]] syntax, facilitating easy composition of various effect systems. Furthermore, automatic conversion of existing standard monads such as Option, Either, List, etc., to effect system monads will streamline and enhance the user experience, reducing boilerplate code.
<p>VirGL provides an OpenGL path well supported on Linux guests. On the host, QEMU offers several console back-ends, from EGL to SDL. Adding a Vulkan path will require to change the current VirGL API, write new guest drivers, and also offer a way to display the output. This is a huge task, which can be split in several sub-projects. Expending the current VirGL API to support Vulkan is the first step.</p>
This project aims to migrate the existing Scala documentation website from Jekyll to Scaladoc. This migration will provide a more streamlined, modern, and easily maintainable documentation experience that is tightly integrated within the Scala ecosystem. I will focus on replicating key Jekyll features, such as the "include" mechanism and custom tabs, using the "liqp" library within the Scaladoc framework. Existing content (Markdown, HTML, CSS) will be carefully adapted, and styling will be applied to match the look and feel of the current website. If time permits, I will explore additional customizations to Scaladoc's default output for greater layout flexibility. The key deliverables of this project include a functional MVP website, replicated Jekyll functionality, and comprehensive documentation of all implemented features.
This project involves extending the Feral library to support more cloud providers, specifically Google Cloud and Vercel, in addition to AWS Lambda, as well as improving the existing support for AWS Lambda.
<p>I/O throttling is currently hard-coded in QEMU. A request is checked for throttling directly in block-backend.c instead of having a filter driver process every I/O request for throttling during the walk in the BlockDriverState graph. Throttling can become modular by being utilised with a filter block driver.</p> <p>Add before write notifying (bdrv_add_before_write_notifier: which is used in backup_run for backups) is also hard-coded.</p>
<p>In GSoC, I propose to introduce deep learning annotators in RoboSherlock for more various task. Because many deep learning frameworks and repositories are written in Python, I first improve RoboSherlock system to be able to run annotators written in Python. Then, I implement annotators using deep learning such as object detection, semantic segmentation, instance segmentation and so on into RoboSherlock system. As the final result of the project, the real robot execute a manipulation task with the deep-learning annotators. The main contributions of my proposal will be as belows:</p> <ul> <li>Improve Robosherlock to execute annotators written in Python</li> <li>Introduce several useful deep-learning annotators in Robosherlock</li> <li>Implement the new annotators in daily-life task with real robot</li> </ul>
Network Block Device (NBD) is a protocol for exporting block devices, either between processes or across the network. Libnbd is a client library for talking to NBD servers. Currently, this library has bindings in various languages, including C, Golang and Python, but not in Rust. This project aims to make ergonomic Rust bindings for libnbd. The bindings should be automatically generated from the API of libnbd, so they will keep in sync as the library evolves. Apart from the actual bindings, several tests and examples will be created and good documentation will be written.
<p>Live Migration is a process of moving a running virtual machine from one physical system to another. There are usually two ways, precopy and postcopy. Postcopy migration is used for virtual machines which have a high memory dirtying rate, (higher than the bandwidth of the network that will be used to perform migration). The disadvantage of postcopy migration is, if there is a network failure then we are left with an inconsistent vm at both the source and the destination side. The aim of this project is to recover from the network failure, and complete the migration process. The project will include completing the process of sending the leftover memory pages. Project would start by making sure that the threads do not fail at both the source and destination end. This would be followed by re-establishing the network connection between the source and the destination. After this is done, the migration process is restarted. The vCPUs on the destination side were suspended due to page faults, so these pages are transferred first. Followed by the rest of the leftover pages on the source side.</p>
This project aims to develop a prototype that simplifies data exchange within Slack, enabling seamless information retrieval and input with minimal effort. The primary focus is on creating an intuitive, efficient interface to streamline workflows and enhance productivity. Additionally, the project involves researching the feasibility of extending support to other communication platforms (e.g., Microsoft Teams, Discord) by analyzing API complexities, authentication mechanisms, and integration challenges. The outcome will include a functional Slack prototype alongside a comparative assessment of cross-platform compatibility, identifying key barriers and potential solutions for future expansion. This work will contribute to a more interconnected and automated workspace ecosystem, reducing manual effort in information management.
<p>QEMU uses a single-threaded tiny code generator (TCG) which translates instructions of the guest ISA to instructions of the host ISA. These translated instructions are then executed on the host in an execution thread. For SMP guests, this single thread is scheduled to execute translated instructions of all the CPUs in a round robin manner. This is a significant performance bottleneck in utilizing all the available cores on the host machine. Multi-threaded TCG (MTTCG) project was started to solve this problem by designing and implementing a multi-threaded TCG. In this design, multiple threads are concurrently scheduled, and each thread executes the translated instructions from one guest CPU. Various consistency issues were identified in this design and the current work aims to solve them.</p>
<p>Patchew is an open source CI project to automate testing of patches submitted as emails on mailing lists. Currently Patchew has a simple API, but it is complicated to use it because it is not REST-like and it exposes low-level details of the patchew database schema. The project aims at replacing it with a new REST API.</p>
Cyfra is a GPU runtime and DSL that simplifies GPU programming in Scala by abstracting Vulkan. This project will build a real-time rendering pipeline with outputs to a window, data stream, and file. Deliverables include high-level GPU APIs, GLFW integration, efficient swap chain/synchronization, and clear documentation with examples—making high-performance graphics more accessible to Scala developers.
The current state of the asynchronous I/O on the JVM involves using separate selector threads to manage I/O events through system functions like epoll or kqueue. Although frameworks like Netty and NIO2 make this approach seem reasonable, the use of separate event loop threads is not without cost. In high-RPS services, these threads can compete for CPU time with worker threads executing application tasks, leading to resource contention and potentially significant performance loss. In contrast, Cats Effect offers a different threading model, integrating I/O and application tasks into a single runtime system, reducing contention an enhancing overall efficiency. io_uring, the key component of this project, offers two major advantages: (1) it enables all supported syscalls to become asynchronous from the application’s perspective, allowing for multiple syscalls to be initiated in parallel without blocking the calling thread, and (2) it uses a pair of ring buffers for syscall submission and completion events that are shared between the application and the kernel, dramatically reducing the overhead of calling from userspace into kernelspace. When integrated with Cats Effect, io_uring can significantly improve the efficiency of syscalls, requiring fewer calls into kernelspace during the worker loop. This proposal brings two key innovations together: a new threading model and a new I/O API. By integrating Cats Effects and FS2 with io_uring, we aim to develop an alternative solution to minimize the inefficiencies found in the traditional model, offering a more efficient and performant solution for I/O-intensive applications.
The Scala ecosystem thrives on information accessibility, and Scaladex stands as a pivotal resource in this domain. However, the current scope of Scaladex's artifact pages does not fully exploit the wealth of metadata available in Maven pom files. This project aims to enhance Scaladex by extracting and presenting additional information from pom files, enriching the user experience, and empowering developers with deeper insights into Scala artifacts.
Upgrade the offline indexing and multi-lingual layout algorithms for high-throughput developer documentation portals.
<p>This project's main goal is to make it easy for potential contributors to use <a href="https://index.scala-lang.org/" target="_blank">Scaladex</a> to find Scala projects they can work on. This will involve researching common difficulties potential contributors face when trying to find an open-source project to contribute to, designing potential solutions to those problems and implementing those solutions. Reaching out to the Scala community to learn about problems they've faced and their thoughts about potential solutions will be an integral part of this project.</p>
<p>This project revolves around designing a reusable framework for mocking the driver side of a VirtQueue operation. It would allow rust-vmm crates and other projects to use it and would provide a cleaner alternative to mocking code already found in vm-virtio.</p> <p>The framework would at first provide users with more granular control over mocking what the driver will place in the queue and will later support mocking more advanced features such as notification suppression, indirect descriptors and other device specific features.</p>
<p>Currently, mypy and mypyc are unable to recognize uses of the singledispatch decorator, making mypy generate false positives and mypyc generate incorrect or slow code when it is used. This project would improve both of these problems by adding special support for singledispatch in mypy and mypyc.</p>
<p>This is a project to tackle as many issues as possible open in the Slick issue tracker with a priority on resolving long standing bugs and implementing features upvoted by the community.</p>