Intelligent assemblers
Validated encoding, precise diagnostics, architecture rules, reusable machine descriptions, and an assembler-centered intermediate layer.
Assembler-first compiler infrastructure
Build the layer between source languages and machine execution.
ForgeVM is a focused systems project for intelligent assemblers, machine-aware optimization, linking, debugging, binary tooling, compiler support, and first-class WebAssembly workflows.
Target architectureFocused pipeline01
Language and low-level inputsC, C++, Rust, Zig, new languages, and explicit assembly
↓
02
Intelligent assembler coreEncoding, validation, diagnostics, machine-aware IR, and optimization
↓
03
Executable outputsNative objects, linked binaries, analysis artifacts, and WebAssembly modules
Project discipline Tools, releases, tests, and reproducible results take priority over expanding the website into unrelated topics.
Core workstreams
A compact toolchain mission.
ForgeVM concentrates on connected engineering layers instead of becoming a general programming portal.
Machine-aware optimization
Optimization close to the final instruction stream, with measurable effects on size, speed, layout, and target behavior.
Linking and binary tools
Object generation, linking, relocation, executable formats, disassembly, debugging, and binary inspection.
WebAssembly infrastructure
A strong path between low-level toolchains and modern web execution, with optimization and diagnostics built in.
Current engineering catalog
All tools →Tools before content volume.
Published tools and prototypes are the primary evidence of project progress.
LLInfra: Low-Level Software Infrastructure for the Next Era
LLInfra builds modern low-level infrastructure from scratch in C++20/23. It features a multi-architecture 64-bit assembler for x86-64, ARM64, and RISC-V with latest extensions, plus a linker, minimal runtime, C compiler with SSA backend, and bare-metal kernel. Free from legacy baggage, it offers a clean foundation for researchers and developers seeking to deeply understand low-level systems.
Planningx86, x86-64
Open tool →First-class WebAssembly
WebAssembly strategy →Treat the web as a serious systems target.
WebAssembly is designed into the architecture rather than added later as an export format.
Shared lower-level representation
Explore how assembler-oriented structures can support both native encodings and WebAssembly instruction streams without hiding machine intent.
Optimization before delivery
Apply validation, simplification, layout, and target-specific optimization before a module reaches the browser or runtime.
Developer-grade diagnostics
Make binary-level and WebAssembly errors understandable to compiler authors, systems programmers, and language designers.
Staged execution
Detailed roadmap →A narrow path from assembler core to compiler ecosystem.
Each phase must produce verifiable artifacts before the next layer expands.
x86-64 assembler foundation
Machine descriptions, instruction encoding, validation, diagnostics, object emission, and comprehensive tests.
Optimizer and linker layer
Instruction-level transformations, layout, relocation, object composition, executable generation, and binary inspection.
WebAssembly toolchain
Module production, analysis, optimization, native interoperability, and browser-oriented development workflows.
Language and architecture expansion
Compiler interfaces, C/C++/Rust/Zig support, language design tools, ARM/AArch64, and RISC-V.
Verified delivery
All releases →Latest ForgeVM releases.
Only published builds and documented milestones appear here.
No public releases yet
The release archive will begin with the first verified public ForgeVM build.
Engineering notes
All articles →Research that supports implementation.
Articles explain architecture decisions, experiments, formats, optimization, and integration work.
From the FPU to the GPU: Where Are Floating-Point Computing and Modern Processors Heading?
Floating-point computing has evolved from scalar FPU operations to SIMD vectors, massively parallel GPUs, and specialized matrix and tensor engines. Modern processors combine CPUs, GPUs, NPUs, and accelerators, using mixed precision to balance speed, accuracy, and energy. The future is heterogeneous computing focused on both increasing performance and reducing costly data movement.
Read article →ABI: The Binary Contract Behind Compilers and Operating Systems
An ABI is the binary contract that lets compilers, libraries, runtimes, and operating systems work together. It defines calling conventions, register use, stack layout, data representation, symbols, linking, loading, and system calls. C remains the preferred ABI language because its simple, explicit model enables stable, portable interfaces across compilers and programming languages.
Read article →Why Learning GAS Gives You Broad Assembly Power
GAS is a powerful assembler because it supports many CPU architectures through GNU Binutils, including x86, ARM, RISC-V, MIPS, and PowerPC. On x86, it supports both Intel and AT&T syntax. GAS works closely with GCC, Clang, GDB, `ld`, `objdump`, and `readelf`, making it ideal for systems programming, compilers, operating systems, cross-compilation, and low-level development.
Read article →Focused references
All books →Books that support the project domain.
Books remain a supporting knowledge layer, not the center of the website.
Introduction to x86-64 Architecture and Memory
This booklet explains how x86-64 processors execute software under Linux. It covers instructions, registers, pipelines, caches, memory, paging, privilege levels, interrupts, and debugging tools. By distinguishing architecture from microarchitecture, it helps programmers, engineers, researchers, and students understand, analyze, secure, and optimize modern systems with confidence.
175 pages
View book →Assembly Programming with GAS (Intel Syntax)
Assembly reveals how processors, memory, operating systems, and performance truly work. This second volume introduces x86-64 assembly on Linux using GAS with Intel syntax, covering assembling, linking, memory layout, calling conventions, functions, and high-level language interoperability through clear, practical, testable examples.
172 pages
View book →Linux System Calls and Process Control
This booklet explains Linux system calls and process control directly in x86-64 assembly, without libc or high-level abstractions. It covers kernel interfaces, registers, processes, signals, environments, memory, and execution, then builds a minimal working shell. It is designed for readers seeking a precise foundation in Linux systems programming, debugging, performance, and runtime design.
121 pages
View book →Project focus
ForgeVM.org exists to support tool development, technical releases, and the research directly required to build them.
Books and articles remain valuable, but they are organized as supporting resources around the assembler-first compiler infrastructure mission.