Open-source alternatives to Riscv Isa Manual

Doxygen is a source code documentation generator and multi-language API reference tool. It extracts annotated comments from source code to create structured technical manuals and searchable software libraries in formats including HTML, LaTeX, and PDF. The project functions as a static code analysis visualizer, generating call graphs, class diagrams, and inheritance hierarchies to illustrate codebase structure. It also serves as an XML documentation export engine, producing structured metadata that can be transformed via XSLT or third-party tools. Beyond API extraction, the tool provides a Ma

SJTU-Courses is a collaborative academic material archive and resource repository. It serves as a community-driven hub for organizing and distributing course-specific documents and study guides for university students. The project operates as a version-controlled library where learners submit and verify academic content. It uses a contribution model based on pull requests and issues to manage the curation of educational resources. The repository organizes its knowledge base through a flat-file directory hierarchy and stores descriptions and guides as markdown files. This structure allows for

This project is a bilingual Java programming guide and educational resource that provides professional Java coding standards and best practices in both English and Chinese. It serves as a software engineering study material designed to teach industry-standard patterns and guidelines through dual-language comparisons. The content is organized as a markdown technical reference, utilizing a side-by-side layout to align original English technical text with corresponding Chinese translations. This structure allows for the direct comparison of technical documentation to clarify complex software eng

This project is a community-driven knowledge base and diagnostic suite designed to evaluate and improve a developer's grasp of JavaScript. It functions as an interactive learning repository, providing a structured collection of technical questions and detailed explanations that target core language mechanics, runtime nuances, and common edge cases. The repository distinguishes itself through a collaborative approach to technical education, offering a wide array of challenging problems that serve as both a skill assessment tool and a resource for interview preparation. By organizing complex co

This project is a curated knowledge repository that serves as a comprehensive reference guide for web development. It organizes high-quality resources, documentation, and technical links into a structured collection designed to assist developers in navigating the frontend ecosystem and staying updated with evolving industry standards. The repository utilizes a directory-based information architecture, categorizing complex technical topics into nested folders to ensure predictable navigation. By leveraging a git-versioned knowledge base, the project maintains a complete historical audit trail

darkriscv is a collection of tools and projects for RISC-V processor implementation, hardware debugging, and automated FPGA synthesis. It provides a hardware design that implements a RISC-V processor core and system components for deployment on programmable logic. The project includes a hardware debugger with a command-line interface for verifying processor state by manipulating registers and dumping memory on a hardware target. It also features a set of scripts and project files to automate the synthesis and programming of hardware designs within a Linux environment. The codebase covers har

This project is a bare-metal operating system developed for ARM64 architecture. It serves as a low-level implementation of kernel engineering, focusing on the fundamental construction of an OS from the hardware level up. The system is distinguished by its comprehensive approach to ARM64 processor control, featuring a red-black tree task scheduler and a hierarchical page table system for virtual memory management. It implements a sophisticated privilege model that handles transitions between kernel and user modes, ensuring process isolation through address space splitting and exception level m

picorv32 is a size-optimized RISC-V CPU core and synthesizable processor IP designed for integration into FPGA and ASIC hardware designs. It serves as an open-source CPU architecture and embedded system-on-chip component that implements a standard RISC-V instruction set. The design features a modular architecture that allows for the integration of external coprocessors to implement custom non-branching instructions. It includes a parameterized integer unit with configurable multiplication and division cores to balance performance against total logic gate count. The project covers a broad ran

This project is an ARMv8 assembly programming guide and tutorial designed to teach the translation of high-level logic into low-level machine instructions. It serves as a low-level systems programming reference for writing and executing code specifically for the ARMv8 architecture. The resource provides instructions for cross-platform assembly implementation, focusing on unifying symbol naming and memory addressing to ensure source code builds across different operating systems. It also covers the integration of assembly routines with higher-level languages using standardized calling conventi

This project is a tutorial for developing a custom bare metal operating system specifically for the Raspberry Pi 4. It provides the guidance and resources necessary to write software that interacts directly with hardware without the use of a pre-existing kernel. The project centers on an ARM64 cross-compilation toolchain and a build pipeline that transforms source code into raw binary images. It utilizes linker scripts to define physical memory addresses and section placements, ensuring the resulting binary loads at the correct hardware entry point. The codebase covers direct hardware interf

This project is an educational resource for developing bare-metal operating systems and kernels from scratch on Raspberry Pi hardware. It provides a structured guide to systems programming using the Rust language, focusing on the implementation of core kernel components that execute directly on ARM-based hardware without the support of an underlying operating system or standard library. The tutorials emphasize a modular architecture that separates hardware-independent kernel logic from processor-specific and board-specific configurations. By utilizing a hardware abstraction layer and distinct

This project is a freestanding kernel written in Rust that boots on x86 hardware without a standard library. It serves as a low-level system implementation focusing on the creation of a bare metal operating system. The system implements a bootable disk image toolchain that transforms source code into binaries compatible with a bootloader. It features a custom memory allocator for dynamic memory management and an x86 kernel implementation that includes paging, interrupt handling, and VGA text mode. The project covers several core capability areas, including low-level memory management through

rpi4-osdev is a project for bare metal operating system development targeting the Raspberry Pi 4. It focuses on creating a custom operating system that runs directly on the hardware without an underlying kernel or abstraction layer. The project provides a codebase and instructional guide for developing a low-level system from scratch. This process involves transitioning from early boot code to kernel execution on the ARM64 architecture. The technical scope covers embedded system bootstrapping and low-level hardware interfacing. This includes managing memory-mapped I/O, physical address mappi

This project is an educational curriculum designed to teach the fundamentals of operating system development and low-level systems programming. It provides a structured sequence of lessons and code samples that guide users through building a functional kernel and bootloader from scratch, enabling a practical understanding of how software interacts directly with computer hardware. The repository distinguishes itself by focusing on the core mechanics of bare-metal execution. It covers the implementation of essential system components, including assembly-based bootloaders that transition process

Kotlin is a statically typed, general-purpose programming language designed for type safety and concise syntax. It functions as a cross-platform development toolkit that enables the sharing of business logic across mobile, web, and server-side environments by compiling a unified intermediate representation into platform-specific machine code, bytecode, or source code. The project distinguishes itself through a multi-target build orchestration model that manages complex compilation units and hierarchical source sets. Developers can define common interface logic that is satisfied by platform-sp

This project is a tutorial and framework for building a low-level, bare-metal operating system from scratch using the Rust language. It focuses on ARMv8 kernel development specifically for the Raspberry Pi 3, providing the resources necessary to implement a monolithic kernel that runs directly on hardware without an underlying operating system. The project distinguishes itself by providing a complete embedded cross-compilation suite within a containerized environment to ensure consistent builds. It includes a dedicated kernel deployer that uses a serial interface and chainloader to load and b

This project is a Lua-based firmware environment for the ESP8266 WiFi chip, providing an embedded Lua interpreter and a development framework for WiFi SoC hardware. It functions as a C-based wrapper around the Espressif non-OS SDK, enabling the execution of asynchronous scripts to manage wireless communication and hardware peripherals. The environment integrates a SPIFFS flash filesystem for storing persistent scripts and data directly on non-volatile memory. To optimize limited hardware resources, the system utilizes execute-in-place flash execution, running read-only constants and instructi

This project provides educational resources and technical guides for microcontroller firmware development. It focuses on writing low-level C code that runs directly on hardware without an underlying operating system, covering the fundamentals of hardware registers, memory mapping, and system clocks. The guides detail the creation of hardware abstraction layers to wrap raw memory-mapped registers into structured interfaces and provide walkthroughs for integrating TCP/IP stacks and HTTP servers into bare-metal environments. It also outlines the implementation of embedded systems build pipelines

Sensor-Watch is an open-source programmable replacement circuit board that transforms a classic digital watch into an extensible wrist-worn development computer. It functions as an embedded firmware development kit, providing the toolset needed to compile and install custom C software onto resource-constrained microcontrollers through a standard bootloader mechanism. The platform supports peripheral pin multiplexing to route analog, digital, and communication signals through a physical multi-pin expansion interface connected to the core processor. This enables the integration of custom perip

Grin is a compiler infrastructure designed for the translation and optimization of high-level functional languages. It functions as a graph-reduction compiler, transforming source code into a standardized intermediate representation that facilitates whole-program analysis and efficient execution across diverse hardware architectures. The project distinguishes itself through a modular backend infrastructure that separates intermediate representation management from target-specific code generation. By utilizing graph-based transformations, the system performs advanced optimizations such as valu

Emscripten is a WebAssembly toolchain and compiler backend that transforms C and C++ source code into WebAssembly bytecode. It serves as a framework for porting native applications and libraries to web browsers and server runtimes by translating LLVM intermediate representation into optimized WebAssembly modules. The system specializes in porting native graphical standards, such as OpenGL and SDL2, by mapping native graphics API calls to browser-compatible WebGL commands. This allows complex visual applications and native desktop software to be deployed as portable web formats. The toolchain

This project is a structured tracing framework for Rust that serves as an async-aware instrumentation library and telemetry data collector. It provides a structured logging facade and the tools necessary to record, filter, and route event-based diagnostic data from both standard applications and embedded systems. The framework distinguishes itself through a core implementation that supports bare-metal and no-standard-library environments without requiring a dynamic memory allocator. It specifically handles the complexities of asynchronous workflows by propagating diagnostic contexts across fu

Genesis World is an embodied AI simulation platform designed for training robotic agents through physics-based interactions. It centers on a multi-physics simulation engine that integrates rigid body, particle, and finite element method dynamics, supported by a parallel simulation kernel compiler that translates Python functions into optimized GPU and CPU kernels. The platform features a photorealistic robot renderer that utilizes path-tracing and Gaussian Splatting to generate synthetic training data. It includes a domain randomization framework to vary lighting and physical parameters acros

Pics is a comprehensive reference library providing visual documentation for binary file structures, character encodings, processor instruction sets, and hardware architecture maps. It serves as a centralized resource for the dissection and analysis of diverse binary formats, including executables, images, and archives. The project specializes in mapping complex specifications into visual layouts. This includes the creation of schematic diagrams to explain the physical and logical organization of hardware components and the maintenance of a catalog for processor opcodes across multiple hardwa

This project is a multi-language compiler collection and cross-platform toolchain used to translate source code from various programming languages into optimized machine code for different hardware architectures. It provides a suite of tools including an optimizing compiler backend, a machine code generator, and a comprehensive runtime library suite that implements necessary execution environments and support functions. The system utilizes a multi-pass compilation pipeline and pluggable language front-ends to process source code into intermediate representations. It distinguishes itself throu

Nim is a statically typed, compiled systems programming language designed for high performance and cross-platform development. It translates high-level source code into C, C++, or JavaScript, allowing developers to produce efficient native binaries or web-compatible scripts from a single codebase. The language emphasizes a clean, indentation-based syntax that simplifies code hierarchy while maintaining the power of a full-featured systems language. What distinguishes Nim is its robust metaprogramming framework, which allows developers to inspect, modify, and generate code structures during th

This project serves as an educational resource for learning and implementing low-level assembly language optimizations. It provides a structured guide for developers to master hardware-specific instructions and manual performance tuning, focusing on the translation of high-level code into efficient machine-level operations for resource-constrained environments. The materials emphasize techniques for maximizing computational throughput in multimedia processing. By covering instruction-level parallelism, register management, and data parallelism, the project enables the development of software