reflaxe.rust

KO | EN

gitlite — search

#javascript #python #hacktoberfest #react #typescript #go #machine-learning #rust #deep-learning #kubernetes #security #pytorch #ios #mcp

(★ 11)

Compile Haxe to mostly idiomatic Rust (not ready for consumption yet!)

reflaxe.rust 최신버젼 다운로드

최종 버전 다운로드 (.zip)

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# reflaxe.rust

[![Latest Release](https://img.shields.io/github/v/release/fullofcaffeine/reflaxe.rust?display_name=tag)](https://github.com/fullofcaffeine/reflaxe.rust/releases/latest)
[![CI](https://github.com/fullofcaffeine/reflaxe.rust/actions/workflows/ci.yml/badge.svg)](https://github.com/fullofcaffeine/reflaxe.rust/actions/workflows/ci.yml)

Haxe 4.3.7 -> Rust target built on Reflaxe.

This project lets you write Haxe and ship native Rust binaries, with a path for both Haxe-first and Rust-first teams.

Release policy and maturity are documented in [SemVer And Release Posture](docs/semver-release-posture.md);
the exact current version is the latest immutable GitHub Release tag.

Architecture and contract confidence is strong, and the validated implementation baseline is broad
and evidence-backed.

Production shorthand: use it for controlled production on validated lanes, not as a blanket promise
that every arbitrary Haxe/std/sys edge behaves identically on every platform. If your app touches
networking, TLS, DB, processes, or threading, add app-specific smoke tests around those paths.
Portable core `Sys`/standard-stream failures are Haxe-catchable on the validated lane; `Sys.cpuTime`
remains explicitly experimental rather than pretending wall time is CPU time, and `Sys.putEnv`
remains experimental outside a provably single-threaded process-startup boundary on non-Windows.
The independent 2026-07-13 review rates current bounded production
`READY_WITH_BOUNDED_SCOPE` and stable `1.0` `NOT_READY`; the verified findings and narrow closure
program are recorded in the
[production-readiness audit disposition](docs/production-readiness-audit-2026-07-13.md).

Architecture-claim status: **3 closed**, **7 qualified**, **1 open**.
The implemented architecture disproves the old claim that a usable Haxe-to-Rust backend is impossible without either a tracing GC or lifetime annotations everywhere, but the evidence still supports bounded, qualified claims rather than universal parity.
Review the exact evidence, exclusions, and blocking Beads in the [generated architecture capability claims](docs/architecture-capability.md); this summary does not authorize stable 1.0 or an unqualified “all Haxe to handwritten-quality Rust” claim.

## Why reflaxe.rust

- `portable` contract (default): Haxe-first semantics with portability-oriented behavior and predictable stdlib/runtime integration.
- `metal` contract: Rust-first boundary rules, typed interop surfaces, and performance-focused paths.
- Portable abstractions do not have to mean wrapper tax: when semantics line up, admitted shared
  portable surfaces can lower directly to native Rust representations. The current fixture-backed
  `reflaxe.std.Option/Result` contract maps to Rust `Option/Result`, while the standalone
  `reflaxe.std` package modules remain family-package work rather than modules bundled by this
  haxelib today.
- `reflaxe.std` is the planned broader portable idiom layer, not a Rust-only wrapper module. V1 is
  intentionally narrow (`Option` / `Result`) so semantics and migration stay stable before the
  portable API surface grows.
- Portable lowering can still target native Rust representations when semantics match, but that is
  an implementation win inside the `portable` contract, not a silent switch into native-lane code.
  See [Portable near-native guidance](docs/portable-near-native-guidance.md).
- `hxrt` is a semantic fallback, not the compiler's default strategy. The compiler should lower at
  compile time first and use runtime helpers only for required Haxe semantics such as `Dynamic`,
  reflection, exceptions, Haxe object identity, anonymous structural records, nullable compatibility,
  or platform abstractions. Type/metadata facts the compiler already knows, such as optional fields,
  literal defaults, and static access paths, should stay in lowering instead of becoming runtime APIs.
- Reflection support is intentionally narrow and typed where possible; for example,
  `Reflect.compare` over typed `Int`, `Float`, and `String` lowers to direct Rust comparisons.
- Common String methods lower to Rust-owned string helpers instead of phantom Rust methods; for
  example, `String.substring(start, end)` preserves Haxe's clamped/swap semantics without emitting
  a nonexistent `String::substring` call.
- Generic helper methods propagate generated class payload bounds in their Rust signatures, so a
  helper returning `Payload<T>` emits the same `T: Clone + Send + Sync` contract required by
  `Payload<T>` instead of relying on runtime indirection.
- Rust-native systems facades are growing beside portable `sys.*` APIs. Current slices include
  `rust.fs.NativeFiles` for typed no-hxrt file/path work and `rust.process.NativeCommands` for a
  narrow owned-command process subset with `rust.process.CommandOutput`, `rust.process.CommandSpec`,
  `rust.process.CommandError`, `rust.process.CommandChild`, and explicit working
  directory/environment set-remove-clear/cwd+env/stdin-input/stdin+cwd+env plus narrow live child
  write/wait/kill lifecycle support. `rust.net.NativeTcp` adds a blocking localhost TCP loopback
  proof with typed `TcpListener` / `TcpStream` wrappers for UTF-8 and byte-stream payloads, and
  `rust.net.NativeUdp` adds a blocking localhost datagram proof with a typed `UdpSocket` wrapper
  for UTF-8 and byte payloads. `rust.net.SocketAddr` carries typed loopback addresses across
  bind/connect/send APIs so metal code can reuse OS-assigned ports without falling back to strings
  or raw Rust snippets.
  `rust.net.SocketError` is available through opt-in socket `Detailed` methods for invalid-input,
  IO, and UTF-8 recovery without parsing strings. These do not replace portable `sys.io.File`,
  `sys.io.Process`, or `sys.net.Socket`.
- Typed anonymous records preserve Haxe aliasing while keeping field access typed; required fields,
  omitted `@:optional` fields, and mutable function-field records that implement the Haxe iterator
  protocol are covered by focused generated-Rust and semantic-differential fixtures.
- Array value and key/value iterators can cross typed helper boundaries without emitting upstream-only
  Haxe std classes; evaluation occurs once, key/value items retain ordered typed records, and reused
  iterator bindings share one cursor.
- DynamicAccess value and key/value iterators also cross typed helpers while preserving their distinct
  lazy contract: keys are captured once, values are read from the live source at `next()`, aliases share
  one cursor, and key order remains unspecified.
- Unicode string value and key/value iterators preserve Unicode scalar code points and logical character
  keys across typed helpers; they never expose Rust UTF-8 byte offsets or split characters into UTF-16
  surrogate halves.
- CI evidence: snapshots, negative policy fixtures, runtime/optimizer plan reports, product-neutral
  benchmark candidates, and HXRT overhead tracking are all part of the default workflow.

## Start Here

- New here: [Start Here guide](docs/start-here.md)
- Common first questions: [FAQ](docs/faq.md) for GC, memory management, runtime overhead, generated Rust quality, profile choice, and interop
- Evaluating production use: [Production Readiness guide](docs/production-readiness.md), then [feature support matrix](docs/feature-support-matrix.md)
- Portable-first path: [Profiles](docs/profiles.md), [Portable near-native guidance](docs/portable-near-native-guidance.md), [Examples Matrix](docs/examples-matrix.md)
- Metal-first path: [Metal profile](docs/metal-profile.md), [Portable vs metal authoring](docs/portable-vs-metal-authoring.md), [profile_storyboard / metal examples](docs/examples-matrix.md)
- Release / operations path: [Production Readiness guide](docs/production-readiness.md), [Semver and release posture](docs/semver-release-posture.md), [Weekly CI Evidence runbook](docs/weekly-ci-evidence.md)
- Tooling / workflow: [Dev Watcher guide](docs/dev-watcher.md), [Async/Await guide](docs/async-await.md), [Documentation Index](docs/index.md)

## Scaffold A New Project (Generator)

Generate a ready-to-run Haxe.rust project:

```bash
npm run dev:new-project -- ./my_haxe_rust_app
cd my_haxe_rust_app
cargo hx dev
```

The generated project includes the full task plumbing:

- `cargo hx dev` (watch, compile, and run during development)
- `cargo hx run` / `cargo hx test` (one compile-and-run/test cycle)
- `cargo hx build --release` (production build)
- `bash scripts/dev/check-guards.sh` (local-path + security wiring checks; gitleaks scan when installed)
- `bash scripts/install-git-hooks.sh` (installs pre-commit local-path + staged gitleaks checks)

Use this scaffold when you want the recommended app layout and local task driver. If you are
installing into an existing app instead, start from [Install via lix](docs/install-via-lix.md).
For the full generated-app loop, see [Workflow](docs/workflow.md#new-project-scaffold--task-hxmls).

## Quick Start (First Successful Run)

Prerequisites include Rust `1.96.0` or newer. `rust-toolchain.toml` makes that supported floor the
repository default; release automation separately pins its reviewed patch toolchain. See the
[Rust toolchain policy](docs/rust-toolchain-policy.md).

For an application, keep the generated `Cargo.lock` under version control and pass
`-D rust_cargo_locked` in CI/release builds. Generated manifests use Cargo resolver 3 to prefer
dependencies compatible with the declared Rust floor; the committed application lock is what keeps
that reviewed resolution reproducible.

1. Install dependencies (the Haxe toolchain is pinned via lix):

```bash
npm install
```

2. Compile and run the hello example:

```bash
cd examples/hello
npx haxe compile.hxml
(cd out && cargo run -q)
```

3. Run snapshot tests:

```bash
npm test
```

4. Run the full CI-style local harness:

```bash
npm run test:all
```

GitHub Actions shards this same harness into parallel jobs for wall-clock speed, but the local
command remains the single full-suite entrypoint.

After the first successful run, the recommended next step is a generated starter app:

```bash
npm run dev:new-project -- ./my_haxe_rust_app
cd my_haxe_rust_app
cargo hx dev
cargo hx test
```

That path exercises the same project-local workflow users should keep in application repos.

## Fast Dev Loop (Watcher)

Install watcher engine once:

- Homebrew: [`brew install watchexec`](https://formulae.brew.sh/formula/watchexec)
- Cargo: [`cargo install watchexec-cli`](https://crates.io/crates/watchexec-cli)

Then run:

```bash
cd examples/hello
cargo hx dev
```

Watch mode uses a session-owned Haxe compile server by default, so compiles are faster after warm-up.
Use `cargo hx dev --mode test` to test on each change, or `--no-haxe-server` if you want direct
compilation without the incremental server.

More usage options: [Dev Watcher guide](docs/dev-watcher.md).

## Pick Your Profile

Use `-D reflaxe_rust_profile=portable|metal`.

| Profile | Best for | What you get |
| --- | --- | --- |
| `portable` (default) | Haxe-first teams | Stable Haxe semantics and portability-first behavior |
| `metal` | Rust-aware teams and performance-critical paths | Rust-first APIs, stricter app-side injection boundaries, and primary near-pure-Rust hot-path performance objective |

Rule of thumb:

- Start in `portable`.
- Add `metal` only where the app needs Rust-first APIs, stricter boundaries, or measured hot-path work.
- Use `reflaxe.std` portable idioms when the shared package is on your classpath and they express
  the right semantics; on Rust, admitted `Option` and `Result` surfaces lower to native Rust
  representations when the contract lines up. Until that package is supplied, keep using the
  shipped `haxe.*` or `rust.*` surfaces that match your portability intent.
- Use `rust.*`/`rust.metal.*` when the source itself should be Rust-native. Treat awkward source
  code written only to appease current codegen as a compiler/API gap to report or fixture.
- Use scoped borrow helpers (`Borrow.withRef/withMut`, slice/str helpers) for Rust-like borrowed
  views; direct token escapes, first-wave alias escapes, escaped wrappers/throws, and overlapping
  local mutable scopes are diagnosed before Rust code is emitted.
- `SliceTools.with(array, ...)` and `MutSliceTools.with(array, ...)` are output-gated to borrow
  Array storage as scoped `&[T]` / `&mut [T]` views rather than materializing cloned arrays.
- Use typed `rust.*` systems facades for Rust-native handles and command/file-style work. Portable
  `sys.io.Process`, `sys.io.File`, and `sys.net.Socket` keep Haxe compatibility semantics and may
  still use `hxrt`.

Read more: [Profiles guide](docs/profiles.md), [Rusty migration guide](docs/rusty-profile.md),
[Metal profile details](docs/metal-profile.md), [Extern and lifetime-island cookbook](docs/extern-lifetime-island-cookbook.md),
[RAII guard and lifetime-island rules](docs/raii-guard-lifetime-islands.md),
[Metal systems facades roadmap](docs/metal-systems-facades-roadmap.md),
[HXRT overhead benchmarks](docs/perf-hxrt-overhead.md),
[Consumer runtime benchmark corpus](docs/consumer-runtime-benchmark-corpus.md), and
[Lifetime encoding design](docs/lifetime-encoding.md).

## Examples

- [chat_loopback](examples/chat_loopback) (cross-profile flagship: portable/metal)
- [profile_storyboard](examples/profile_storyboard) (cross-profile micro-app focused on profile-specific coding style + `@:rustTest`)
- [metal_first_dataflow](examples/metal_first_dataflow) (dedicated metal-style reference: `Result`/`Option`/`Vec` with strict-boundary-safe app code)
- [metal_native_net](examples/metal_native_net) (metal/no-hxrt TCP + UDP loopback using typed `SocketAddr`)
- [hello](examples/hello) (portable sanity check)
- [async_retry_pipeline](examples/async_retry_pipeline)
- [classes](examples/classes)
- [serde_json](examples/serde_json)
- [sys_file_io](examples/sys_file_io)
- [sys_net_loopback](examples/sys_net_loopback)
- [sys_process](examples/sys_process)
- [sys_thread_smoke](examples/sys_thread_smoke)
- [thread_pool_smoke](examples/thread_pool_smoke)
- [tui_todo](examples/tui_todo)

Coverage map: [docs/examples-matrix.md](docs/examples-matrix.md).

## Most Useful Commands

- Watch mode for local development: `cargo hx dev`
- Scaffold a new starter project: `npm run dev:new-project -- ./my_haxe_rust_app`
- Refresh tracker-backed status docs: `npm run docs:sync:progress`
- Verify tracker-backed status docs are in sync: `npm run docs:check:progress`
- Snapshot tests: `bash test/run-snapshots.sh`
- Upstream stdlib sweep: `bash test/run-upstream-stdlib-sweep.sh`
- Template task-matrix smoke: `bash scripts/ci/template-smoke.sh`
- Independent `codex-hxrust` consumer compatibility: `npm run test:codex-hxrust` (requires the sibling checkout; skips when absent)
- Windows-safe smoke subset: `bash scripts/ci/windows-smoke.sh`
- Metal idiom count guard: `npm run test:metal-idiom`
- Native facade manifest guard: `npm run guard:native-facade-manifest`
- HXRT overhead benchmark + soft-budget warnings: `bash scripts/ci/perf-hxrt-overhead.sh`
- Full local CI equivalent: `bash scripts/ci/local.sh`
- Clean generated artifacts: `npm run clean:artifacts:all`

## Status and Readiness

- Current release posture: [Semver and release posture](docs/semver-release-posture.md)
- Production rollout guidance: [Production Readiness](docs/production-readiness.md)
- Current readiness tracker: [Compiler Progress Tracker](docs/progress-tracker.md)
- Ongoing validation cadence: [Weekly CI Evidence](docs/weekly-ci-evidence.md)
- Technical support matrix: [feature support matrix](docs/feature-support-matrix.md)
- Sys regression intake: [Cross-Platform Watchlist](docs/sys-regression-watchlist.md)

Historical closeout records:

- [GA decision record](docs/ga-decision-record.md)
- [GA caveat classification](docs/ga-caveat-classification.md)
- [Road to 1.0](docs/road-to-1.0.md)

## Defines (Common)

- `-D rust_output=out` - output directory for the generated Cargo project
- Every generated crate includes a deterministic `rust-source-map.json` that ties exact emitted
  Rust bytes back to Haxe positions or explicit compiler-generated reasons; see
  [Rust-to-Haxe source maps](docs/rust-source-maps.md).
- `-D rust_no_build` / `-D rust_codegen_only` - codegen only, skip Cargo build
- `-D rust_build_release` / `-D rust_release` - release build mode
- `-D rust_target=<triple>` - pass target triple to Cargo
- `-D reflaxe_rust_profile=portable|metal` - select profile contract
- `-D rust_async` - enable the experimental Rust-first async/await preview (`docs/async-await.md`)
- `-D rustfmt` - run `cargo fmt` on generated output (best effort)

Full list: [Defines reference](docs/defines-reference.md).

## Rust Interop

Preferred order:

1. Pure Haxe + runtime/std APIs
2. Typed externs and metadata (`@:native`, `@:rustCargo`, `@:rustExtraSrc`)
3. Framework wrappers around hand-written Rust modules
4. Raw `__rust__` only when necessary

Hand-written Rust helpers under `std/rust/native/*.rs` are governed by the
[Native facade helper policy](docs/native-facade-policy.md) and
[manifest](docs/native-facade-manifest.json). New or expanded helpers must declare their owner,
classification, runtime contract, allowed dependencies, forbidden growth, evidence owner, and
review budget.

Read: [Interop guide](docs/interop.md) and [Workflow guide](docs/workflow.md).

## Installation and Release Docs

- Toolchain install details: [Install via lix](docs/install-via-lix.md)
- Release process: [Release docs](docs/release.md)

reflaxe.rust

reflaxe.rust 최신버젼 다운로드

오늘의 추천 프로젝트

Was this content helpful?

Recent Feedback

reflaxe.rust

reflaxe.rust 최신버젼 다운로드

오늘의 추천 프로젝트

Was this content helpful?

Recent Feedback

Download README