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.
Sootty is a novel graphical waveform viewer targeted at modern terminals, however, it currently only supports VCD format and decimal system, not fully supporting markers or cursors. In this project, Sootty will support more mainstream input formats, common numerical systems when displaying numbers, and markers. These enhancement features are limited to what terminals can display, but they will be faster and easier to use than a complex graphical user interface for terminal users. Sootty will integrate numerical system converters and different format interpreters to realize these features.
Concerto, the core modeling language of the ACCORD PROJECT, is critical for smart legal contracts and domain modeling. This project aims to migrate from the current testing framework mocha to vitest which will enhance the performance, execution time and debugging capabilities. This process can be automated by the combination of vitest-codemod, regex transformations, ai assistance and some manual scripts required for handling complex test cases which cannot be automated. Here are the deliverables: 1. Migration from Mocha, Chai, Sinon to Vitest for all Concerto implementation. 2. A new Concerto conformance package which will be a standalone validation test package for all Concerto implementations.
This project extends the Accord Project Template Playground by implementing an end-to-end, sandboxed logic execution pipeline to solve its inability to test interactive smart contract behaviors natively. By utilizing a secure Web Worker architecture, the platform will safely evaluate user-authored TypeScript logic and validate all states and requests against strict Concerto models directly in the browser. The core deliverables include an integrated Monaco-powered logic editor, an interactive contract runner UI for initialization and request handling, dynamic execution results visualization, and comprehensive multi-state contract templates. Together, these features transform the platform from a static authoring tool into a complete, interactive development workspace for smart legal contracts.
<p>With this proposal I hope to benefit the open-source hardware enthusiast community with work related to the incredible Parallela board used by thousands of students and hobbyists around the world. This project will focus on the integration of the RISC-V rocket core, inside the Zynq FPGA device of Parallela. The RISC-V rocket core is an implementation of the RISV-V ISA that has gotten a lot of attention and support due to being clean, modular and power efficient. This project will allow owners of Parallela boards to write and execute RISC-V programs with minimal effort from their side. The system will work out of the box with a prebuilt binary image ready to be placed in an SD card and users will be able to re-build it with minimal effort. Moreover, a tutorial document will be created to aid inexperienced users make the most of this work and allow them to modify it for their own needs and purposes with custom hardware and / or software code.</p>
TinyParrot is a BlackParrot RISC-V multi-core variant that aims to be small enough to fit onto educational FPGA development boards like the Pynq Z2. In order to get there, the TinyParrot variant needs to optimize and constrain itself in order to meet the physical device constraints (such as LUTs, BRAMs, and flip-flops) provided by development boards like the Pynq Z2 FPGA development board. This project will implement size optimizations that ultimately decrease the amount of resources required by TinyParrot, enabling TinyParrot to fit on the Pynq Z2. At a high level, this will be accomplished by first parameterizing the FMUL/FDIV instructions as part of an MFD parameterization effort. Then, hardware primitives will be re-mapping using the BaseJump STL library in order to standardize and optimize the existing RTL. The ultimate goal of these optimization efforts is to implement TinyParrot on the Pynq Z2.
<p>This project is to add Microarchitectural enhancement of Ariane that is a popular open-source CPU core implementing the RISC-V ISA (instruction set architecture). Currently, the processor is single-issue, meaning that the processor can only issue one instruction per clock cycle. That is a huge performance bottleneck since most functional units in the processor will stay idle when it does not have any instructions to proceed. In this project, I will implement super-scalar issue logic which allows Ariane to issue two (or more) instructions in the same clock cycle so that the overall performance will be greatly improved.</p>
<p>The open-source RISC-V instruction set architecture is gaining interest throughout industry and academia. One advantage of RISC-V is the ability to add custom instruction extensions to the processor targeting specific applications. A joint project between Embecosm and Southampton university recently developed an open source ISA extension for the CV32E40P RISC-V core to accelerate neural network inference acceleration (<a href="https://github.com/AI-Vector-Accelerator" target="_blank">https://github.com/AI-Vector-Accelerator</a>). The verification of the AI vector extensions project currently exists only as a Verilator model, and speed ups are based on cycle counts, with no insight to any impact on clock speed in actual silicon. There is no pipeline and everything is single cycle because there are no timing constraints in Verilator. This project aims to take the existing work and bring it up on a Nexys A7 FPGA platform.</p>
<p>Black Parrot is a tiny, modular Linux capable open-source processor core that encourages external contributions and strives for infrastructure agnosticism. It has been previously taped out successfully on commercial nodes TSMC 40nm and GlobalFoundaries 12nm. Last year, Google released the Google-Skywater 130nm Open-Source PDK which opened new windows in the field of Semiconductor Design and Manufacturing. To be able to successfully get a reliable, tiny, and modular Linux-capable processor like Black Parrot onto Skywater, and have it working, would be a key milestone for the open-source technology node. The aim of this project is to get a single-core implementation of Black-Parrot tapeout-ready on the Google-Skywater 130nm node.</p>
This project aims to make contract execution easier by removing the need to write TypeScript logic for every template. Instead, it uses an LLM to understand the contract and execute it automatically. The system adds three modes—disabled, fallback, and force—so users can choose between normal typescript logic and LLM execution. It also includes proper validation and formatting to ensure correct outputs. The project will be tested on different real world templates and compared with existing logic to check accuracy and performance.
Developing a native Swift-etcd client aims to seamlessly integrate etcd, a distributed Swift key-value store into Swift applications. This project aims to enable developers to have efficient communication with etcd servers via gRPC API, by targeting authentication, key-value operations, watch operations, and lease management.
AnyCore is an advanced superscalar processor developed at NC State University, designed to be highly configurable across parameters like issue width and pipeline depth. The goals of the project are fixing memory related issues of the core, finishing integration of an open-source Floating Point Unit (FPU), and enhancing the core in areas needed for running a Unix-like operating system.
circt-bmc can already prove when an assertion is falsifiable, but it does not yet produce the counterexample trace format hardware developers rely on for debugging. Today, users get a SAT/UNSAT result without a practical cycle-by-cycle waveform showing how the design reached failure. This project adds that missing debugging path. I will preserve meaningful signal identities before lowering, track the corresponding solver expressions across BMC timesteps, and evaluate those expressions against the first satisfying Z3 model. The implementation is intentionally staged: first a readable text counterexample for the failing prefix, then VCD waveform generation from the same trace data. The focus is the first-failure prefix (cycle 0 to the violating step), which delivers high user value with low integration risk and clean upstreamability. Deliverables: 1. Signal tracking and naming pipeline for user-relevant values (ports, externalized registers, selected internals where remapping is reliable). 2. A BMC trace runtime component that records per-step solver ASTs and supports model-driven trace emission. 3. Midterm milestone: first-failure text counterexample dump. 4. Final milestone: VCD waveform output for the same counterexample path, exposed through circt-bmc CLI flags. 5. Upstream-quality tests and documentation (IR-level + end-to-end regressions, including failing and no-violation cases).
This project aims to enhance the OpenPiton+Ariane architecture to progress toward RISC-V RVA23 profile compliance. The primary focus will be implementing the Svnapot extension, which allows for Naturally Aligned Power-Of-Two regions in memory to improve TLB efficiency. I will modify the CVA6 Memory Management Unit (MMU), specifically the Page Table Walker (PTW) and Translation Lookaside Buffer (TLB), to support this extension. As stretch goals, I plan to implement additional supervisor extensions required for RVA23 compliance, such as Svpbmt (Page-Based Memory Types) and Svadu (Hardware Updating of A/D Bits). The project will include comprehensive testing and documentation, ensuring all implementations conform to RISC-V specifications while integrating seamlessly with the existing architecture.
Apache Kafka is a distributed event streaming platform that is very widely used to process and store data. This project aims to create a Swift Package that enables Swift developers to send and receive data in the Kafka ecosystem while also taking advantage of the new Swift Concurrency features. At first, this shall be achieved by wrapping an existing C library called librdkafka.
This project aims to shrink BlackParrot multicore to have a minimal variant called TinyParrot multicore. The main goal of this project is to get very low resource ASIC tapeouts. The deliverables of this project are: **Provide Minimal ISA support: This will be done by parameterizing the FPU logic (all the FP pipes, register file, and bypass paths). **Shrink the size of caches: The cache size will be reduced to 1kb of data. **Logic saving optimizations: The optimizations are planned to be done through Yosys. Yosys supports optimization passes and runs them while synthesis.
<p>The WARP-V RISC-V core generator was developed in 2018, it is the most-configurable, most-adaptable open-source RISC-V CPU core generator, taking advantage of advanced digital design features of TL-Verilog. Till now WARP-V has support for RV32I base instruction set architecture and is formally verified using Risc-V formal. My proposal is to implement RV32F(Single Precision Floating-point) Unit extensions to the Warp-V core by using a "hard float by Berkeley" library written in chisel, which also supports IEEE 754 single-precision floating-point unit. My proposal is also to introduce Virtual Memory support(TLB) in Warp-V and to complete the implementation of Bit-Manipulation Instructions.</p>
Large digital designs are prone to consume lots of power and thus, a tool for power analysis is needed. There are two types of power analyses: static, which is more of an estimation that ignores circuit operations, and dynamic, which simulates the circuit behavior in conjunction with switching power. These tools are Verilog gate level-simulations and SPICE simulations, respectively, but the former can be inaccurate while the latter is computationally demanding. IRSIM, a tool intermediate between these two simulation tools, simulates the circuit as a network of transistor capable of turning ON and OFF, serving as a tradeoff between speed and accuracy in dynamic power analysis. The goal of this project is to develop and enhance a command-line interface compatible with up-to-date transistor components in the IRSIM library to ensure the analysis accounts for various power domains.
This project aims to improve the way Scautable handles CSV files by making structured data parsing in Scala more robust, flexible, and user-friendly — especially for data exploration and quick scripting tasks. Key problems being addressed include poor handling of row/column mismatches, limited support for malformed or missing headers and lack of custom delimiter options. Inspired by the usability of Pandas, this proposal introduces enhancements such as configurable error-handling modes (e.g., skip or autofill bad lines), support for automatic or custom headers, smarter handling of duplicate or malformed columns, and flexible delimiter parsing. For large files, methods to access specific columns will be distributed across implicit classes to avoid JVM method count limitations, improving scalability. Additionally, clear error messages and diagnostics will guide users through common issues and edge cases. By addressing these aspects, the project will significantly improve Scautable’s reliability and make it a more powerful tool for developers working with structured data in Scala.
<p>The Tainted Checker Overhaul aims to be an extension of the Tainted Checker Framework, extending the concept of tainted data and upgrading its functionalities. Often, programs need to deal with input values outside of their domain, which can sometimes allow the entry of invalidated and corrupt data. Such corrupt inputs can cause numerous errors and, therefore, must be handled carefully. This Overhaul aims to deal with such dilemmas and aid the programmer in a significant way.</p>
<p>Traditionally, java programs use null to represent the absence of value. Java 8 introduced Optional class, a container that contains a reference to T (non null) or is empty. Using Optional Class solves the problem of null pointer exceptions but creates new problems that may crash your program. The goal of this project is to create a new type system that warns programmers who have misused Optional and expose latent errors, which would ultimately lead to proper use of Optional class.</p>
<p>Checker framework is a great lightweight tool which could easily type check code having a dependency on a library if the library has already been annotated. Google Gson is a widely used library written in java to transform the Java objects to JSON (JavaScript Object Notation) and vice versa. This library has a total of 143 directories and 255 files out of which 208 are java files. This project could be an overall evaluation of the type-checkers on real code and can also help detect bugs or suggest improvements to the library being annotated. The main goal of the project</p> <ol> <li>Adding annotations to the Google Gson library for Nullness, Index and Interning checker.</li> <li>Adding missing annotations in JDK and reporting bugs if found any in the process.</li> </ol>
<p>Checker Framework provides a collection of type systems to prevent bugs on Java programs at development time. Although a type system might be useful to prevent certain types of errors, it requires the effort to write all the types, which might be an annoying task for developers. In order to tackle such problem, developers might use a type inference tool to write the types for a program. Particularly, to determine what type should be written for a procedure’s formal parameter, a type inference tool must examine the type of the argument at every call to that procedure. Thus, the type inference process requires a whole-program analysis. In conclusion, the main goal of this project is to create a single type inference tool that will work for any type system available in Checker Framework (e.g., Nullness and Interning Checker).</p>
JSON Schema validation errors are often cryptic and difficult to understand, making debugging frustrating for developers and end users. This project aims to develop a JavaScript library that transforms raw JSON Schema validation outputs into clear, concise, and human-friendly error messages. It will maintain compatibility with the standard format while improving error readability, supporting multiple languages, and allowing customization. By the end of the project, developers using standard-compliant JSON Schema validators will have access to a high-quality, user-centric Better JSON Schema errors—enhancing the developer experience and making debugging more intuitive for end users.
<p>The Rails website and welcome page was redesigned. However, the current design of error pages doesn't follow the new style. The new styling can be made more consistent.</p> <p>Moreover, some pages display errors that require action from the user like when the migrations are pending. I would like to propose a mechanism for users to act on the errors straight from the error page. A new module for ActionableError can be designed and integrated with the new error pages to give greater control to the user. It should also be extendable by other gems for them to customize their own course of actions when an actionable error is hit.</p> <p>A Web Console integration will also be done to update the console style to fit the look and feel of the new redesign.</p> <p>In addition to these ideas, we can also attempt a series of opinionated rails generators that will create a suite of default error pages (404 and 500s for example), based on the new styling rules, or from a set of styles obtained from the application's implemented stylesheets.</p>