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.
Currently, Tiled uses software/CPU rendering for all of its images drawn in the application. This project will implement a new renderer utilizing hardware/GPU rendering, leading to better performance and setting the groundwork for hardware rendering-specific features to be added in the future. The new renderer will be built over the course of 13 weeks, and will progress as so: - Create an option to switch between software/hardware rendering. - Migrate TiledQuick's existing code to replace Tiled's map renderer. - Ensure all existing map editing tools function. - Render animated tiles. - Add safeguards to prevent GPU rendering on devices that can't handle it. At this point, the project will fit the requirements of being completed. However, two more features are planned to be added. The first feature is a memory optimization when drawing the map, and the second is the ability to create maps of polygon-shaped tiles.
Apache NuttX, while offering a Unix-like RTOS environment, currently lacks support for the vast ecosystem of X11-based graphical applications. This limits its usability in embedded GUI scenarios. This project addresses the gap by porting NanoX (also known as Microwindows), a compact X11-compatible server, to NuttX. The port will adapt NanoX’s client-server communication from Unix sockets to NuttX’s message-queue model, and rework the Nano-X server backend to run on top of NuttX’s NX/NXTK window system instead of accessing the framebuffer directly. It will also integrate NuttX’s input subsystem for mouse, keyboard, and touch support while preserving Nano-X/NX11 compatibility. The result will be a Nano-X/NX11 compatibility layer on NuttX that can run applications such as FLTK with minimal changes. Time permitting, I'll also port of FLTK 1.3 and the Dillo web browser to demonstrate real-world application capability.
Studying team communication in simulated human-factors environments currently relies on manual annotation of hours of raw audio, a process that is time-consuming and subject to recall bias. This project builds TCAMP, a modular open-source pipeline that takes raw headset audio as input and outputs structured behavioral metrics grounded in validated Human Factors research. By combining speech enhancement, speaker diarization, transcription, and communication analytics, TCAMP gives research labs an automated, objective instrument for studying team coordination and performance in simulated environments.
The GA4GH Service Info API is a required component across standards such as TES, WES, and TRS, providing essential metadata about a service. Currently, each implementation must manually develop and maintain its own /service-info endpoint, leading to duplication, inconsistent metadata, and difficulty in supporting new capabilities such as security and extensibility features. This project proposes a reusable GA4GH ServiceInfo Sidecar a lightweight proxy service that runs alongside existing GA4GH services and handles /service-info requests centrally, while forwarding all other requests transparently to the backend. The sidecar will generate standard-compliant responses using a combination of static configuration (config.yaml) and dynamic metadata collected through a plugin system, enabling seamless support for service-specific and custom extensions without modifying backend code. The project will deliver a production-ready implementation with schema validation, extensibility aligned with GA4GH specifications, and deployment support via Docker and Kubernetes. Additionally, the sidecar will support Trusted Execution Environments (TEE) by advertising attestation capabilities via the ServiceInfo API and delivering attestation reports through a dedicated endpoint, enabling verifiable trust without implementing low-level attestation logic.
KDE is one of the largest open-source communities, offering opportunities in the field of development, design, documentation, translation and mentorship. However, the current onboarding experience is very fragmented, the entry points are spread across various platforms which often leaves new contributors asking "Where do I even start?". This project aims to build join.kde.org as KDE's primary contributor entry point and central hub, routing users to the right resource. The site will allow users to find their own place in open source software based on their interest and it will allow experienced contributors to contribute directly into projects based on their skillset. The site will be organized into clear sections: Add, Learn, Divulge, Work on a Project, Read, Explore, Meet, and Suggest. Built using Hugo for static site generation, Deliverables include a fully responsive website with interest-based navigation, structured contributor pathway cards for all contribution types, mentorship program overviews, a KDE Networks map with setup instructions, and complete site maintenance documentation. This project directly aligns with KDE’s goal: "KDE Needs You" , which aims to bring more contributors into the community and increase the retention for the said contributors.
This project solves the problem of inefficient on-chain trading, where current systems depend on fixed prices, off-chain matching, or complex order books that do not scale well. As the number of orders grows, matching becomes slow, costly, and less transparent. To solve this, I will build Windmill, a fully on-chain trading system where orders are not fixed but change with time as price curves. Buy prices go down, sell prices go up, and trades happen automatically when they meet. No off-chain engine, no oracle, and no central control is needed. Everything is deterministic and runs directly on the blockchain. The deliverables include smart contracts for order creation, matching, and settlement, a keeper system to trigger matches, a frontend interface for users to place and track orders, and a subgraph for indexing and analytics. The final system will be scalable and completely decentralized.
OpenROAD's CUGR backend lacks incremental routing support, forcing a full re-route of the entire design after every Engineering Change Order (ECO) operation such as buffer insertion, buffer removal, gate upsizing or downsizing, and placement legalisation. On large industrial designs this can take tens of minutes per iteration. FastRoute, the other backend, already handles this correctly via the IncrementalGRoute class and GRouteDbCbk ODB callbacks that track only the subset of modified nets. This project brings full incremental routing parity to CUGR by implementing deleted net cleanup (removeNet), connecting all five ECO-triggered ODB callbacks to CUGR's dirty-net queue, ensuring only the correct subset of nets is re-routed per incremental pass, and scoping guide write-back to dirty and secondary overflow nets only, modelled on findRouting in FastRoute. Three pull requests implementing the core infrastructure have already been merged into upstream OpenROAD (#9671, #9759, #9866). Deliverables include the complete incremental CUGR flow, a regression test suite covering all ECO scenarios, incremental congestion view updates, and benchmarking data comparing incremental versus full re-route runtime and quality across reference designs.
This project proposes mlr3hf, an R package for integrating Hugging Face datasets into the mlr3 ecosystem. The package will allow users to download datasets from Hugging Face, cache them locally, and convert them into mlr3 tasks efficiently. To support large datasets, the package will use Parquet + DuckDB for lazy, disk-based querying, minimizing RAM usage while preserving scalability. It will also support fallback handling for canonical formats such as CSV, JSON, and TSV, along with split-aware task creation for train/test/validation datasets. The final outcome will be a practical, memory-efficient, and CRAN-ready workflow for using Hugging Face datasets in mlr3.
Problems to solve: - Porting and stabilizing Arduino CLI for FreeBSD - Fixing USB and serial communication workflows for reliable device interaction - Developing a unified CLI-based workflow for building, flashing, and monitoring devices Standardize device detection and access using FreeBSD’s /dev interfaces and devd. Address permission and driver issues, implement reliable serial port identification, and ensure stable communication for flashing and monitoring through tested configurations. Build a wrapper CLI that integrates Arduino CLI, ESP32 tooling, and serial monitoring into a single interface. Automate common tasks (build, flash, monitor), reduce manual setup, and provide a consistent developer experience with clear commands and documentation.
This project builds a modular audio pipeline for tabletop RPG session analysis within the HumanAI TableTalk framework. It extends mood detection with speaker diarization, narrative role classification, and semantic retrieval over recorded sessions. Deliverables include a Whisper-based transcription layer, an SVM/ensemble classifier for narrative voice tagging, a FAISS-backed semantic retrieval index, and a documented evaluation suite; enabling players to query sessions by emotional arc or character voice.
LFortran is a modern, interactive Fortran compiler built on LLVM that aims to support real-world Fortran codebases. This project focuses on enabling full compilation and correct execution of two real-world Fortran packages benchmark.f (a benchmarking library) and feq-parse (an equation parser) using LFortran. Significant pre-GSoC progress has already been made: benchmark.f currently compiles to 76% and feq-parse to 40%. The remaining blockers include missing quadruple precision (REAL(KIND=16)) support, deserialization ICEs for forward-referenced symbol tables, ExternalSymbol resolution failures for struct-scoped types, ASR verifier false positives for GenericProcedure constructor calls, and an LLVM IR type mismatch in character length handling. The project will follow an iterative, compilation-driven workflow: attempt compilation, identify failures, reduce to MREs, fix the compiler, and validate against gfortran. Every fix will be accompanied by integration tests to prevent regressions. Deliverables: - Full compilation of both benchmark.f and feq-parse with LFortran - All example programs and test suites passing with gfortran-consistent output - End-to-end quadruple precision support across parsing, ASR, and LLVM backend - All fixes merged as pull requests with integration tests
As AI assistants adopt humanlike names, conversational tone, and confidence framing, users form impressions of AI competence from interface design alone — independently of actual system capability. This can produce overtrust, underuse, or miscalibrated reliance. Most existing research measures trust through self-report scales, which cannot capture when or how quickly users actually defer to or override an AI recommendation. This project builds a modular, open-source web-based experimentation platform that makes behavioral trust measures tractable for researchers. Built in Next.js, the system supports randomized condition assignment, configurable manipulation of humanlike interface cues (agent name, tone, confidence framing), and a recommendation-acceptance task that produces clear reliance-versus-override outcomes under controlled AI accuracy. Fine-grained event logs — decisions, timestamps, response latency — are exported as clean JSON and CSV datasets, and a reproducible Python notebook reports reliance rate, override rate, and latency by condition. The platform is designed as reusable research infrastructure: cue logic is configuration-driven, task logic is decoupled from condition management, and the event schema is fully documented so future researchers can extend the system with new cues, tasks, and study conditions. Deliverables include a functional experimental prototype, cue manipulation framework, behavioral logging backend, sample dataset, analysis notebook, and complete documentation in a public GitHub repository.
A common problem in binary analysis is function detection. One method is searching for function preludes. Preludes are a sequence of instructions commonly found at the beginning of a function. These preludes perform tasks like setting up the stack, or initializing registers to values as defined in the architecture’s ABI. It is very common to hard-code these prelude patterns and match instructions against them. These patterns get outdated, are tedious to update, and have to be written for each architecture. Also because these signatures are generic, they are highly prone to false positives especially on x86/x86_64 binaries. This project aims to augment static signature based approach with a dynamic, multi-stage statistical heuristic pipeline. Weighted Prefix Trie will be used for matching and then filtering through 2-signal validation approach (frequency distribution analysis + shannon entropy) for removing noise. Hence the plugin will automatically learn directly from functions identified by initial CFG (Control Flow Graph) analysis in the target binary. This approach also enables the discovery of orphaned or hidden functions that standard CFG analysis often misses in stripped or obfuscated binaries.
FFmpeg already supports WHIP, allowing users to publish WebRTC streams using HTTP signaling. This project aims to extend WHIP support by adding support for more codecs, enabling multiple media streams, providing full ICE support, and other related improvements.
Haiku's Bluetooth stack currently implements only a basic subset of general Bluetooth functionality. At first during testing with an Android phone, the local device was visible, but the pairing process fails entirely because Haiku does not understand modern Bluetooth events. The pairing process silently failed because the stack drops unsolicited Secure Simple Pairing (SSP) requests. The system was dropping modern discovery packets because the Inquiry subsystem lacked Extended Inquiry Result (EIR) support. Although recently the SSP and EIR issues have had recent patches from GSoC candidates, still there’re several issues in bluetooth pairing and connection that needs handling including: the pairing button doesn't make any action, not showing the pairing number when getting pairing requests from the phone, and lacking persistent remote device information. Hence, many other modern HCI events and commands still need handling. The primary motivation of this project is to modernize Haiku’s Core Bluetooth stack to match 2.X and later to improve the existing code's compatibility with newer devices. By resolving these foundational HCI drops, the stack can finally be used for more than just basic pairing attempts, paving the way for functional Bluetooth HID, audio, or file transfer profiles. This project modernizes the stack by Completing the remaining HCI commands and events, Adding persistent Link Key storage to preserve pairing devices after reboot, Implementing the Service Discovery Protocol (SDP), and Delivering a full Human Interface Device (HID) profile with a working input_server add-on.
The project adds InfluxDB 2.0 and Elasticsearch as timeseries database backends to OpenWISP Monitoring by implementing the existing DatabaseClient. The core monitoring logic remains untouched since it already interacts through timeseries_db abstraction, making backend addition a clean isolated task. For InfluxDB 2.0, all chart queries in `queries.py` will be translated from InfluxQL to Flux. For Elasticsearch, queries will use `date_histogram` aggregations. Each backend gets dedicated GitHub Actions CI, deployment support via ansible-openwisp2 and docker-openwisp, and users can switch between all three backends through the `TIMESERIES_DATABASE` setting with full documentation coverage.
GBasis currently requires manual libcint compilation, breaking on macOS and Windows. This project automates the build using scikit-build-core and CMake FetchContent, adds cross-platform wheel building via cibuildwheel on GitHub Actions, implements platform-aware library loading, and wraps additional integrals from issue #149.
Currently, national climate and fiscal policy analyses operate in isolated domains. The CLEWS framework models physical constraints across energy, land, and water systems, whereas OG-Core projects macroeconomic and demographic trajectories. Because their output schemas, unit normalizations, and temporal resolutions are fundamentally incompatible, analysts must manually translate data between the two models to understand how physical policies impact long-term fiscal stability. This project establishes the first automated, bidirectional integration between OSeMOSYS and OG-Core within the MUIOGO platform. Building upon the asynchronous execution architecture and API contracts recently established in the repository, the project will construct a multi-step convergence pipeline. This system will orchestrate the execution of CLEWS, perform the necessary schema translations, run the OG-Core macroeconomic model, and iteratively feed the fiscal outputs back into the physical model until a mathematical fixed point is reached. The development is structured across four strictly ordered deliverables: 1. A stabilized, cross-platform MUIOGO runtime environment supported by comprehensive automated testing. 2. A native OG-Core execution module featuring a dedicated scenario manager and a visual results dashboard. 3. A coupled data pipeline designed to strictly normalize and translate critical bridge variables between the two distinct architectures. 4. A final convergence orchestrator capable of managing the iterative loop, complete with configurable stopping criteria and automated divergence detection.
vscode-json-languageservice, the library powering JSON editing in VSCode currently supports only JSON Schema draft-07. The architectural coupling between its validator and editor features means draft support cannot be extended by simply swapping the validator. This project aims at building a drop-in replacement that matches the exact API surface of vscode-json-languageservice while replacing the validator with @hyperjump/json-schema, bringing full support for draft-04 through draft-2020-12. By the end of GSoC, all 13 features of the existing library will be implemented and tested, backed by a MatchingSchemaCollector EvaluationPlugin as the core data layer, a working VSCode extension, and a test suite verifying drop-in compatibility with the existing implementation.
RUXAILAB currently saves the final state of usability studies but lacks insight into the evaluation process itself. This project introduces a unified, scalable logging and traceability system built into the shared frontend layer, backed by entirely secure Firestore Cloud Functions. It captures methodology-specific events (like evaluator answer revisions and participant task anomalies) to provide researchers with an interactive Log Explorer, quick filters, and anonymized exports. This system enables deep session traceability for IRB submissions and post-study behavioral analysis without increasing database read costs or affecting existing architectures.
Visdom is great for watching training in real time, but once you have dozens of experiments, keeping track of what hyperparameters you used in each one becomes a mess. This project adds an experiment tracking layer to Visdom a SQLite-backed metadata store where every run carries structured hyperparameters, metrics, and tags. I am building a search system so you can query runs with simple syntax like "lr less than 0.01 and accuracy above 90", interactive parallel coordinates plots to visualize the hyperparameter space, and Optuna integration so Visdom can suggest what to try next based on past results. Everything runs locally with zero external dependencies, keeping Visdom's self-hosted philosophy intact. I have already contributed 6 PRs to the Visdom codebase covering backend bug fixes, frontend improvements, test fixes, and Python 3.12+ compatibility, and I have deep familiarity with both the Tornado server and the React frontend.
This project redesigns sbi's potential function API to eliminate stateful behavior, inconsistent IID handling, and device management bugs. The new architecture introduces a three-layer design: (1) stateless core protocol using typing.Protocol for composability, (2) explicit observation binding utilities with clear IID semantics, and (3) high-level convenience factories. This enables seamless integration with NumPyro, PyMC, and PyTorch samplers while maintaining backward compatibility through a phased migration strategy. Deliverables include refactored potential classes, comprehensive tests, migration guide, UML diagrams, and tutorial notebooks demonstrating ecosystem integration. The redesign fundamentally improves maintainability, extensibility, and reliability for both novice users and advanced practitioners.
The go-mfp cpython package is a unique Go library that embeds CPython as a scripting engine, supporting multiple isolated sub-interpreters with automatic garbage collection of Python objects. As this package is planned to move into a standalone repository and potentially become critical Linux infrastructure, ensuring correctness and security across Python 3.8 through the latest version is essential. This project will build a comprehensive unit test and fuzz test suite — pairing each source file with _test.go and _fuzz_test.go files using Go's native fuzzing framework, tested across Python 3.8–latest on both x86 and ARM64. Deliverables: - Full unit test suite for all public API functions - Fuzz harnesses for sub-interpreter lifecycle, object GC, type conversions, and error handling - CI matrix builds across Python versions and architectures - Documentation for running and extending the test suite
Uyuni is a powerful systems management platform, but today it lacks a native way to automate actions based on events in real time. As a result, administrators often have to write custom scripts to react to things like patch updates or system changes, which adds unnecessary complexity and effort. This project aims to change that by introducing a simple, scalable event-driven architecture that turns Uyuni into an automation-friendly platform. The idea is to make it easy for administrators to connect Uyuni with other tools and build workflows without writing a lot of custom code. The solution has two main parts. First, an MQTT-based event publisher that hooks into Uyuni’s existing event pipeline and emits real-time events such as patch updates, system registrations, and Salt state results. Second, a custom Node-RED integration that allows administrators to visually design automation workflows using a drag-and-drop interface. The publisher is designed to be lightweight and non-intrusive, running as a passive listener so it does not interfere with Uyuni’s current behavior. It sends structured JSON messages, supports topic-based filtering, and includes reliability features like retries, batching, and rate limiting to handle larger deployments. On top of this, the Node-RED layer provides reusable nodes for consuming events, triggering actions, and interacting with Uyuni APIs. Overall, this project makes automation in Uyuni much more accessible, reduces the need for manual scripting, and enables easy integration with external tools like Slack or Jira. It also lays a solid foundation for building more advanced automation features in the future.