LEGACY DOCS · 12.2Stable is 13.2. This page stays because it still owns historical or unchanged contracts.CURRENT 13.2 →
RELEASE LINE13.2 HISTORICAL13.1 PREDECESSOR13.0 PREVIOUS12.4 NATIVE MIRARCHIVE

LEGACY DOCS · 12.2

PAGE ROLE · HOW-TO · EVIDENCE INDEX

DBYTE 12.2 MODERN NATIVE SEMANTICS

v12.2.0 owns the modern x86_64 native contracts. v12.2.1 repaired packaging for this line. v12.3.0 is current and keeps these native contracts while adding the flat VM and owned collections foundation.

New to 12.2? Read Native Targets first, then DBYTE64 ABI, then the runtime contract for the platform you care about.

READ BY GOAL

Install or verify the Windows packageINSTALL 12.2 · RELEASE EVIDENCE
Understand released native targetsMODERN NATIVE TARGET MATRIX · PLATFORM STATUS
Read the 64-bit DByte calling conventionDBYTE64 ABI
Read bare-metal and Linux contractsELF64 + MULTIBOOT2 · LINUX RUNTIME
Read Windows object and runtime contractsCOFF + PE32+ · WINDOWS RUNTIME

NATIVE DELTA: X86_64 NONE · X86_64 LINUX · X86_64 WINDOWS · ELF64 · COFF · PE32+ · DBYTE64

00 release identity§

Packagedbyte-v12.2.0-windows-x64.zip
Bytes3988552
Entries431
SHA-25603ee5aa21f77cfbf175b154f6ecf3f5c6be8e6b87bb1c1a55a6f9ef84f66a5f4
Tagv12.2.0 annotated
Commit74e4eaca8d8e1086770e8804c3707d301996afeb
Tree7a4cb341d8ec9583a86da14a60666a629741be2f

10 target contract§

i686-dbyte-none       retained
 i686-dbyte-user       retained
x86_64-dbyte-none     RELEASED · ELF64 · MULTIBOOT2
x86_64-dbyte-linux    RELEASED · STATIC ELF64 · SYSV AMD64
x86_64-dbyte-windows  RELEASED · AMD64 COFF · PE32+ · WIN64

The modern targets consume the same monomorphized Concrete HIR. Target adapters select layout, ABI and file formats; they do not re-run semantic analysis.

20 locked evidence§

Native suite296 passed in the locked release verification
Relocations before linkx86_64 none 190 · Linux 170 · Windows 175
Final unresolved relocations0
Windows import boundary8 allowlisted KERNEL32 functions · no CRT production dependency
C ABI probesSysV64 and Win64 callbacks, narrow values, mutable pointers, repr(C), stack arguments and alignment passed

30 runtime source boundary§

Corrected v12.2.0 and v12.2.1 packages include the versioned runtime tree. The separately published runtime source ZIP remains supplemental evidence, not the sole source of these package members.

[ LINUX SYSTEM ALLOCATOR SOURCE ] [ WINDOWS SYSTEM ALLOCATOR SOURCE ] [ RUNTIME SOURCE ZIP ]

linux_system_allocator.dbyDOWNLOADOPEN RAW
import "../v12.1.0/alloc.dby" as alloc

static mut SYSTEM: alloc.KernelAllocator

fn linux_mmap_raw(size: usize) -> i64:
    return linux.mmap(0 as usize, size, 3 as i32, 0x22 as i32, -1 as i32, 0 as usize)

fn linux_munmap_raw(address: usize, size: usize) -> i64:
    return linux.munmap(address, size)

fn copy_bytes(destination: ptr[u8], source: ptr[u8], count: usize) -> unit:
    let index: usize = 0 as usize
    while index < count:
        destination[index] = source[index]
        index = index + (1 as usize)
    return unit

fn provider_allocate(context: ptr[u8], size: usize, alignment: usize) -> Result[ptr[u8], alloc.AllocError]:
    if alloc.valid_alignment(alignment) == false:
        return Result[ptr[u8], alloc.AllocError].Err(alloc.AllocError.UnsupportedAlignment())
    let address = linux_mmap_raw(size)
    if address < (0 as i64):
        return Result[ptr[u8], alloc.AllocError].Err(alloc.AllocError.OutOfMemory())
    return Result[ptr[u8], alloc.AllocError].Ok(address as usize as ptr[u8])

fn provider_resize(context: ptr[u8], pointer: ptr[u8], old_size: usize, new_size: usize, alignment: usize) -> Result[ptr[u8], alloc.AllocError]:
    let replacement = provider_allocate(context, new_size, alignment)?
    let amount: usize = old_size
    if new_size < amount:
        amount = new_size
    copy_bytes(replacement, pointer, amount)
    if linux_munmap_raw(pointer as usize, old_size) != (0 as i64):
        linux_munmap_raw(replacement as usize, new_size)
        return Result[ptr[u8], alloc.AllocError].Err(alloc.AllocError.ContractViolation())
    return Result[ptr[u8], alloc.AllocError].Ok(replacement)

fn provider_free(context: ptr[u8], pointer: ptr[u8], size: usize, alignment: usize) -> unit:
    linux_munmap_raw(pointer as usize, size)
    return unit

pub fn system_allocator() -> alloc.AllocatorRef:
    return alloc.kernel_initialize(&SYSTEM, 0 as usize as ptr[u8], provider_allocate, provider_resize, provider_free)
DBY · 1.9 KiBSHA-256 6b871b75b039dafc11e5274d732662facb9bd446cdd6a9e9211b01133ac6bb11
windows_system_allocator.dbyDOWNLOADOPEN RAW
import "../v12.1.0/alloc.dby" as alloc

static mut SYSTEM: alloc.KernelAllocator

fn windows_virtual_alloc_raw(size: usize) -> usize:
    return windows.virtual_alloc(0 as usize, size, 0x3000 as u32, 4 as u32)

fn windows_virtual_free_raw(address: usize) -> i32:
    return windows.virtual_free(address, 0 as usize, 0x8000 as u32)

fn copy_bytes(destination: ptr[u8], source: ptr[u8], count: usize) -> unit:
    let index: usize = 0 as usize
    while index < count:
        destination[index] = source[index]
        index = index + (1 as usize)
    return unit

fn provider_allocate(context: ptr[u8], size: usize, alignment: usize) -> Result[ptr[u8], alloc.AllocError]:
    if alloc.valid_alignment(alignment) == false:
        return Result[ptr[u8], alloc.AllocError].Err(alloc.AllocError.UnsupportedAlignment())
    let address = windows_virtual_alloc_raw(size)
    if address == (0 as usize):
        return Result[ptr[u8], alloc.AllocError].Err(alloc.AllocError.OutOfMemory())
    return Result[ptr[u8], alloc.AllocError].Ok(address as ptr[u8])

fn provider_resize(context: ptr[u8], pointer: ptr[u8], old_size: usize, new_size: usize, alignment: usize) -> Result[ptr[u8], alloc.AllocError]:
    let replacement = provider_allocate(context, new_size, alignment)?
    let amount: usize = old_size
    if new_size < amount:
        amount = new_size
    copy_bytes(replacement, pointer, amount)
    if windows_virtual_free_raw(pointer as usize) == 0:
        windows_virtual_free_raw(replacement as usize)
        return Result[ptr[u8], alloc.AllocError].Err(alloc.AllocError.ContractViolation())
    return Result[ptr[u8], alloc.AllocError].Ok(replacement)

fn provider_free(context: ptr[u8], pointer: ptr[u8], size: usize, alignment: usize) -> unit:
    windows_virtual_free_raw(pointer as usize)
    return unit

pub fn system_allocator() -> alloc.AllocatorRef:
    return alloc.kernel_initialize(&SYSTEM, 0 as usize as ptr[u8], provider_allocate, provider_resize, provider_free)
DBY · 1.9 KiBSHA-256 76d8ab5e14523f872f6d2523725250af70bbcfb883984dcb244b82dc74ecdc34

40 release-line position

v12.2.1 is the packaging correction for this native foundation. v12.3.0 is current and links back here because the native target contracts remain owned by v12.2.

[ 12.2.1 PACKAGE FIX ] [ 12.4 CURRENT ] [ RELEASE LEDGER ]