Zero to useful

FAST PATH: extract → verify → run one hosted file → inspect it → then choose VM/native work. Do not begin with kernel proofs unless that is your target.

01 install + verify§

COMMAND · WINDOWS POWERSHELL · V12.0.0 HOST PACKAGE

$Zip = ".\\dbyte-v12.0.0-windows-x64.zip"
(Get-Item $Zip).Length
(Get-FileHash $Zip -Algorithm SHA256).Hash

# expected bytes
3196504

# expected SHA-256
83F9DE1E1116EBFE0FC0A4B24338909FFAB39142D4171B0B9364A51727D5E4D2

The published binary host package is Windows x64. The v12 contract does not claim a Linux or macOS host release, and it does not claim an x86_64 application backend.

02 first source file§

RUNNABLE · WINDOWS X64 · EXACT RELEASE FIXTURE

print("Hello, DByte!")

Expected output from the exact release-bundle examples/hello.dby:

Hello, DByte!

03 run it§

RUNNABLE · TREE + VM · EXPECT EXACT STDOUT

dbyte --version
dbyte run examples\\hello.dby
dbyte run --vm examples\\hello.dby

The first command establishes binary identity. The next two exercise hosted execution surfaces. Backend parity is a release requirement, but a single hello-world run is only a smoke test.

04 inspect language shape§

Continue with language basics before generics/ownership. Then use the v12 language tour for canonical-HIR features.

05 first useful byte task — exact release example§

RUNNABLE · WINDOWS X64 · HOSTED COMPATIBILITY · EXACT RELEASE-BUNDLE EXAMPLE

The v12.0.0 release already ships a self-contained byte patcher. It creates its own six-byte input file, finds DE AD BE EF, replaces it with four 90 bytes, saves the patched file, then reads it back. No external firmware.bin is required.

MIRRORED EXACT SOURCE · source SHA-256 7ae37b406b792bc3c091e0b58939d59021ba5342e031ac7d0eab65e5dc85a8e6

import std.buffer as buf
import std.encoding as enc
import std.fs as fs

let input_path: str = "example_firmware.bin"
let output_path: str = "example_firmware.patched.bin"

fs.write_bytes(input_path, b"\x00\xDE\xAD\xBE\xEF\x00")

let image: buffer = buf.load(input_path)
let offset: int = buf.find(image, b"\xDE\xAD\xBE\xEF")

if offset >= 0:
    buf.replace(image, offset, b"\x90\x90\x90\x90")
    buf.save(output_path, image)
    print("patched", offset)
else:
    print("pattern not found")

let patched: bytes = fs.read_bytes(output_path)
print(enc.hex_encode(patched))

import std.buffer as buf
import std.encoding as enc
import std.fs as fs

let input_path: str = "example_firmware.bin"
let output_path: str = "example_firmware.patched.bin"

fs.write_bytes(input_path, b"\x00\xDE\xAD\xBE\xEF\x00")

let image: buffer = buf.load(input_path)
let offset: int = buf.find(image, b"\xDE\xAD\xBE\xEF")

if offset >= 0:
    buf.replace(image, offset, b"\x90\x90\x90\x90")
    buf.save(output_path, image)
    print("patched", offset)
else:
    print("pattern not found")

let patched: bytes = fs.read_bytes(output_path)
print(enc.hex_encode(patched))

Run§

COMMAND · WINDOWS POWERSHELL · FROM EXTRACTED V12.0.0 RELEASE ROOT

dbyte run .\examples\binary_patcher.dby

The source writes example_firmware.bin and example_firmware.patched.bin in the current working directory.

Artifact gate§

Get-FileHash .\example_firmware.bin -Algorithm SHA256
Get-FileHash .\example_firmware.patched.bin -Algorithm SHA256
Format-Hex .\example_firmware.bin
Format-Hex .\example_firmware.patched.bin

These hashes are deterministic expectations computed from the exact byte sequences written by the shipped source. The website build did not execute the Windows binary; runtime authority remains the user's observed run on the supported Windows x64 package.

This remains a HOSTED COMPATIBILITY surface. Shipping the example does not redefine std.buffer/std.fs as new canonical-HIR API design.