Under active development

Systems programming, forged for control.

ForgeLang is a modern systems programming language being designed for predictable native performance, zero-cost abstractions, explicit memory behavior, strong compile-time guarantees, and close-to-the-metal control — without giving up modern language ergonomics.

Explore the language View development status

Target: first public alpha / initial public release window in Q1 2027, subject to engineering, validation, documentation, and legal readiness.

ForgeLang Development Snapshot Pre-Alpha

Current Build ForgeLang P0.6.2 + FNM 0.6

Native Pipeline Direct Typed IR + Forge backend

ForgeStd ≈ 48–50% broad API surface

Release Target Q1 2027

Current project maturity Core + native library foundations advancing

Core philosophy

Nothing hidden. Nothing paid for accidentally.

ForgeLang follows a systems-language discipline: abstraction should improve structure and safety without silently introducing allocation, reference counting, garbage collection, locks, metadata, or unpredictable runtime machinery.

“High-level clarity should compile down to low-level intent.”

The language is being shaped around explicitness, stable behavior, deterministic lifetimes, strong optimization opportunities, and an ABI model suitable for serious native software.

Zero-cost by default No hidden heap allocation, GC, locks, or runtime polymorphism unless explicitly requested.

Predictable memory Value semantics first, deterministic lifetimes, explicit ownership and borrowing concepts where needed.

Native interoperability A stable Forge ABI is planned, alongside a deliberate C-compatible interop mode for low-level integration.

Optimization-aware language design The compiler model is intended to expose useful alias, effect, ownership, and purity information to the optimizer.

What ForgeLang aims to be

A serious native language for software close to the machine.

The project is not intended as a scripting language or a managed runtime. Its long-term direction is operating systems, libraries, runtimes, networking, embedded software, compilers, tools, engines, and other performance-sensitive native applications.

Systems-level control

Data layout, ABI boundaries, memory ownership, unsafe operations, low-level pointers, and platform interfaces should remain visible and controllable when the programmer needs them.

Modern safety

Strong compile-time diagnostics and constrained mutation are being designed to reduce common memory and correctness failures without requiring a mandatory managed runtime.

Simple deployment

The package and library model is planned around one manifest, one lockfile, straightforward dependency resolution, and minimal include/linker configuration burden.

Toolchain independence

ForgeLang is being developed around the Forge toolchain and ForgeAssembler direction rather than making LLVM a mandatory foundation.

Stable interoperability

The language is intended to integrate with existing native ecosystems, especially C ABI environments, while establishing a versioned Forge ABI for long-term language-native compatibility.

Performance regression discipline

New language and library features are expected to justify their runtime, allocation, binary-size, and compilation impact through benchmarks and regression gates.

Language preview

Designed to read clearly while preserving machine-level intent.

These examples are aligned with the currently implemented ForgeLang P0.6.2 / FNM 0.6 syntax. The language is still pre-alpha, so details may continue to evolve.

module main

fn main() -> i64 {
    let iterations: i64 = 50000000
    var total: i64 = 0

    for i in 1..=iterations {
        total += i
    }

    println("ForgeLang native execution")
    println("Iterations : ", iterations)
    println("Total      : ", total)

    return 0
}

module main

nuc Counter {
    state {
        value: i64 = 0
    }

    action increment() {
        value += 1
    }

    query get() -> i64 {
        return value
    }
}

fn main() -> i64 {
    var counter = Counter()
    counter.increment()
    counter.increment()

    println("FNM counter = ", counter.get())
    return counter.get() - 2
}

module ffi_demo

pub extern C struct Pair {
    a: i64
    b: i64
}

// Imported C ABI function.
extern C fn imported_seed() -> i64

// ForgeLang definition exported through the C ABI.
export C fn add(a: i64, b: i64) -> i64 {
    return a + b
}

Current pre-alpha examples. Standard I/O uses native print/println; C interoperability uses explicit extern C/export C boundaries.

Forge Nucleus Model

A composition-first alternative to classic class hierarchies.

One of ForgeLang's experimental core directions is the Forge Nucleus Model (FNM): a value-oriented model that separates state, mutation, queries, capabilities, and composition without requiring inheritance or implicit virtual dispatch.

nuc Counter {
    state { value: i64 = 0 }
    action increment() { value += 1 }
    query get() -> i64 { return value }
}

Current FNM 0.6 core syntax: sealed state, explicit mutation through actions, non-mutating queries, structural contracts, compile-time composition, and explicit dynamic contracts only when requested.

Development status

The architecture is defined; the language is still being completed and hardened.

ForgeLang remains a pre-alpha engineering project. The current working line is ForgeLang 0.6.2-p0.6.2+fnm0.6, with ForgeStd continuing to expand while compiler, ABI, diagnostics, portability, and performance-regression gates are hardened.

Major areas already taking shape

✓Native compilation direction and ForgeAssembler integration.
✓Core numeric types, control flow, functions, literals, and low-level execution model.
✓Performance-focused compiler work and benchmark-driven optimization.
✓Native memory, ownership, borrowing, allocator, and deterministic-lifetime foundations.
✓Forge Nucleus Model 0.6 core with static/dynamic contracts and zero-cost optimization metadata.
✓ForgeStd foundations for text, vectors, ranges/algorithms, Option/Result, memory, and associative collections.

Current pre-alpha priorities

→Complete the core language specification and remove semantic gaps.
→Expand the standard library into a broad systems-programming foundation.
→Lock down ABI, FFI, package, module, and library behavior.
→Increase diagnostics quality, editor intelligence, and developer documentation.
→Run strict correctness, safety, performance, and regression testing.
→Prepare licensing, legal review, public repository structure, and alpha distribution.

Roadmap to public release

Engineering first. Public release when the foundation is ready.

The roadmap is intentionally conservative. Dates are targets, not promises, and may move if correctness, performance, documentation, portability, or legal readiness requires more work.

Language-core completion

Finalize essential syntax, type semantics, ownership/reference rules, error handling, module behavior, low-level features, and FNM foundations.

Standard-library expansion

Build a practical systems baseline covering strings, containers, memory, algorithms, I/O, files, time, concurrency foundations, platform interaction, diagnostics, and other core facilities.

ABI, packages, and interoperability

Stabilize Forge ABI concepts, C interoperability, modules, package metadata, dependency resolution, and editor/build integration.

Hardening and validation

Stress-test compiler correctness, generated code, performance, memory safety, diagnostics, optimization regressions, and cross-platform behavior.

Public alpha target — Q1 2027

Publish the project when the language, toolchain, documentation, licensing, and legal preparation are sufficiently mature for serious external testing.

Creator

Founded by Ayman Alheraki.

ForgeLang is an independent long-term systems programming project built from decades of practical interest in programming languages, compilers, assembly, C, C++, native software, and low-level tooling.

Ayman Alheraki Founder of ForgeLang and the Forge toolchain

Ayman Alheraki began programming in the 1980s and has worked across BASIC-era home computers, Pascal, x86 assembly, C, C++, web software, and modern native-development environments. His interest in building a new programming language dates back to around the year 2000.

ForgeLang grew from that long-term goal: create a systems language that keeps the performance discipline and low-level relevance of C-class programming, while offering a cleaner modern model for safety, abstraction, tooling, libraries, and large-scale software design.

The project is being developed independently as part of a broader Forge ecosystem that includes ForgeAssembler and ForgeEditor.

Development updates

This website will evolve with the language.

New milestones, syntax decisions, compiler improvements, standard-library components, benchmarks, documentation, tooling changes, and release information will be published here as ForgeLang moves toward its public alpha.

Important: ForgeLang is not yet a stable released language. Any syntax, API, feature, benchmark, performance result, ABI detail, roadmap item, or release date shown on this website should be treated as provisional until formally published as part of a versioned release.