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>Casbin is an authorization library that extends its features to implement Access Control Lists, Role-Based Access Control, and Attribute-Based Access Control models in various programming languages to its clients. Casbin's Core Engine is written in GoLang. Casbin-CPP has obvious benefits of speed and efficiency compared to its implementation in other languages and thus, benchmarking is vital for the project to stand out from the rest. Python is the most versatile as well as the most used programming language and has huge community support. Casbin-CPP has the potential to support new PyCasbin to compound the benefits of both languages through language bindings and extension libraries. Currently, the project uses Microsoft Unit Testing Framework for C++ for testing and Microsoft’s Azure DevOps pipelines for CI. CTest is truly cross-platform and can be configured using GitHub Actions for consistent and better CI.</p> <p>Project Ideas are as follows:</p> <ul> <li>Modernizing the project with C++17 standard and Google’s benchmarking tool</li> <li>Implement Python bindings for Casbin-CPP using pybind11 library</li> <li>Implement testing based on CTest and set up workflows for Continuous Integration through GitHub Actions</li> </ul>
<p>Astropy's <code>regions</code> package is being developed to handle description and manipulation of astronomical regions on sky and pixel coordinates.The current regions package has support for the most commonly used region specification, DS9, but does not yet support the <code>CRTF</code> and <code>FITS REGION</code>.</p> <p>CASA is the main package for radio interferometry data reduction and processing. CASA regions are mostly compatible with and translatable to DS9 other formats, but the only parser that presently exists, lives within CASA. <code>CRTF</code> stands for Casa Region Text Format.</p> <p>FITS , <code>Flexible Image Transport System</code> is an image format standard used in astronomy. A <code>FITS Region</code> binary table defines a spatial region of a 2-dimensional image. The region file is often used to define an area that is to be included or excluded from certain data processing operations on the image.</p> <p>The primary goal of the project is to implement I/O so the <code>regions.Region</code> objects can serialize/deserialize across these file formats , handle the meta data and spectral dimensions , improve the regions package, document and test alongside.</p>
OpenMRS is a medical record system that has previously allowed the uploading and visualisation of patient conditions through diagrams. This feature has been critical in helping doctors better explain patient conditions to their patients. However, the module lacked certain essential functionalities that could improve the user experience. Therefore, this project aims to improve the diagramming feature in OpenMRS by allowing the upload of any diagram as an image, annotation of certain areas of the diagram with different shapes, saving and retrieving these diagrams, and additionally downloading them as an image with the edited annotations. The project has two parts, essential and desirable objectives. The essential objectives aim to provide the basic functionalities for uploading and editing diagrams while the desirable objectives enhance the user experience by adding more features. Essential Objectives: Allow users to upload any diagram as an image to the module Enable users to annotate certain areas of the diagram with different shapes such as circles, squares, and single points, etc.. Allow users to save the annotated diagrams for future reference Enable users to retrieve diagrams from a list of already saved ones Desirable Objectives: Allow users to draw free shapes on the diagram and annotate them with a description text Enable users to download the diagrams as images with the edited annotations, allowing for easy sharing and printing.
Konveyor provides a unified experience of tools to help organizations modernize their applications at scale, transitioning them to Kubernetes and cloud-native technologies. Recently the Konveyor community began the development of a Generative AI approach for application modernization called Konveyor-AI. Konveyor AI accelerates application migration by discovering migration incidents in the source code and providing LLM-generated fixes in a diff view presentation. When proposed changes are accepted, it provides real-time updates on the number of incidents. The presentation side for this work is currently serviced via an IDE extension for VSCode. We aim to expand Konveyor AI by developing an IntelliJ plugin. Our first step involves integrating the static code analysis tool, analyzer-lsp, into the IntelliJ plugin. We plan to create a common module for interaction with analyzer-lsp, which can be used in multiple IDE plugins, starting with VSCode and IntelliJ. Currently, the IntelliJ IDE uses the Konveyor CLI tool, Kantra, for analysis and transformation, but we need to replace Kantra with analyzer-lsp to optimize real-time updates. Expected Outcome: Define and implement a new module or library to facilitate integration of analyzer-lsp into multiple IDEs. We will start with VSCode and IntelliJ to begin.
<p>In order to meet the goal of migrating administration functions to the new micro frontend framework, I had to make sure all the administration functions are accessible through REST APIs.</p> <p>This task involved getting familiar with current Legacy UI administration section functionalities. Then I had to find what is the missing functionality and how it’s currently handled by the UI.</p> <p>Then, I have added new or modified existing REST resources as well as added REST API documentation to them.</p> <p>Objective:</p> <p>Create REST endpoints for managing administration functions that are not yet available via REST - COMPLETED</p> <p>Contributions:</p> <p>I’ve worked on three OpenMRS repositories:</p> <p><a href="https://github.com/openmrs/openmrs-module-webservices.rest" target="_blank">https://github.com/openmrs/openmrs-module-webservices.rest</a> <a href="https://github.com/openmrs/openmrs-contrib-rest-api-docs" target="_blank">https://github.com/openmrs/openmrs-contrib-rest-api-docs</a> <a href="https://github.com/openmrs/openmrs-core" target="_blank">https://github.com/openmrs/openmrs-core</a></p>
Modern printer testing remains heavily dependent on physical hardware, making it slow, expensive, and difficult to scale for regression testing. While OpenPrinting already provides a Go-based MFP simulator and a Python-based image evaluation framework, these components are not yet integrated into a unified, automated testing system. This project proposes to build an end-to-end, hardware-free print testing pipeline that bridges this gap. The system will be implemented as a Go-based orchestration tool that directly leverages the simulator’s internal libraries for efficient control, while embedding Python to execute advanced image evaluation. It will automatically load printer models, create CUPS queues, enumerate all supported print modes, execute print jobs, capture simulator outputs, and evaluate them against expected results. The pipeline will support both single and batch testing modes, enabling scalable regression testing and seamless CI/CD integration. It will generate detailed, structured reports with quality metrics (e.g., SSIM, PSNR) and pass/fail analysis. By transforming isolated components into a cohesive, automated system, this project will significantly enhance reliability, reproducibility, and scalability of printer testing in the OpenPrinting ecosystem.
<p>DIRAC is an open source interware platform whose roles are submission of jobs, the management of the data produced, to the orchestration of the distributed resources. It is a generic software, used and extended by several Virtual Organizations (VO).</p> <p>It monitors resources like computing, storage, catalogue resources, networks, information providers, file transfer services, message queues or databases services. Members of a VO can use a mask composed of services exposed by local resources. Experienced Grid administrators apply procedures for managing such services, based on their status, as it is reported by an ever-growing set of monitoring tools. When a procedure is agreed and well-exercised, a formal policy could be derived.</p> <p>For this reason, using the DIRAC framework is developed as a policy system that can enforce management and operational policies, in a VO-specific fashion.</p> <p>This project proposal offers :</p> <ul> <li>A reliable working implementation of a multi-VO Dirac Resource Status System (RSS).</li> <li>A base database access module for the RSS which would unify the SQLAlchemy frontend and also reduce code duplication.</li> <li>Remove sqlite3 from some RSS modules and port them to MySQL backend</li> </ul>
OpenLane and SKY130 users are encountering a lot of trouble with current documentation. Even I, experienced software/VLSI developer, struggled with current documentation. For this reason, my proposal is to make a Consolidated documentation for all of SKY130/OpenLane. I worked with many students and helped a lot of people debug issues with tools. I collected feedback from them and the main struggles of students and newbies will be documented. This Wiki/Documentation proposed will cover everything that you need to start designing integrated circuits from scratch. Some amount of knowledge of Linux/Bash is assumed. I want to elevate the pressure on Skywater’s slack as the base for discussion for issues by adding a troubleshooting guide. This will allow mentors in slack to have one go-to point for all of the most common issues that they can refer to. All of the tutorials and demos are text + screenshots posted on GitHub. This is because it’s easier to update them when new versions of software come out or if the existing guide does not cover a particular topic. Videos get outdated every 3-6 months and require an effort from contributors to support. The aim is to reduce the cost of documentation support. All documentation will be proposed to developers of the according to software to be integrated into existing software’s documentation. Link to the global guide is also encouraged to allow a single consolidated entry point.
<p><strong>Terasology</strong><br> One of the main goals of Teraoslogy is to be <em>Overwhelmingly Customisable</em>. This means that the base engine only provides the bare minimum to create a functioning sandbox environment. Content is provided through modules which build on, tweak and integrate with both the engine and each other. This creates a wealth of content for the player to choose from.<br> Or at least that is the intention. Currently the major content for Terasology is extremely similar to content seen in other games like Minecraft, MineTest and similar sandbox games. However due to how modular the design is, it has the potential to have a breadth of content that eclipses either of those two. Which is where this project comes in.</p> <p><strong>GooeyDefence</strong><br> Tower Defence is a very well known game genre, and one that is also consistently popular. This project aims to add a tower defence game mode to Terasology, with a sandbox spin on it. The game mode allows for modular tower building and freeform block placement. It is intended to show off the best of Terasology and thus is designed to be extremely extensible as well as to use content from other modules.<br> <a href="https://docs.google.com/document/d/1DN4LxL8nSd9ZUbqhpXIfasmm8PQykJonOw7nUpKXpoo/edit?usp=sharing" target="_blank">The original proposal can be seen here</a></p> <p>Hope you enjoy!</p>
<p>In mathematics and computer algebra, automatic differentiation (AD) is a set of techniques to numerically evaluate the derivative of a function specified by a computer program. Automatic differentiation is an alternative technique to Symbolic differentiation and Numerical differentiation (the method of finite differences). Clad is based on Clang which provides the necessary facilities for code transformation.</p> <p>ROOT is a framework for data processing, born at CERN, at the heart of the research on high-energy physics. Every day, thousands of physicists use ROOT applications to analyze their data or to perform simulations. ROOT has a clang-based C++ interpreter Cling and integrates with Clad to enable flexible automatic differentiation facility.</p> <p><code>TFormula</code> is a ROOT class which bridges compiled and interpreted code.</p> <p>The project aims to add second order derivative support in <code>TFormula</code> using <code>clad::hessian</code>. The PR that added support for gradients in ROOT is taken as a reference and can be accessed <a href="https://github.com/root-project/root/pull/2745" target="_blank">here</a>.</p> <p>Optionally, if time permits, this project will also convert the gradient function into CUDA device kernels.</p>
<p>The purpose of this GSoC project will be to modernize <a href="http://github.com/clips/pattern" target="_blank">Pattern</a>, a Python library for <em>machine learning</em>, <em>natural language processing</em> (NLP) and <em>web mining</em>. A substantial part of this undertaking is to port a majority of the code base to Python 3. This involves porting the individual modules and sub–modules piece by piece, where the whole process will be guided by <em>unit tests</em>. In the beginning, I will remove all tests from the pipeline that do not pass for Python 3 and take this pared–down code base as a starting point, porting parts of the code and putting the respective unit tests back in as I go along. Missing unit tests must be added before moving on. Since porting Python 2 code to Python 3 code is a standard problem for the Python community, there are many different tools available that can help in this regard. In addition to that, I'd like to extend this project to a bit of a <em>Hausmeister</em> project (<em>housekeeping</em> for Pattern), and optimize/modernize the code base in terms of <em>execution speed</em>, <em>memory usage</em> and <em>documentation</em>.</p>
<p>Last year, <a href="https://summerofcode.withgoogle.com/projects/5809403503575040" target="_blank">as a project under the Google Summer of Code</a>, I created <a href="https://github.com/p5py/p5" target="_blank">p5</a> --- a native Python implementation of the Processing API. The goal then was to combine Python's minimal syntax and pedagogical roots with Processing's high-level graphics API. While the <a href="https://medium.com/processing-foundation/p5-a-python-implementation-of-the-processing-api-5f05c62db23b" target="_blank">project was successful</a> and we <a href="https://github.com/p5py/p5/releases/tag/v0.3.0a1" target="_blank">released the first alpha as a Python package</a>, p5 is still missing some core parts of the processing API and needs better cross-platform support.</p> <p>The goal of this project is to fix existing cross-platform issues by changing the internal rendering engine to <a href="http://vispy.org/" target="_blank">VisPy</a>; fixing <a href="https://github.com/p5py/p5/issues" target="_blank">existing open issues</a>; and extending the API by adding image support, improvements to the <code>Shape()</code> class, and minor utility methods.</p>
The grepreaper package addresses the critical need for efficient pattern matching and selective data loading in R, particularly for large datasets. Currently, R users must load entire files before filtering, creating performance bottlenecks. My solution implements four core functions: 1. grep_count(): Counts pattern matches without loading entire files 2. grep_read(): Selectively loads only matching data 3. grep_files(): Discovers files containing specific patterns 4. grep_context(): Shows matches with surrounding context lines The package leverages system commands for pre-filtering, significantly improving performance by avoiding unnecessary data loading. It supports flexible pattern matching options, including case sensitivity control, inverted matching, and multi-pattern support across multiple files. Deliverables include: 1. Complete R package with documented functions 2. Comprehensive test suite 3. Performance benchmarks against traditional methods 4. Introductory vignette with practical examples 5. Integration with popular data manipulation workflows This project will provide R users with a powerful tool for efficient data exploration, particularly beneficial for large dataset analysis and text mining applications.
<p>Phoenix is a web-based, experiment independent event display framework in JavaScript for visualizing HEP experiment data from multiple experiments. This project focuses on the following improvements to Phoenix.</p> <h5>Improvements</h5> <ul> <li>A more feature rich, control-oriented and intuitive GUI</li> <li>Easier selection of 3D objects and event data (like Tracks, Jets etc.)</li> <li>Keyboard controls for controlling the event display through keys</li> <li>Runge-kutta propagator for using Track parameters to calculate Track positions and decreasing data format size</li> <li>Extension of the current common JSON data format to support more diverse experiments and their event data</li> <li>Support for more CERN experiments like CMS</li> <li>Loaders for loading event data from ".root" and ".ig" files</li> <li>Loading and processing event data from cloud servers</li> <li>Animation of events to simulate the propagation of particles</li> <li>Improvement of VR features</li> <li>Investigating TGeo/GEANT4 geometries and implementing converters to display them in Phoenix</li> <li>Extending unit tests and creating UI tests</li> </ul>
The goal of this project is to push four nearly-finished ScummVM engines over the finish line, ensuring they are ready for official releases. Currently, these engines face issues ranging from incomplete low-level graphics and legacy code structures to unresolved gameplay bugs. How I plan to solve it: The project tackles the engines systematically. For the chamber engine, I will finalize the EGA planar graphics support and resolve memory-management issues like buffer overreads. For the avalanche engine, I will refactor the donated source code into modern C++ OOP standards, implement missing UI features, and fix gameplay logic bugs. Finally, for the DM and lilliput engines, I will conduct complete, meticulous end-to-end playthroughs to identify and fix any remaining logic, memory, or portability bugs. Deliverables: Chamber: Fully functional EGA 16-color graphics support without segmentation faults. Avalanche: A modernized, OOP-refactored codebase with a working "Shoot 'Em Up" minigame, repaired Robin Hood event trigger, missing Outro screens, and synced UI. DM & Lilliput: Stable, fully playable versions of Dungeon Master, The Adventures of Robin Hood, and Rome: Pathway to Power, fully prepared for stable public release.
Istio is a service mesh platform used by thousands of companies to secure and manage their microservices traffic, most often in a single Kubernetes cluster. However, the ability to operate across multiple clusters is an important feature in Istio's traditional Sidecar mode, and work to support it in Istio's Ambient mode is making rapid progress. To call any feature complete, comprehensive testing is needed. Given that multicluster Istio Ambient is a new mode of operating, we will need to both adapt tests for existing features to ensure they work across multiple clusters, as well as identify multi-cluster specific scenarios we want to codify in tests. Expected Outcome: 1. Audit existing ambient integration tests for cases that do not support multi-cluster testing patterns. 2. Refactor those tests, using Istio's testing infrastructure to cover features within a multi-cluster environment. 3. Work with Istio maintainers to identify opportunities for testing new scenarios that exist only for ambient multi-cluster. 4. As documentation is written for https://istio.io, verify that the user instructions (kubectl commands, YAML snippets, etc.) actually work end-to-end. 5. Gain hands-on experience with Istio's codebase, service mesh architectures, and Kubernetes multi-clust......
This project implements five concrete improvements to animint2 across the R compiler, animint.js renderer, and CI pipeline. First, polygon holes via geom_polygon(aes(subgroup)) — the JS renderer will use D3's d3.geo.path.projection(null) with fill-rule: evenodd to correctly draw multi-ring SVG paths instead of silently garbling them. Second, the CI race condition where R_coverage and JS_coverage share a hardcoded GitHub repo name will be fixed by deriving a unique repo name per job from the existing TEST_SUITE variable. Third, the inner apply() kernel of getCommonChunk() moves to C++ via Rcpp — benchmarks show 28x speedup for numeric columns and 32.5x for character columns. Fourth, scale range calculation moves from the R compiler to the JavaScript renderer — computed at click-time from visible data only, eliminating exponential blowup in plot.json. Fifth, stats and positions (stat_bin, position_stack, position_dodge) will be computed in JavaScript after showSelected is applied — fixing the silent breakage in geom_histogram and grouped bar charts. All features include renderer tests, documentation, and wiki updates. The RJSONIO → jsonlite migration will also be completed to remove a deprecated CRAN dependency.
Problem: Brian2CUDA offers significant GPU acceleration for neural simulations, but its current "beta" state contains friction points that hinder widespread adoption. Key issues include unreliable Windows support due to POSIX-specific build assumptions, slow incremental compilation that often exceeds simulation time, silent GPU failures that are difficult to debug, and startup crashes related to preference file validation. Solution: This project aims to make Brian2CUDA "production-ready" by modernizing its backend infrastructure without adding heavy external dependencies. The plan involves: Stabilizing the Windows workflow by implementing a robust nmake/MSVC build path and platform-independent path handling. Optimizing compilation speed through deterministic source grouping and granular dependency tracking in generated Makefiles. Implementing a synchronized C++/Python logging system with structured CUDA error-checking to eliminate silent failures. Resolving preference validation conflicts to ensure reliable configuration loading. Deliverables: - A validated cross-platform build system supporting Windows (nmake) and Linux/macOS (Makefile). Optimized code-generation templates for faster incremental builds. A unified diagnostic logging framework. A suite of regression tests and "Getting Started" documentation for Windows users.
Volcano has introduced Agent Scheduling feature that supports fast scheduling for AI agent workloads. This includes ShardingController for shard management, agent scheduler for agent workloads scheduling, and enhanced existing Volcano batch scheduler with sharding support to coordinated scheduling with agent scheduler. To ensure correctness and stability of this new scheduling mechanism, we need to build a comprehensive end-to-end (e2e) test suite. Test cases should cover key scenarios including shard creation, node assignment across shards, agent scheduler scheduling in different sharding modes, etc. - Expected Outcome: - A comprehensive e2e test suite using Ginkgo framework covering all agent scheduling scenarios. - Test cases for ShardingController: shard creation, node assignment, node addition/removal, configuration changes, and node stability across shards. - Test cases for Agent Scheduler: scheduling in no-sharding, hard-sharding, and soft-sharding modes, shard reconfiguration, and multi-worker scenarios. - Test cases for Volcano scheduler with sharding: validation of allocate, preempt, reclaim, and backfill actions under different sharding configurations. - Integration with CI/CD workflows for automated testing. - Comprehensive documentation including test design, coverage reports, and guidelines for extending tests.
The proposal aims to enhance Dubbo-python to meet the evolving needs of the AI sector by addressing compatibility issues, architectural limitations, and functionality gaps. Currently, Dubbo-python faces challenges due to its reliance on Python 2, deprecated libraries, and incomplete RPC communication capabilities, hindering its adoption within mainstream AI frameworks. To tackle these issues, the plan includes: 1. Upgrading Dubbo-python to support Python 3 and modernizing its architecture following the Microkernel + Plugin design principle. 2. Implementing complete RPC communication functionality, including server-side service exposure and client-side service invocation, with support for the new Triple protocol. 3. Developing service governance capabilities such as service discovery, registration, and load balancing, including the design of a GPU metric-based load balancing algorithm to address GPU workload imbalances in AI frameworks. 4. Writing comprehensive test codes to ensure the reliability of each functionality and providing detailed documentation to facilitate easier adoption and contribution to Dubbo-python. By accomplishing these objectives, the aim is to transform Dubbo-python into a robust, high-performance RPC framework compatible with mainstream AI frameworks, thus empowering developers to build scalable and efficient AI systems.
This project aims to improve the quality, consistency, and usability of the Checkstyle documentation website by enhancing automation and user experience. Although documentation generation has been partially automated from Java sources, gaps still exist such as missing examples, inconsistent formatting, and difficulty in navigation. The project will focus on completing and standardizing documentation for all Checkstyle modules by adding missing examples and enforcing uniform formats through automated validation integrated into the build and CI pipeline. This will reduce manual effort and ensure documentation remains accurate and up-to-date. Additionally, the website’s usability will be improved through frontend enhancements, including a client-side search feature based on a pre-generated index, enabling fast and backend-free navigation across the static site. Existing user-reported issues will also be addressed to further enhance the overall experience. Deliverables include: 1. Adding missing examples for all Checkstyle modules and checks 2. Standardizing and validating documentation formats across the website 3. Automating documentation checks within the CI/build pipeline 4. Implementing a client-side search feature for improved navigation 5. Resolving existing website usability issues and improving UX 6. Providing clear documentation for contributors on maintaining content
<p><strong>Modelica</strong> is an object-oriented and declarative language specification for description/modeling of dynamic systems (mechanical, electrical, thermal, mixed, etc.). <strong>Scilab</strong> uses it inside <strong>Xcos</strong> to describe more complex blocks/components, taking advantage of existing compiler/translator implementations to generate correspondent <strong>C</strong> code for actual simulation.</p> <p>For now, <strong>Modelica</strong> in <strong>Scilab</strong> is managed by an out-of tree compiler developed by <strong>LMS</strong> released under the <strong>GPL</strong> license, which is not actively maintained and support only a subset of the current language specification. The idea of this project is to allow the usage of <strong>OpenModelica</strong>’s <strong>OMCompiler</strong> (<strong>omc</strong>) as an alternative. Being a more up-to-date solution, <strong>omc</strong> integration would provide <strong>Scilab</strong>/<strong>Xcos</strong> the ability to use more advanced features, and avoid bugs, issues and maintenance burden of the current <strong>modelicac</strong> compiler.</p> <p>Adapting <strong>Xcos</strong> blocks to support the <strong>FMI2 API</strong> standard would allow not only omc-generated code to be called but also any other FMI2-compliant applications to be easily integrate in the future.</p>
This proposal targets the HSF 2026 idea Clad as a first class gradient engine in libtorch, a 350-hour project intended to make compiler-generated gradients available from LibTorch and, eventually, easier to reuse from the ROOT ecosystem. My goal is to build a practical and well-scoped integration path that allows a LibTorch C++ training loop to call Clad-generated derivative code for a small but meaningful subset of workloads. The primary implementation path is to wrap Clad-generated backward logic inside torch::autograd::Function, because the PyTorch C++ frontend explicitly supports custom autograd functions and presents them as the standard way to integrate optimized forward and backward code in extensions. If time permits and the API proves cleaner, I will also evaluate a custom-operator path based on the PyTorch C++ extension mechanisms. This proposal is intentionally scoped as a proof of concept, not as a general replacement for LibTorch autograd. A realistic first milestone is to differentiate selected training kernels or small model components written in C++, expose them to LibTorch, and measure where compiler-generated derivatives are correct, maintainable, and competitive. This produces a concrete result for mentors and also establishes a clear baseline for future work on broader operator coverage, deeper ROOT integration, or GPU support.
<p>NetFPGA is an open-source project aimed to foster networking hardware prototyping. Their latest and de-facto standard development board is NetFPGA SUME with a Virtex-7 FPGA and 4 SFP+ (10 Gbps) ports. The board’s open-source repository includes 14 designs: 'reference' projects to be used as a first step to building customized NICs, switches, routers, etc., as well as community member contributed projects. The NetFPGA software ecosystem, including the device drivers, is unfortunately Linux-centric, with no support for FreeBSD.</p> <p>This project will enable using NetFPGA SUME as a 4x10 Gbps NIC on hosts running FreeBSD. There are already FreeBSD drivers for older (now obsolete) versions of NetFPGA 10G (if_nf10bmac(4)) and NetFPGA 1G (<a href="https://github.com/wkoszek/freebsd_netfpga" target="_blank">https://github.com/wkoszek/freebsd_netfpga</a>), both incompatible with the SUME board but could provide some valuable insight. Writing a device driver on top of the iflib(9) framework should inherently provide support for netmap(4), which would enable high-speed traffic exchange between (custom) NetFPGA designs and userspace network applications, paving the way for experimentation with new hardware / software network processing paradigms.</p>