Under active development

Native assembly, without needless friction.

ForgeAssembler is a modern assembler and low-level systems tool designed to preserve direct machine control while adding structured procedures, compiler-aware assistance, optimization guidance, ABI awareness, and a cleaner path from human intent to native machine code.

Explore the syntax View development status

ForgeAssembler is being developed as a core part of the Forge ecosystem and as the low-level foundation beneath ForgeLang.

ForgeAssembler Development Snapshot Pre-Release

Primary Target x86-64 native systems

Architecture Low + structured assembly layers

Design Goal Control with compiler intelligence

Ecosystem Role ForgeLang backend foundation

Current maturity Core assembler systems are well advanced

Core philosophy

Keep the machine visible. Improve everything around it.

ForgeAssembler does not try to hide assembly language. Its purpose is to make low-level programming more structured, analyzable, optimizable, and productive while preserving explicit registers, instructions, memory, calling conventions, object layout, and native execution.

“Assembly should remain explicit — but the tool should be intelligent.”

The assembler is designed to understand more about programmer intent than a traditional text-to-opcode pipeline, enabling stronger diagnostics, smarter suggestions, ABI checks, structured functions, and optimization opportunities without turning assembly into a hidden virtual machine.

Explicit native control Registers, instructions, memory addressing, sections, symbols, and calling conventions remain visible and intentional.

Structured where it helps Functions, local structure, semantic hints, and higher-level assembly constructs can improve clarity without hiding generated code.

Compiler-aware behavior The toolchain is intended to reason about instruction choices, register use, code size, cycles, ABI rules, and optimization opportunities.

No mandatory LLVM or GNU foundation ForgeAssembler is being built as an independent Forge toolchain component rather than as a thin wrapper around another compiler infrastructure.

What makes it different

Traditional assembly power with modern toolchain intelligence.

ForgeAssembler is intended for programmers who want deterministic machine code and direct native control, but also want the assembler to understand more than syntax alone.

Low-level mode

Direct instruction-level assembly remains a first-class path for exact control over registers, opcodes, data, sections, symbols, and layout.

Structured functions

Procedure-oriented constructs are designed to reduce boilerplate while keeping calling conventions, stack behavior, and emitted code inspectable.

Optimizer guidance

The assembler can evolve beyond passive translation by identifying instruction sequences, code-size tradeoffs, and performance opportunities.

ABI awareness

Calling conventions and C-compatible interoperability are important design targets so native assembly can integrate cleanly with system libraries.

Native object generation

ForgeAssembler is being built as a real native toolchain component with object-format and linker integration rather than only producing textual assembly.

ForgeEditor integration

The surrounding editor is being adapted specifically for ForgeAssembler with diagnostics, symbols, help, build/run workflows, and low-level views.

Syntax preview

From raw instructions to structured native functions.

The examples below illustrate the intended direction. Exact syntax, directives, reserved words, and file conventions may continue to evolve before the first public release.

; Development-preview ForgeAssembler syntax

section .data
message:    db "ForgeAssembler", 0

section .text
global main

main:
    mov     rax, 1
    mov     rbx, 2
    add     rax, rbx
    imul    rax, 3

    xor     eax, eax
    ret

; Conceptual structured-function preview

func sum_i64(a: i64, b: i64) -> i64
{
    mov rax, a
    add rax, b
    return rax
}

func main() -> i32
{
    call sum_i64(40, 2)
    return 0
}

; Conceptual native C ABI interoperability

extern "C" printf

section .rodata
fmt: db "Result: %lld", 10, 0

func main() -> i32
{
    mov rax, 42

    ; ABI-aware call sequence generated or validated by the toolchain
    call printf(fmt, rax)

    return 0
}

Preview only. The final syntax, calling conventions, structured-function model, object directives, and optimizer behavior remain subject to change.

Optimizer and clever behavior

An assembler that can reason — without stealing control.

A major ForgeAssembler goal is to provide compiler-like intelligence at the assembly level while keeping every transformation visible, explainable, optional where appropriate, and measurable.

Instruction analysis

Detect inefficient sequences, redundant moves, avoidable dependencies, and equivalent instruction choices.

Speed / size strategies

Allow optimization decisions to target execution speed, binary size, or balanced native code generation.

Register-aware suggestions

Provide useful diagnostics around register pressure, clobbers, calling conventions, and data movement.

Vectorization opportunities

Where the pattern is clear, the toolchain can surface SIMD/vectorization opportunities rather than silently rewriting intent.

ABI validation

Catch stack, parameter, return-value, alignment, and preserved-register mistakes before they become runtime bugs.

Explainable transformations

The long-term direction is to make optimization advice inspectable so programmers can understand why a change is proposed.

Development status

The assembler core exists; the surrounding production toolchain is still being hardened.

ForgeAssembler has progressed through low-level and more structured assembly work, native object generation, optimizer experiments, and ForgeEditor integration. The current effort is centered on completeness, diagnostics, portability, correctness, and release quality.

Major areas already established

✓x86-64 assembly foundation and native instruction encoding direction.
✓Low-level and structured/mid-level assembly concepts.
✓Function/procedure model and compiler-clever behavior direction.
✓Native object-file generation work, including real ELF64 writer stages.
✓ForgeEditor transition from generic assembler support toward ForgeAssembler-specific tooling.
✓Use as a foundational backend direction for ForgeLang.

Current priorities

→Finalize syntax, diagnostics, reserved words, directives, and language reference.
→Strengthen optimizer correctness and performance regression testing.
→Harden ABI, object-format, linker, debug, and platform integration.
→Improve ForgeEditor help, symbols, machine-code views, build advisor, and debugging workflow.
→Expand test suites for instruction encoding, edge cases, object validity, and executable generation.
→Prepare formal documentation, licensing, packaging, and public release infrastructure.

Roadmap

From advanced prototype to production-grade native tool.

The release sequence prioritizes correctness and toolchain trust. Assembly tooling must produce predictable bytes, valid objects, valid executables, and transparent diagnostics before convenience features are considered finished.

Core syntax and encoding lock-down

Finalize instruction parsing, directives, structured syntax, symbols, data declarations, and deterministic encoding behavior.

Object and linker hardening

Validate native object formats, relocations, symbol tables, executable generation, and platform-specific ABI behavior.

Optimizer and diagnostics maturity

Expand optimization advice, speed/size strategies, register analysis, vectorization proposals, warnings, and error quality.

ForgeEditor production integration

Complete ForgeAssembler-aware editing, documentation, build/run, code inspection, diagnostics, templates, and tooling workflows.

Public release preparation

Publish when documentation, test coverage, licensing, packaging, legal review, and Forge ecosystem integration are ready for serious external use.

Founder

Founded by Ayman Alheraki.

ForgeAssembler is an independent low-level systems project created from decades of practical interest in assembly language, native software, C and C++, compilers, performance, and systems programming.

Ayman Alheraki Founder of ForgeAssembler and the Forge ecosystem

Ayman Alheraki began programming in the 1980s and later worked with x86 assembly, C, C++, and native systems development. His long-term interest in building independent programming tools ultimately grew into the Forge ecosystem.

ForgeAssembler was created as more than a replacement syntax for existing assemblers. Its goal is to preserve the precision and transparency of native assembly while introducing structured functions, stronger diagnostics, optimization intelligence, ABI awareness, and modern tooling.

It also serves as a strategic foundation for ForgeLang, allowing the language and its compiler toolchain to remain closely connected to native machine code without requiring LLVM as the core backend.

Development updates

This website will evolve with ForgeAssembler.

New syntax decisions, instruction support, optimizer capabilities, object writers, ABI improvements, ForgeEditor integration, documentation, benchmarks, and release information can be published here as development progresses.

Important: ForgeAssembler is still under active development. Syntax, optimizer behavior, diagnostics, object-format support, structured-function rules, file conventions, benchmarks, and release plans shown on this website should be treated as provisional until published in a versioned release.