Skip to content

Release Notes

Changes to HyperAccel Runtime (hart). For changes across the whole stack, see the SDK release notes.


0.0.6 — 2026-11-16

Version: 0.0.6. Requires Python 3.10 or later.

Migration (Breaking Changes)

Kernel launch arguments unified into HaLaunchArgs

Kernel arguments are no longer passed as a pointer array but as one argument list object. Each argument records its kind and data type, so if it does not match what the kernel expects, the launch is rejected with HaKernelInvalidArgument instead of being silently misread. For usage, see the C++ and Python references.

Area Before 0.0.6
C++ launch HaLaunchKernel(path, args, args_count)
HaLaunchKernelAsync(path, args, args_count, stream)
HaLaunchKernel(path, args)
HaLaunchKernelAsync(path, args, stream)
args is an HaLaunchArgs object
C++ argument list creation and release ha_launch_args.h from 0.0.5:
HaLaunchArgsCreate() / HaLaunchArgsAddTensor() / HaLaunchArgsGet() / HaLaunchArgsDestroy()
Header removed
Create an HaLaunchArgs object directly and pass it to the launch function
Released automatically when destroyed; move-only
C++ adding arguments List value addresses in a pointer array HaLaunchArgsAddTensor() / HaLaunchArgsAddScalar() / HaLaunchArgsAddArray()
C++ call instrumentation structs args and args_count fields of HaLaunchKernelParams / HaLaunchKernelAsyncParams Removed
Python launch Pass a list to launch_kernel*() Pass a hart.HaLaunchArgs to launch_kernel*(). Passing a list raises TypeError
Python arguments LegatoTensorArg, LegatoScalarArg, LegatoArrayArg, LegatoTupleArg, LegatoArgKind, LegatoDataType add_tensor() / add_scalar() / add_array()
Python repeated launches Edit the fields of argument records directly set_tensor() / set_scalar_bits() / set_array() (C++: HaLaunchArgsSet*())
  • Arguments are checked against the calling thread's current device when added, so call HaSetDevice() first.
  • Header locations are as follows. Including ha_runtime_api.h brings in all of them. - Argument functions (HaLaunchArgsAdd*(), HaLaunchArgsSet*()): ha_runtime_api.h - HaLaunchArgs: ha_driver_types.h - HaLaunchArgRoute: ha_types.h
  • Float64 (Python: FLOAT64) was added to HaDataType.

Driver API overhaul

The driver API was reorganized into a public, device-handle-based API. Every call names a device handle, kernels are loaded and launched by handle, and data transfers and launches are enqueued asynchronously on streams. For detailed usage, see the Driver API Guide and the Reference.

Before 0.0.6
ha_drv_t HaDrvDev
ha_drv_ctl(HA_CTL_CLOSE) / ha_drv_ctl(HA_CTL_RESET) ha_drv_close() / ha_drv_reset()
ha_drv_get_attrs() ha_drv_get_attr() (reads one attribute at a time)
ha_drv_default_stream() HA_STREAM_DEFAULT as the stream argument (the calling thread's default stream)
ha_drv_submit_launch() Load with ha_drv_kernel_load_from_file() / ha_drv_kernel_load_from_library(), launch with ha_drv_kernel_launch(), release with ha_drv_kernel_release()
Pointer-array arguments of ha_drv_kernel_launch() const HaLaunchArgs &, filled with ha_drv_launch_args_add_*() / ha_drv_launch_args_set_*(), which check against the given device
ha_drv_memcpy_nd() Gains a stream argument. Like ha_drv_memcpy(), asynchronous on every stream including HA_STREAM_DEFAULT
HA_WAIT_QUERY / HA_WAIT_SYNC of ha_drv_wait() Gains an event argument and out_synced_seq. Wait kinds are HA_WAIT_STREAM_* / HA_WAIT_EVENT_* / HA_WAIT_DEVICE_SYNC

The following functions were added.

Function Description
ha_drv_deinit() Releases every device initialized by ha_drv_init() along with its streams, events, kernels, and memory
ha_drv_is_ready() Checks that the handle is valid and the device has not been torn down
ha_drv_get_device_id() Returns the hardware device index the handle was opened with
ha_drv_stream_post() Enqueues copy, deferred free, file load, marker, sampling, and event operations on a stream
ha_drv_init_tlb() Initializes the TLB with the KV cache geometry (EVT0)
ha_drv_configure_tlb() Configures the TLB. Every configuration invalidates the TLB cache (EVT1)
ha_drv_set_page_table_range() Sets the base address and size of the page table (EVT1)
ha_drv_flush_tlb() Invalidates the entire TLB cache (EVT1)

Other additions and changes:

Area Details
Now supported Driver events (HA_OBJ_EVENT). Previously returned HaDeviceUnsupported
Added error codes HaDeviceBusy
HaKernelInvalidHandle
Type header Split out into ha_driver_types.h, included by ha_driver_api.h
Type names Renamed to the HaDrv* convention: HaDrvDev, HaDrvDevAttr, HaDrvObjKind, HaDrvWaitKind, HaDrvEvent, HaDrvKernel, HaDrvStreamOp*, HaDrvHostMem*

Other API changes

Item Before 0.0.6 (replacement)
Launch by kernel id C++: HaLaunchKernel(kernel_id, …)
Python: launch_kernel()
Removed. Launch by binary path or kernel handle (Execution Model)
Device attribute names C++: kHaDevAttrPciBus and so on Scoped names such as HaDeviceAttr::PciBus (enum class)
Python names unchanged
TLB type header #include "ha_tlb_types.h" #include "ha_types.h". Also included through ha_runtime_api.h
VMM header #include "vmm.h" #include "ha_vmm.h"
Profiler hooks HaProfiler*, HaProfileEvent, and so on Removed from the public API. Use the HyperAccel Profiler

New Features

Kernel library and handle launch

Kernels can be looked up and launched by name instead of by file path. Register a kernel library, get a kernel handle by name, and launch it; the first time a kernel is launched on a device, the build for that device's chip generation is loaded. For details, see the Execution Model.

Area Added
Runtime API HaLibraryLoadData(), HaLibraryGetKernel()
HaLaunchKernel(HaKernel_t, …), HaLaunchKernelAsync(HaKernel_t, …)
Python library_load_data(), library_get_kernel()
launch_kernel_with_handle(), launch_kernel_async_with_handle()
Driver API ha_drv_library_load_data(), ha_drv_library_get_kernel(), ha_drv_library_kernel_name()
ha_drv_kernel_load_from_library()
Types HaLibrary_t, HaKernel_t
Error codes HaKernelNoBinaryForDevice (the library has no build for the device's chip)
HaKernelLoadFailed (loading failed for a reason other than running out of kernel memory)
Call instrumentation structs HaLibraryLoadDataParams added
HaLaunchKernelParams / HaLaunchKernelAsyncParams (kernel and kernel_name instead of by_id and kernel_id)

Device memory statistics

An API that queries the memory usage of the current device was added. It returns, in one call, the amount the runtime pool has allocated and holds, the peak of each, and the free DRAM of the whole device, and it can also reset the peaks or return the memory the pool holds but no longer uses. For details, see Memory Statistics & Trim in the Memory Model.

Area Added
Runtime API HaDeviceMemGetStats(), HaDeviceMemResetPeakStats(), HaDeviceMemTrim()
struct HaDeviceMemStats
Python device_mem_get_stats(), device_mem_reset_peak_stats(), device_mem_trim()
Driver API ha_drv_device_mem_get_stats(), ha_drv_device_mem_reset_peak_stats(), ha_drv_device_mem_trim()
Environment variables HA_DEVICE_MEM_STATS_PRINT=1 (also print to standard error on each query)
HA_MEM_STATS_PRINT=1 (turn on both host and device statistics output)

Host memory manager

A device-independent, per-process host memory manager was added. It reuses freed memory and applies a limit to the host memory the process obtains. For details, see Host Memory in the Memory Model and Host Memory in the Driver API Memory Model.

Area Added
Runtime API HaHostMemAlloc(), HaHostMemFree(), HaHostMemGetStats(), HaHostMemResetPeakStats(), HaHostMemTrim()
Python host_mem_alloc(), host_mem_free(), host_mem_get_stats(), host_mem_reset_peak_stats(), host_mem_trim()
Driver API ha_drv_host_mem_alloc(), ha_drv_host_mem_free(), ha_drv_host_mem_get_stats(), ha_drv_host_mem_reset_peak_stats(), ha_drv_host_mem_trim()
Error code HaHostMemLimitExceeded (an allocation was rejected because of a configured limit)
Running out of system memory is still HaMemoryAllocationFailed
Environment variables HA_HOST_MEM_MAX_BYTES (upper limit of host memory the process obtains)
HA_MEMCPYND_STAGING_MAX_BYTES (upper limit of multi-dimensional copy staging buffers)
HA_HOST_MEM_STATS_PRINT=1 (also print to standard error on each query)

Device attribute Version added

Version, which identifies the chip generation, was added to the device attributes (HaDeviceAttr). Its value is an HaDeviceVersion.

Language Call
Python get_device_attribute(HaDeviceAttr.VERSION, device_id)
C++ HaGetDeviceAttribute(&value, HaDeviceAttr::Version, device_id)

Changes

  • The minimum remainder when the Small pool splits a block can be set with HA_SMALL_POOL_MIN_SPLIT_REMAINDER_KB. The default is 512 KiB.
  • HaError moved to its own header, ha_error_code.h. ha_types.h includes this header, so existing code needs no change.

Fixes

  • Core route core number check — Fixed launches that succeeded with a nonexistent core number and silently dropped that argument. It is now rejected with HaKernelInvalidArgument both when the argument is added and at launch.
  • Thread safety of argument lists — Fixed undefined behavior when one argument list was shared across threads. Adding, replacing, and launching may now overlap safely. Do not move or destroy a list while another thread is using it.

0.0.5 — 2026-10-14

Version: 0.0.5. Requires Python 3.10 or later.

New Features

Virtual memory API for the KV cache

A virtual memory API (vmm.h) for the Bertha DC EVT0 KV cache was added. It wraps the hardware TLB. For the call order, see Virtual Memory & HW Pages in the Memory Model; for each function, see the VMM API.

Area Added
Pools HaVmmAllocatePool(), HaVmmFreePool()
structs HaVmmBlockSegment, HaVmmPool
Initialization and teardown HaVmmInitBlocks(), HaVmmDeinit()
Address reservation HaVmmReserveBlocks() (returns the VA spacing between blocks in out_block_stride_bytes)
Per-request page mapping HaVmmMapBlocksBatchFromPool(), HaVmmMapBlocksBatchFromPools(), HaVmmUnmapBlocksBatchFromPool()

Legato argument array helper API

A C++ helper API (ha_launch_args.h) that builds the argument array of a Legato kernel was added.

  1. Create a list with HaLaunchArgsCreate().
  2. Add Tensor arguments with HaLaunchArgsAddTensor(). HaLaunchArgRoute selects the block an argument is written to.
  3. Get the pointer array and count with HaLaunchArgsGet() and pass them to HaLaunchKernel(path, args, args_count).
  4. Release the list with HaLaunchArgsDestroy().

Other additions

  • HaDeviceSynchronize() — Waits until all streams of the current device finish. Use it when you need to wait for other threads' work, which HaStreamSynchronize(HA_STREAM_DEFAULT) cannot do because each thread has its own default stream.
  • Weight Converter API — Converts weight tensors to the device memory layout of the target architecture. C++ uses weight_converter/ha_weight_converter.h and the CMake target hart::ha_weight_converter; Python uses the hart.weight_converter module (C++, Python).

Changes

  • Legato kernel launch merged — Legato kernels are also launched with launch_kernel_with_binary_path() (C++: HaLaunchKernel()). launch_legato_kernel() and launch_legato_kernel_async() were removed.
  • PyTorch KV cache operators — vmm_init_blocks, vmm_map_blocks_batch, vmm_unmap_blocks_batch, and so on go through the VMM API instead of calling the TLB functions directly. vmm_init_tlb, vmm_alloc_tlb_page, and vmm_dealloc_tlb_page, which handle the TLB directly, are unchanged.
  • stream_query() — In Python, returns False instead of raising while work is in progress, and True when it has finished. It raises only on a runtime error.
  • Profiling coverage — Profiling now also covers asynchronous entry points and HaMemCpyNd(), so those spans no longer appear empty in traces of stream-based pipelines.
  • Log level — In release builds, an HA_LOG_LEVEL below Warn (3) is raised to Warn. Trace, Debug, and Info (0–2) take effect only in development builds.
  • Firmware version — Has three fields, matching the driver and firmware convention.
  • Library structure — The internal library structure changed. Applications continue to link the CMake target hart::ha_hart and need no source changes.

0.0.4 — 2026-07-15

Version: 0.0.4rc4. Requires Python 3.10 – 3.12.

Highlights

  • Streams and events — Data transfers and kernel launches can all be enqueued asynchronously, so transfers and computation can overlap.
  • Kernel-level profiling — Supports hardware counters and host-device correlation ids.
  • Cross-device copies — Data can be copied directly to another device or a peer device.

New Features

Area Added
Streams HaStreamCreate(), HaStreamDestroy(), HaStreamSynchronize(), HaStreamQuery(), HaStreamWaitEvent(), HaStreamGetDevice()
Events HaEventCreate(), HaEventDestroy(), HaEventRecord(), HaEventSynchronize(), HaEventQuery()
Asynchronous operations HaMemAllocAsync(), HaMemFreeAsync(), HaMemCpyAsync(), HaMemLoadFileAsync(), HaLaunchKernelAsync(), launch_legato_kernel_async()
Profiler entry points Correlation push/pop, record ring configuration and consumption, signal log reads, host/device clock pairing
Cross-device copies Cross-device and peer HaMemCpy()
TLB structs TLBInitInfo, TLBAllocInfo, and so on available from the hart.hart extension module

Changes

  • Copy path reworked — HaMemCpyNd() merges dimensions that are adjacent on both sides, so a copy that is logically multi-dimensional but physically contiguous becomes a single transfer. You no longer need to flatten views yourself.
  • Data type definitions — Moved to the SDK-wide shared type layer, so HaDataType values match the compiler.
  • Per-device ownership — Each device has its own hardware abstraction layer agent.
  • Paged KV-cache — A smaller page granularity lowers the memory overhead.
  • Model initialization — Uses the fast weight copy path, shortening Llama load time.

Deprecated

  • launch_model — Moved to the general launch path and will be removed in a later release. Use HaLaunchKernel() or the Legato launch entry points.

Fixes

  • Fixed generation starting on non-final steps, which produced incorrect chunked prefill results.
  • Fixed the repetition penalty behavior of the V1 vector unit, which changed after the EVT1 and Edge RTL changes.
  • Fixed the Legato top/core builder pattern producing an incorrect argument layout.

Known Issues

Issue Impact Workaround
Device memory and utilization cannot be queried The monitor mode integration cannot read the values from the runtime Use the driver interface
Freed device memory is not returned right away Peak usage may persist until the process exits Allocate long-lived buffers once at startup

0.0.3 — 2026-06-18

New Features

  • Device scan API — Device discovery, which used to happen implicitly on the first allocation, is now an explicit call.
  • Per-DRAM-channel memory dump — HaMemDumpForEachChannel() (Python: dump_for_each_channel()) lets you verify that a layout landed where intended.
  • HaFlushTlb() — Invalidates only the TLB, separately from HaConfigureTlb().
  • Runtime API callbacks — Callbacks can be received when runtime API calls are made.

Changes

  • HaMemCpyNd() — Host↔host copies run in parallel, and SinglePassInterleaved copies gather the data and then transfer it at once.
  • Sampling parameters — Cached instead of being set again every step.
  • Kernel caching — Per-launch state is separated from cached kernels, so a kernel cached on the device can be reused with different arguments.
  • SRAM scratch buffer — The per-device ABI scratch buffer is reused instead of reallocated.
  • Memory layer — Overhead on frequently called paths was reduced.

Fixes

  • Fixed memory pool sub-allocations not being aligned to page boundaries.
  • Fixed the small memory pool thrashing when similar sizes were allocated and freed repeatedly.
  • Fixed thread context and DRAM channel handling getting out of sync under multithreaded use.
  • Fixed several correctness defects in multi-head attention.

0.0.2 — 2026-01-13

The first release in which the runtime was split out as a component with its own version.


Version Support

Version Release date Status
0.0.6 2026-11-16 Current
0.0.5 2026-10-14 Superseded
0.0.4 2026-07-15 Superseded
0.0.3 2026-06-18 Superseded
0.0.2 2026-01-13 Superseded

hart is in beta.

  • The Ha* C++ API and the hart Python API are expected to stay source-compatible within a minor version, but the runtime as a whole has not yet reached a stability guarantee.
  • Error codes are stable and are not reused with a different meaning.
  • Deprecations are announced in the release that introduces them, and deprecated entry points remain for at least two subsequent releases before removal.