Awesome GitHub RepositoriesKernel Component Debugging

WinFSP is a framework for implementing custom file systems on Windows. It enables the creation of user-mode file systems that appear as standard disk drives or network shares to the operating system, allowing developers to implement file system logic in user space via a proxy architecture that avoids the need for custom kernel code. A primary differentiator is its FUSE compatibility layer, which maps POSIX-based file system calls to native Windows requests. This allows existing file systems written for the FUSE API to be ported to Windows and Cygwin environments. The project covers a wide ra

The Linux Kernel Module Programming Guide is an educational resource that teaches how to write, compile, and manage loadable kernel modules for modern Linux kernels. It covers the complete lifecycle of kernel modules, from building and loading to unloading and debugging, with a focus on extending kernel functionality without recompiling the entire kernel. The guide provides comprehensive coverage of core kernel programming concepts including dynamic module loading, file-operation registration, interrupt handling, kernel-user data copying, concurrency control, and deferred task scheduling. It

XXPermissions is a framework and manager for handling runtime and special system permissions across different Android operating system versions. It provides a unified interface for requesting standard permissions and directing users to system settings pages for advanced access control, such as file access and accessibility services. The project features a backward compatibility layer that abstracts version-specific logic, removing the need for manual operating system version checks in client code. It utilizes a chainable request pipeline to queue multiple permissions and manage their asynchro

The Rust RFCs repository is the formal home for the Rust language evolution process, housing the structured design documents and community review mechanisms that govern changes to the Rust programming language, its compiler, and its standard library. It defines the complete lifecycle for proposing, discussing, and implementing substantial changes through RFC documents, from initial submission and community feedback through final comment periods and sub-team sign-offs. The repository codifies the governance and collaboration processes that shape Rust's development, including mechanisms for com

SSHFS-Win is a Windows implementation of SSHFS that mounts remote directories over SSH as local Windows drives, enabling seamless file access as if they were local network drives. It provides both command-line and graphical interfaces for creating, managing, and disconnecting SSHFS mounts, supporting password or SSH key authentication with optional credential storage in the Windows Credential Manager. The project extends beyond basic SSH mounting to support a wide range of remote file access scenarios, including mounting cloud storage services like Azure Blob or Amazon S3, distributed POSIX f

Warp is a Python framework that JIT-compiles Python functions into CUDA kernels for GPU-accelerated parallel computation, with built-in automatic differentiation and multi-framework array interoperability. At its core, it provides a GPU kernel compilation system that enables writing and executing custom GPU kernels directly from Python, while supporting automatic gradient computation through those kernels for integration with machine learning pipelines. The framework also includes tile-based cooperative computing, where thread blocks partition into tiles for shared-memory and tensor-core opera

seL4 is a formally verified microkernel whose C implementation is backed by machine-checked mathematical proofs of correctness, confidentiality, integrity, and availability. It enforces strict isolation between processes through hardware-enforced address space separation and a capability-based access control system, where each process holds explicit rights only to the resources it has been granted. The kernel exposes hardware resources through a minimal API of system calls that manage threads, address spaces, and inter-process communication, with synchronous IPC supporting sender-identifying b

Battery Historian est un outil de visualisation et de profilage pour analyser la consommation d'énergie et la décharge de la batterie sur les appareils Android. Il fonctionne comme une visionneuse de rapports de bugs et un profileur de consommation d'énergie qui analyse les logs système pour extraire les statistiques de batterie et les données du noyau dans une interface basée sur le web. L'outil se spécialise dans la corrélation de sources de données disparates sur une chronologie synchronisée. Il identifie les activités consommatrices d'énergie en suivant les transitions de wakelock de l'espace utilisateur et du noyau, en mappant les sources de réveil du noyau à des horodatages en temps réel, et en superposant les logs de moniteurs d'énergie matériels externes sur les événements système. Le système fournit des capacités pour l'analyse comparative, permettant le calcul de deltas entre plusieurs rapports de bugs pour mesurer les changements dans le comportement énergétique. Il agrège en outre les métriques au niveau de l'application et les événements système pour identifier les déclencheurs logiciels spécifiques qui empêchent un appareil d'entrer en mode veille.

TileLang is a Python-embedded domain-specific language compiler that JIT-compiles and autotunes GPU kernels. It uses a tile-based DSL, automatic software pipelining, and parallel autotuning to generate optimized GPU kernels at runtime. It supports tensor core operations with Pythonic syntax, automatic memory management, and thread mapping. The compiler searches over tile sizes, thread counts, and scheduling policies, compiling and benchmarking candidates in parallel to find the fastest kernel. It also caches compiled binaries and tuning results to disk for reuse across sessions. TileLang inc

Ce projet fournit un environnement de développement du noyau Linux et une suite d'émulation système pour construire et déboguer des modules noyau et de l'assembleur bare-metal à travers de multiples architectures matérielles. Il fonctionne comme un bac à sable complet et un framework pour le développement système bas niveau, utilisant QEMU pour simuler des environnements matériels sans avoir besoin de périphériques physiques. L'environnement intègre des chaînes de compilation croisée utilisant Buildroot et crosstool-NG pour cibler les plateformes x86_64, ARMv7 et ARMv8 depuis un seul hôte. Il dispose d'un framework de débogage noyau spécialisé qui exploite GDB et KGDB pour l'exécution pas à pas et l'inspection d'état des processus noyau et utilisateur. Ses larges capacités incluent des tests de régression automatisés pour isoler les échecs de démarrage et fonctionnels via la bissection de contrôle de version, l'abstraction matérielle pour gérer les états d'alimentation du CPU et les registres système, et des primitives de test bas niveau pour l'intégrité de l'état mémoire et l'analyse d'assembleur. Le système inclut également des utilitaires pour le benchmarking de performance des commandes, la journalisation de sortie et l'amorçage d'espaces de travail conteneurisés.

This project is a comprehensive technical manual for installing macOS on non-Apple x86 hardware using the OpenCore bootloader. It serves as a configuration guide for emulating Apple hardware and patching system firmware to achieve operating system compatibility on PCs. The documentation provides detailed instructions for SMBIOS hardware emulation, including the generation of system identifiers and model profiles. It covers the application of ACPI table patches to enable native power management and the modification of UEFI runtime services to resolve memory map and write protection issues. Th

This project is an educational operating system kernel designed to demonstrate the fundamental architectural principles of memory paging and process management. It is implemented as a minimal kernel that serves as a practical reference for building a functioning system from the ground up. The implementation features a preemptive multitasking kernel that switches execution contexts between threads to share a single CPU. It includes an x86 virtual memory manager that uses paging to map virtual addresses to physical memory and isolate processes. The system covers low-level hardware interfacing

XNU is an operating system kernel designed to manage system hardware and process execution across different processor architectures. It utilizes a hybrid microkernel design that combines microkernel message passing with monolithic kernel performance by embedding critical subsystems into a single address space. The project implements a port-based asynchronous messaging system for communication between kernel tasks and userspace processes. It manages hardware interactions through a layered driver architecture and enforces system-wide security policies via a mandatory access control interface.