2026 Open Source Summer is now in full swing—openKylin challenges are waiting for you!
Starting in 2026, the Lighting Plan has officially entered the 2.0 era — oriented toward the AI era, centered on RISC-V core foundational software, comprehensively focusing on key fields such as operating systems, compilers, virtualization, and artificial intelligence, further strengthening open-source collaborative innovation, and continuously promoting the maturity and prosperity of the RISC-V ecosystem.
OpenAtom openKylin (hereinafter referred to as "openKylin") releases multiple project challenges through Summer of Open Source every year. Two projects are now available for the 2026 Summer of Open Source! Students are welcome to apply according to their interests or areas of expertise. openKylin Summer of Open Source challenges can be developed based on the openKylin 3.0 version. Participating students can first go to the official website to download the openKylin 3.0 system image, configure the basic development environment, and then proceed with challenge-related development work. System download link:
https://www.openkylin.top/downloads
Project Difficulty: Advanced
Completion Stipend: RMB 5,000 before tax
Programming Languages: C, C++, Python, Shell
Project Community Mentor: Yang Jiguo (HygonInformation Technology Co., Ltd.）
Mentor Contact Email:yangjiguo@hygon.cn
Project Description:
Currently, there is a gap in tools for user-mode program crash forensics and automatic reproduction for the openKylin operating system. Community developers and system maintainers lack standardized, automated assistance for crash diagnosis. When Linux user-mode C/C++ applications encounter exceptions such as SIGSEGV, SIGABRT, or SIGFPE, systemd-coredump can save the coredump and related metadata, and tools such as coredumpctl and GDB can further extract call stacks, registers, threads, and symbol information. However, completing a reliable crash diagnosis typically also requires understanding ELF/DWARF, debug symbols, source code context, and journal logs before and after the crash, as well as confirming the root cause through repeated experiments. For maintainers of desktop applications, system services, and third-party software, the cost of forensics for such issues is high, duplicate issues are difficult to merge, and minimal reproduction programs often rely on manual experience. Large models have the ability to understand code and logs, but without a standardized evidence chain, privacy controls, and executable verification, they can easily produce conclusions that are untraceable or unreproducible.
systemd-coredump and coredumpctl already provide coredump collection, indexing, query, and export capabilities; tools such as GDB, addr2line, and readelf can analyze stack frames, symbols, and binary information; tools such as AddressSanitizer can also assist in locating certain memory errors. The open-source community already has practices of using large models to analyze logs, call stacks, and code, but these capabilities mostly exist as standalone tools, lacking a general workflow that connects crash evidence collection, call stack normalization, source code retrieval, AI attribution, reproduction generation, and sandbox verification. The openKylin Skills repository provides a reusable organization and delivery format for system diagnosis AI skills.
Crash evidence is scattered, lacking a unified structured data model.
Address randomization and symbol differences make duplicate issues difficult to merge.
When debug symbols are missing, tools struggle to explain the confidence boundaries of conclusions.
AI conclusions often lack references to stack frames, logs, and source code evidence.
Minimal reproduction code lacks automatic compilation, execution, and similarity verification.
This project aims to build a complete closed loop of "crash record selection — automatic evidence collection — symbol and stack frame normalization — crash fingerprint generation — source code and log retrieval — large model root cause analysis — reproduction generation — sandbox verification." The system should receive crash records from coredumpctl, automatically generate structured evidence packages, and merge crashes of the same defect at different addresses and in different process instances into stable fingerprints; combined with project source code, build information, and journal logs before and after the crash, the large model should output root cause hypotheses ranked by evidence support, missing information, and subsequent verification steps; optionally generate minimal reproduction programs or test scaffolding, compile and execute them in containers or restricted sandboxes, and determine whether reproduction is successful based on signal type, key stack frames, and crash fingerprints. All externally sent data should be desensitized by default, and the model must not directly execute high-privilege commands on the host machine.
Ultimately, a user-mode crash forensics and reproduction tool that can run in a standard x86-64 Linux environment should be developed and packaged as an installable software package (.deb) suitable for the openKylin operating system. The basic version must support at least three types of exceptions for C/C++ user-mode programs: SIGSEGV, SIGABRT, and SIGFPE, and provide a command-line interface, evidence collection and desensitization, call stack normalization, crash fingerprints, source code retrieval, AI root cause analysis, reproduction generation, sandbox verification, and JSON/Markdown reports. The project should provide no fewer than 12 public fault samples, of which at least 10 must complete correct first-level error classification, and at least 5 must generate reproduction programs or reproduction scaffolding that pass verification; primary verification must be completed in the openKylin x86-64 environment, and compatibility verification must be completed on at least one other systemd Linux distribution.
Project Deliverables:
1. Develop a coredump evidence collection and desensitization module;
2. Implement call stack normalization and crash fingerprints;
3. Implement source code and journal context retrieval;
4. Develop evidence-constrained large model root cause analysis;
5. Implement minimal reproduction generation and sandbox verification;
6. Support three signal types and twelve fault samples;
7. Complete verification on two x86-64 distributions;
8. Output JSON and Markdown diagnostic reports;
9. Submit automated tests, documentation, and mergeable PRs.
10. Software package delivery: package the tool as a .deb package suitable for openKylin, ensuring it can be installed and used via dpkg.
Project Technical Requirements:
1. Proficient in Python and Linux command-line development;
2. Familiar with C/C++ and common memory errors;
3. Familiar with GDB and core dump debugging;
4. Understanding of ELF, DWARF, and debug symbols;
5. Familiar with systemd-coredump and journal;
6. Understanding of large model APIs and structured output;
7. Familiar with containers, Git, and automated testing;
8. Experience with crash analysis or Agents is preferred.
9. Understanding of the openKylin operating system development environment, with experience debugging system software on openKylin being a plus.
Project Homepage:https://m.summer.ospp.ac.cn/org/prodetail/267180067
Project Difficulty: Advanced
Completion Stipend: RMB 5,000 before tax
Programming Languages: C, Python, Rust
Project Community Mentor: Xiao Hui (Kylin Software Co., Ltd.）
Mentor Contact Email:xiaohui@kylinos.cn
Project Description:
The RK3588 integrates a 6 TOPS NPU, commonly used in scenarios such as edge gateways, robotics, industrial vision, and lightweight local large model inference. Existing inference pipelines typically rely on Linux kernel drivers, user-mode runtimes, and vendor SDKs, resulting in a heavy system stack that makes it difficult to demonstrate the complete path from device driver to model execution in teaching-oriented or research-oriented operating systems. X-Kernel, led by the openKylin community, is a Rust-based macro-kernel experimental system with advantages in memory safety, modularity, and extensibility for modern hardware, making it suitable for hosting a researchable and reproducible edge AI inference pipeline.
X-Kernel already has basic kernel framework, device management, and user-mode interface extension capabilities; the RK3588 ecosystem already has NPU-related documentation, open-source examples, and user-mode inference tools for reference. The community has also accumulated practices in Rust driver development, device tree parsing, DMA buffer management, and asynchronous task scheduling.
• X-Kernel currently lacks real device driver cases for AI accelerators.
• RK3588 NPU command submission, memory mapping, interrupt handling, and user-mode interfaces have not yet formed reusable abstractions in the Rust macro-kernel.
• Edge inference typically remains at user-mode examples, lacking an end-to-end pipeline covering kernel drivers, runtime adaptation, model deployment, and performance evaluation.
• There is a lack of systematic testing for NPU driver stability, error recovery, and inference performance.
• Implement RK3588 NPU device discovery, initialization, memory management, interrupt handling, and task submission in X-Kernel.
• Design Rust-style safe driver interfaces, encapsulating unsafe boundaries to reduce the cost of subsequent device driver development.
• Provide user-mode ioctl/syscall or character device interfaces, and adapt a minimal inference runtime.
• Complete end-to-end inference demonstrations for typical models, such as image classification or object detection.
• Establish functional, stability, and performance testing, and output reproducible experiment reports.
Complete an openKylin X-Kernel NPU driver prototype that can run on an RK3588 development board, and establish the model loading, tensor buffer allocation, NPU task submission, result retrieval, and user-mode inference call pipeline. The project should ultimately provide compilable code, example programs, test cases, deployment documentation, and a performance evaluation report.
Project Deliverables:
1. Complete RK3588 NPU device initialization and resource management in the openKylin operating system environment.
2. Implement NPU DMA buffer and memory mapping interfaces.
3. Implement task submission, interrupt handling, and result retrieval flows.
4. Provide user-mode inference runtime adaptation interfaces.
5. Complete end-to-end inference Demo for at least one model.
6. Supplement driver tests, deployment documentation, and performance reports.
Project Technical Requirements:
1. Proficient in Rust system programming and unsafe boundary encapsulation.
2. Familiar with operating system kernel and device driver fundamentals.
3. Familiar with ARM64, MMIO, interrupts, and DMA mechanisms.
4. Understanding of RK3588 NPU or AI accelerator operating models.
5. Understanding of edge AI inference, model formats, and runtimes.
6. Experience with embedded Linux or development board debugging is preferred.
Project Homepage:https://m.summer.ospp.ac.cn/org/prodetail/267180066
Log in to the official websitehttps://summer.ospp.ac.cn/and view the challenges on the openKylin homepage to register!
The project tasks are now live on the official website. Students can communicate directly with mentors via the mentor email in the project details, or scan the QR code below to join the discussion group, where teachers will answer questions online:
Scan the QR code to add a friend, send "2026 Summer of Open Source" to join the group
Click[Read Original]to view detailed information on all openKylin projects for the 2026 Summer of Open Source. If you are interested, you can log in to the Summer of Open Source official website to register, communicate with mentors, and submit your resume!