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.
<p>The project aims at developing a feature wherein the template developers can sign the templates (to authenticate the source) they developed. The contracts derived from the templates can be then signed by the parties involved in the agreement (to authenticate the signatories).</p>
<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>
<p>Block-Based Circuit Design is a solution to counter the complexity of Circuit Design. We aim to develop and deploy a Block-Based TL-Verilog solution for developers and new entrants to the sphere. Powered by Blockly from Google, it will deliver a simple, concise, and intuitive gateway to Circuit Design.</p>
Utilizing cloud FPGAs prove to be very expensive and minor coding bugs could consume precious compute cycles and incur hefty bills. This proves using FPGAs on AWS F1, virtually ineffective for students, enthusiasts and early researchers. Additionally, 1st CLaaS, already has a streaming interface in place, not all hardware accelerators would require continuous streaming of data. The addition of support for Memory Mapped Interfaces like AXI4, AXI4 Lite, Wishbone and custom interfaces similar to RoCC, Core-V eXtension interface etc., would enable a wider ecosystem of hardware accelerators to support 1st CLaaS integration without any RTL Level modifications. Besides these, supporting 1st CLaaS on Local FPGAs/Remote FPGAs contrary to AWS F1 would prove useful to enthusiasts, researchers, professors and students having FPGA on-premise or remotely accessible. 1st CLaaS for PYNQ leverages the PYNQ (Python Productivity for Zynq) Framework, which consists of a Jupyter Server running in a Linux Operating system on the ARM Processor in the Zynq SoC. Addressing the current limitations of 1st CLaaS, the proposed framework that not only brings 1st CLaaS to PYNQ FPGAs, but also vendor agnostically automates TL-Verilog/Verilog/SystemVerilog based Hardware accelerator design from RTL to bitstream and deployment eliminating the need to interact with a wide range of vendor specific tools. The framework would provide a complete FPGA based hardware design flow within the browser/terminal right from designing in makerchip-app and IP-Block design-Bitstream generation to deployment on FPGA in a single command.
Throughout this project, I hope to gain a firmer understanding of TCL scripting and the backend working of parameterized devices and hopefully make some new ones too these devices are used many times while using magic to makes our work easier. this project will help me in a deeper understanding of how each command in the command line works in magic and how we can make some changes in its scripts to make it to improve user inference. In terms of the project, the goal is to work in scripts to draw devices like LDNMOS, LDPMOS, bipolar transistors, photodiodes, Avalanche Diode, etc as well as fixing a few devices that are known to draw incorrectly for some parameter values.as far as working on this project is concerned as per my own rough timeline following is the methodology i would use while working on the project : The magic VLSI tool uses TCL scripts for the parameterized design layouts so we should start by going through some of the scripts to get a better understanding of what we are working with then we will be going through each of the mentioned devices and study its CMOS design and draw it on the magic tool using the magic command line TCL scripts, we will also be looking at the pre-existing devices to check if we were getting the required drawings of them or not if the drawings are not as required then we will be making changes to those scripts as well, in the meantime, we will be looking for improvements we could make on the user inference of magic tool too. to get a better understanding of how I would work on this project please go through the proposal I have attached below. thankyou soo much for your time, looking forward to working with you soon.
<p>Bespoke Silicon group at University of Washington is working on the second version of their open source RISC-V manycore processor. They are also working on a CUDA-light programming environment using LLVM. This GSoC I plan to extend RV32 LLVM backend incorporating new hardware features.</p>
<p>I'm proposing the creation of a Math Library for BaseJump STL. Adding a set of routines that employ the CORDIC algorithm to implement directly and indirectly computable functions like logarithmic, exponential, sqrt, etc. An overall better parameterization of bit-widths in the existing and new modules, along with functions that directly compute on an array with computations based on a configurable pipeline structure. I also propose to add explicit parallelization inspired by SIMD architecture to the mathematical functions in which the number of independent parallel data elements and bit-length is added as a parameter.</p>
Swift's concurrency runtime has no mechanism to enumerate live Tasks and TaskGroups. When a program using async/await stalls, existing tools such as thread backtraces, Instruments, LLDB are silent about the suspended tasks that are the likely cause. Instruments records task lifetimes after completion; there is no API, debugger command, or crash report field that answers "what tasks exist right now and what are they waiting on?" This project implements a global registry of live AsyncTask and TaskGroup instances inside the Swift Concurrency runtime. The core challenge is doing this without introducing unacceptable synchronisation overhead on every task creation and destruction, a hot path in any concurrent Swift program. I will implement and benchmark at minimum two candidate data structures: a sharded-mutex intrusive list (using PrivateStorage, which is opaque externally and safe to extend without breaking ABI) and a lock-free Treiber stack alternative. Deliverables: A working registry implementation with hooks in swift_task_create_commonImpl and AsyncTask::~AsyncTask() A design document comparing candidate data structures with measured overhead against the existing TaskGroups.swift and AsyncTree.swift benchmark suite Signal-safe crash backtrace integration listing live tasks on crash LLDB Python macros for interactive task inspection.
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.
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.
The swift-java interoperability library provides the jextract-swift tool, which extracts Java sources that are used to call Swift code from Java. However, the tool uses the Foreign Function and Memory API (FFM), which requires JDK 22+, making it unavailable on platforms such as Android. The goal of this proposal is to extend the jextract-swift tool, such that it is able to generate Java sources using JNI instead of FFM and thereby allowing more platforms to utilize Swift/Java interoperability. The solution will modify the code generation to support multiple modes through a protocol. Thereby, allowing us to generate JNI Java wrappers that that utilize the JNI functionality already defined in the library. We will modify the current Arena implementations to support memory management for JNI as well, through calls to the Swift runtime. The library will also generate Swift thunks that implement the native methods defined in Java and handle JNI/Swift conversion and object initialization. The project will achieve feature parity with the current FFM mode and explore more complex language features, if time permits.
<p>Debuggers are essential tools in aiding developers to do their work more efficiently. They are inherently tied to the target operating system, and therefore require platform-specific work in order to deliver functional parity between different platforms. Swift is a multi-platform programming language, and having a good debugging experience in all platforms is beneficial for the language. With that in mind, I propose to improve LLDB’s support on the Linux operating system by: fixing Swift type metadata parsing for ELF objects; unifying queries of dynamic type resolution under the RemoteMirrors API; and, finally, enabling tests which currently do not run on Linux, or are marked as expected to fail.</p>
Since CVA6/Ariane is highly modular by design, it is relatively easy to develop and integrate multiple L1 caches. Additionally, because CVA6/Ariane is open source, users can develop L1 caches customized for their needs. The primary technological feature of HPDC is its L1 Dcache, which supports Multi-Requester, Multi-Issue, and Out-of-Order operations. This capability is especially valuable for HPC systems striving for high memory throughput. However, HPDC is still under development, and various functional enhancements are being implemented or planned to make it more useful for HPC systems by providing a variety of functions for diverse cores. In this year's GSoC, the objective is to first expand the functionality of the L1 cache for the CVA6/Ariane core, and then to make it scalable to accommodate many cores, laying the groundwork for making HPDC an even more significant entity for HPC systems. By exploring the appropriate scale and structure, it's possible to enhance HPDC's functions to be used as an instruction cache with scalability in mind. Furthermore, by connecting with OpenPiton, it becomes extremely easy to scale to large systems with many cores. This aligns with the goals of the GSoC project.
Booting Linux in OpenPiton's Verilator RTL simulation takes days. This project builds a checkpoint/restore pipeline: boot Linux in QEMU (minutes), extract machine state, convert it to OpenPiton's `mem.image` format, and resume execution in RTL simulation with Linux already running.
<p>Inlay hints take advantage of Swift's powerful type inference by visualizing inferred types throughout a Swift program in the editor. This makes it easier to read and understand Swift code, all while letting the programmer write concise code, without having to spell out every type. To achieve this, a custom LSP request is introduced that fetches the inferred types of unannotated variable bindings from the language server which, in turn, queries <code>sourcekitd</code> for the required information. The request will be called by the editor, e.g. VSCode, which will subsequently present the corresponding text decorations.</p>
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.
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.
This initiative focuses first on creating a Rust runtime platform for Concerto. Presently, Concerto's runtime logic resides in JavaScript and we use Node/Browser execution to conduct that logic, however; the logic is becoming more difficult to be reused as expected in other execution environments. The long term plan is to create a reusable Validation Core written in the Rust programming language which loads Concerto entity metamodels in JSON format, validates against the requested Concerto entity types based on the appropriate input metamodel and allows both access to the same validation core as a WASM module which is used from JavaScript executed environments, and also through a native interface for callers that are not executing using vanilla JavaScript.
<p>This project involves a heterogeneous-ISA system based on a BYOC (Bring Your Own Core) framework. This provides a cache coherent, manycore research framework meant to support a variety of ISAs. The ao486 core having a x86 ISA, provides support for legacy code and is one of the few open source CISC ISAs. The initial approach to integration involved connecting BYOC through the Avalon interface. In this project, work is done with the bare interface of ao486 to interface it with BYOC to maintain cache coherency across all cores.</p>
<p>A Cicero extension for Microsoft Word will enable lawyers to write “Smart Legal Contracts” directly on the Word document itself. This will extend the usage of Accord Project templates to non-technical users as well. Thus, greatly expanding the accessibility to technology.</p>
Accord Project Playground: Empowering Developers Through Interactive Learning Problem: The Accord Project offers powerful functionalities for smart legal contracts, but grasping these concepts can be challenging for developers with varying backgrounds. Existing documentation and resources may not provide an engaging and interactive learning experience. Solution: Proposing and developing a user-friendly Accord Project Playground. This web-based platform will provide an interactive environment for developers to experiment with Accord Project features through: Modern UI/UX Design: An intuitive and visually appealing interface that aligns with the Accord Project's branding. Interactive Code Samples: Live code editing and preview capabilities to demonstrate functionalities in a hands-on manner. Integrated Learning Resources: Comprehensive documentation, tutorials, and search functionality for efficient learning. Sample Management: Functionality to save and export user-created Accord Project code (specific format to be determined). Integration of Live Chat-Bot. Open-Source Principles: Adherence to open-source best practices for transparency, collaboration, and maintainability. Deliverables: * A fully functional Accord Project Playground website with interactive learning features. * Comprehensive documentation for the playground itself, including installation, setup, and usage guides. * A well-structured codebase with clear version control and adherence to coding standards. * A thriving contributor's community with a contributor's guide outlining participation procedures. Impact: By creating this Accord Project Playground, I aim to: * Lower the barrier to entry for developers interested in Accord Project technology. * Foster a more engaged and active Accord Project developer community. * Enhance the overall accessibility and user experience of the Accord Project.
<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>Libraries for <a href="https://github.com/apple/swift-log" target="_blank">Logging</a> and <a href="https://github.com/apple/swift-metrics" target="_blank">Metrics</a>, embraced by the Serverside Swift Work Group, have enabled many Swift projects to simplify their code bases by removing their own implementations. However, there’s currently no official story for distributed tracing.</p> <p>This project aims to kick off the work on a distributed tracing infrastructure for the Swift ecosystem by creating a context propagation library with integration points for Swift NIO, AsyncHTTPClient, Swift gRPC, URLSession, and more.</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.