Version 0.3 Release - Faster Iteration, Stronger Foundations

Hachi has always been about building something that feels simple on the surface, but powerful underneath. This release is a big step in that direction.

v0.3 focuses on three core areas:

The result is a version of Hachi that is not just easier to use, but significantly more reliable under the hood.

A Faster, Smoother Development Loop

One of the biggest upgrades in this release is the introduction of a real development loop.

Watch Mode

Hachi now includes a --watch mode:

hachi file.hachi --watch

This continuously rebuilds and reruns your program whenever something changes. What makes it particularly useful is that it doesn’t just watch the entry file — it tracks all imported modules as well.

If you modify a dependency, Hachi detects it and rebuilds automatically.

You also get clear, timestamped logs:

2026-03-22 21:03:11 File Changed: fmt.hachi -> Rebuilding

This turns Hachi from a “run-it-manually” tool into something you can actually live inside while developing.

Check Mode

A new --check flag provides a fast validation pass:

hachi file.hachi --check

This runs parsing, import resolution, and validation, but skips execution and compilation. It’s useful for:

You get a simple result:

✅ check passed

or

❌ check failed

Execution Stats

You can now inspect where time is being spent:

hachi file.hachi -go --stats

Example output:

[Hachi Stats]
Resolve:    8 ms
Transpile:  14 ms
Compile:    392 ms
Run:        27 ms
Total:      441 ms

This makes performance visible and gives a foundation for future optimization work.

Import Graph Visualization

Understanding dependencies is now much easier:

hachi file.hachi --graph

This prints a structured tree of imports, including nested dependencies, shared modules, and cycles. It’s a small feature that ends up being extremely useful as projects grow.

Under the Hood: Compiler & Transpiler Improvements

A large portion of this release focused on correctness.

Several issues in the generated C++ layer were addressed:

Import handling also received significant improvements:

Additionally, CLI recursion (-c and internal execution paths) now correctly uses the current executable rather than assuming a fixed binary name.

These changes don’t necessarily show up in syntax, but they eliminate entire classes of subtle failures.

Runtime Safety Improvements

Another major focus of v0.3 is making transpiled execution safer.

Array Safety

Transpiled array access now includes explicit bounds checks for:

Out-of-bounds access now produces a clear runtime error instead of undefined behavior or segmentation faults.

This applies across all transpiled execution modes:

Memory Behavior

A few key fixes and improvements:

These changes tighten memory behavior without changing the language surface.

CLI Improvements

The CLI has been cleaned up and made more consistent:

There’s also a new --clean flag to remove leftover build artifacts.

Where Hachi Stands Now

Hachi is still early, but this release marks a shift.

Previously, the focus was on getting the language working.

Now, the focus is on:

You can now:

At the same time, the generated code and runtime behavior are significantly more stable.

Closing Thoughts

v0.3 is less about flashy syntax and more about making Hachi feel solid.

Better tools. Better safety. Better iteration.

← Version 0.4 Release - Concurrency, Obfuscation, and a Real Step Forward Version 0.2.4 Release - Runtime Tightening and New File Capabilities →