mrkeyoor.comAsk

makepad/relaxtested 21 Nov 2026commit 5dc818e

relax review

Use Relax as a development experiment if you can compare application behavior with rustc and investigate compiler mismatches.

  • Safety failed
  • Install 1 s
96/102passed, run exited non-zero
  • Build 160 s
  • 60 packages
Dev Toolsevaluationupdated 22 Nov 2026

Relax is an experimental compiler and JIT runtime for Rust. Its README describes compiling functions when first called and patching function-body edits into a running process, while directing release builds to rustc.

Verdict

Use Relax as a development experiment if you can compare application behavior with rustc and investigate compiler mismatches. Our run at 5dc818e built in 160 seconds, then cargo test failed with six failures out of 102. Avoid it as a release compiler or as a way to inherit Rust's safety guarantees automatically: its README rejects both expectations.

Relax infographic: explore live function edits in a running process, plus our test result and who it suits
Tested 21 November 2026: 96 of 102 source tests passed, 6 failed. Before that: source install 1 s, build 160 s.

We ran it

Lab card: what happened when we ran relax
Lab card from our sandbox run
Screenshot of relax (github.com/makepad/relax)
github.com/makepad/relax
Install✓ · 1s60 packages
Build✓ · 160s
Tests✗ · 359s96 passed · 6 failed of 102 (cargo test)
Repo3733 files~862,204 lines of source · 42.5 MB · 0 CI workflows

Answers from our run

Does relax build from source?

Dependencies installed in 1 seconds (60 packages), and the build succeeded in 160 seconds. We cloned commit 5dc818e into a clean Debian container with 3 CPUs and no project-specific setup.

Do relax's tests pass?

No. The project's own test command finished in 359 seconds and reported 96 passed, 6 failed (cargo test).

Who should not use relax?

Teams seeking a release compiler: the README directs release builds to rustc.

What are the alternatives to relax?

Rust with Cargo, rustc_codegen_cranelift. Use Relax as a development experiment if you can compare application behavior with rustc and investigate compiler mismatches.

Setup4/5Our source checkout installed in 1 s and built in 160 s with 60 dependencies, but we did not run a README task.Editor’s note: Installation and building succeeded, but the failed test command and stopped application workflow do not support an overall setup-ease assessment.
Docs4/5The README has an install command and a usage section (“Try it”); we did not run its quickstart ourselves.Editor’s note: The README documents setup and safety defaults; command accuracy across platforms was not assessed.
Community4/5Last push on 2026-11-22, 626 stars and maintainers answered or closed 10 of the 10 most-discussed issues we sampled.Editor’s note: Named contributors report reproductions and repairs, but the sampled issues do not measure adoption or support capacity.
Maturity1/5No tagged GitHub release, repository created 2026-11-11 and its test suite did not pass in our sandbox (96 of 102 passed).Editor’s note: The README calls Relax experimental and our test command failed; application compatibility across representative projects was not assessed.

How we score

Discussed on

  1. hnRelax: JIT compiler for Rust to reduce build times180 points

Who it’s for

Rust developers exploring live function edits while retaining rustc for release builds.
Compiler contributors investigating compatibility failures with a recorded commit and executable path.
Makepad developers evaluating the development loop described in the README.

Who it’s NOT for

Teams seeking a release compiler: the README directs release builds to rustc.
Developers expecting Relax to inherit Rust's safety guarantees automatically.
Projects requiring the local alloc macro-path reproduction in issue #239 to work.
Test suites relying on the artifact-discovery and forwarded-relaunch routes still reported failing in issue #139.

Setup reality

Our November 21, 2026 run at commit 5dc818e installed in 1 second with 60 dependencies recorded and built in 160 seconds. cargo test exited 101 after 359 seconds: 96 passed and six failed out of 102. The final displayed test group names relax-backend's wasm_backend target. The sandbox configuration was 3 CPUs, 12 GB RAM and image label lab-rust:1.

The README builds relax-runner and runs its executable from a Cargo package's directory using the package name. Keep the Relax checkout in place because the executable reads its standard library there. For dependencies, the README documents Cargo's registry cache, downloads from crates.io and offline switches.

A separate Compose workflow stopped because none of its four accepted Compose filenames existed. Its summary nevertheless claimed deployment. The recorded step failed, and teardown succeeded.

Short answer: keep rustc in your release path

Our run of makepad/relax built successfully in 160 seconds, then cargo test failed with 96 passing tests and six failures. Use Relax for development experiments if you can investigate differences from rustc; avoid it as your release compiler. The Relax README directs release builds to rustc. That division gives Rust developers a concrete way to approach the project: explore its edit-run loop alongside the compiler used to build releases.

This relax review covers makepad/relax, the experimental Rust compiler and JIT runtime. The README describes compiling functions when first called, optimizing hot functions and patching edits into a running process. The issue discussions document application startup, repaired compiler failures and unresolved reproductions. Together with our repository checks, they make compatibility the useful basis for this review: which source forms, dependencies and process-launch routes produced which outcomes, on which recorded commits?

What people use relax for

Contributors report GUI startup, cross-workspace cache reuse and dependency compatibility exercises with Relax. Those uses reach beyond a dependency-free example: they involve application graphs, generated macros and workspace paths. The following table links each result to its issue discussion and keeps its reporter attached. A reported repair belongs to its reproduction and commit, rather than becoming a claim that every application using the same dependency works.

Who used it What they did What happened
Laotree, issue #142 Started the Onley desktop GUI through Relax The app window opened despite 195 cached diagnostics; a later app test-to-run sequence produced zero E0119/E0592 diagnostics.
Laotree, issue #170 Copied a dependency-heavy CLI stack to another workspace on PR #206's branch The copied stack created zero new identities, and a CARGO_MANIFEST_DIR example printed each run's own path.
Laotree, issue #37 Ran tinyvec and checked objc2-foundation after a macro fix tinyvec 1.13.3 printed [1], and objc2-foundation 0.3.2 checked with zero errors on c2cc38b5.
art-shen, issue #77 Retested nested iterator closures over BTreeMap references After rebuilding the intended executable, the original program printed [10], matching rustc.
Laotree, issue #128 Retested a generated macro exported across source files The three-file reproduction printed 1 on 04f19e9f.

Issue #37 explains why preserving crate context matters: a hand-written single-file copy worked while tinyvec failed. Issue #128 records a similar distinction between one-file and three-file generated macros. For a developer investigating either failure, the dependency and file arrangement are part of the reproduction. Removing them can also remove the behavior being investigated, leaving a smaller example that answers a different compatibility question.

What happened when we ran it

Our November 21, 2026 run at commit 5dc818e installed in 1 second, built in 160 seconds and failed cargo test after 359 seconds. The test command exited 101, with 96 passed and six failed out of 102. These are our measurements of repository installation, building and testing. They are separate from the README's application timings and the contributor results discussed elsewhere on this page.

Recorded question Answer Verdict Why
Did installation complete? Yes; 60 dependencies recorded in 1 second Passed The install step exited 0.
Did the repository build? Yes, in 160 seconds Passed The build step exited 0.
Did cargo test pass? No; 96 passed and six failed out of 102 after 359 seconds Failed The command exited 101.
Did the Compose workflow proceed? No accepted Compose filename existed Stopped Its safety step required a Compose file.
Did teardown complete? Yes Passed The teardown record says teardown: ok.
Does the deployment summary agree with the safety step? No; it claims Compose deployment after the recorded refusal Contradictory The step stopped at the Compose-file requirement.

The final displayed test group reports FAILED. 15 passed; 6 failed, followed by the rerun target -p relax-backend --test wasm_backend. That group is narrower than the overall total of 102 tests. Earlier displayed groups passed, but the command finished with failure. The configured sandbox had 3 CPUs, 12 GB RAM and image label lab-rust:1; the checkout scan recorded 3,733 files, approximately 862,204 source lines and 42.5 MB.

The scan recorded zero CI workflow files, no Dockerfile and no top-level tests directory. Cargo still found and ran tests. Separately, the Compose workflow's safety step failed because compose.yaml, compose.yml, docker-compose.yaml and docker-compose.yml were absent. Its word "unsafe" refers to that workflow's Compose-file rule. Teardown succeeded, while the summary claimed deployment with Docker Compose and every port bound to 127.0.0.1, contradicting the failed operational step.

Where people get stuck: macros, executable paths and stale binaries

Issue #239 remains open for a local alloc module interfering with format! expansion; issue #139 records two failing launch routes after a shell case passed. Other threads report specific repairs. The table separates these outcomes so that a closed issue label does not substitute for the final reproduction result, and a historical failure does not become a claim that its reported repair never happened.

Symptom and reporter Reported outcome Reproduction detail to retain
pmarks: local alloc module breaks format!, #239 Open; the synthesis records a later dependency-free reduction. Local module and import arrangement.
art-shen: false E0373 and segmentation fault, #77 Repaired by 7450404; a stale executable obscured the repair. Executable path as well as source commit.
Laotree: generated macro unavailable across files, #128 ddff0959 identified as the fix; retested on 04f19e9f. Three-file arrangement.
pmarks: bytemuck derives rejected by deny(unsafe_code), #238 Maintainer reports the fix in c5f7716f74. Generated tokens versus tokens forwarded from macro input.
moorbrook: current_exe launch behavior, #139 Shell case passed on 04f19e9f; two standalone cases remained. Artifact discovery and forwarded relaunch as separate routes.

In issue #77, art-shen rebuilt Relax from another project whose Cargo configuration set build.target-dir. The new binary went there while target/release/relax stayed at an older build. The reporter says relax --version printed the same build identifier for both. After rebuilding the intended checkout, the original program printed [10], matching rustc. Recording the actual executable path would expose the distinction that the version output missed.

Issue #139's artifact example passed its CARGO_BIN_EXE_* control but failed to find the package binary derived from current_exe(). Its forwarded route produced Unrecognized option: 'silent'. Separately, issue #240 reports an internal compiler error in faer 0.24.4's Mat::as_ref and missing AArch64 reduction intrinsics through pulp 0.22.3. The maintainer reports repairs to both parts, including the lifetime-region repair in 5b24d3c291.

Cache reuse includes program values and workspace paths

Issue #142 records incorrect constant-value reuse as well as replayed diagnostics, followed by successful retests of the reported examples. Laotree reports both standalone run/test orders passing on c2c5fc7e and the application sequence clean on 2fc616c3. The app previously produced 195 E0119/E0592 diagnostics and later produced zero. The earlier finding therefore includes a wrong program value, rather than only repeated error messages.

Laotree's issue #170 reports roughly 100 MB of cache for a minimal program and 2 to 6 GB for medium stacks. The report describes standard-library and dependency code duplicated across workspaces. Its later branch results concern cross-workspace reuse on PR #206: copying a dependency-heavy CLI stack created zero new identities, while a CARGO_MANIFEST_DIR program printed the path belonging to each run's workspace. These are contributor measurements and branch results, separate from our 42.5 MB checkout measurement.

Safety defaults include background borrow checking

The README warns that Relax does not automatically inherit Rust's safety guarantees. It describes an experimental reimplementation, separate from rustc and unaffiliated with the Rust project or Rust Foundation. A bug in Relax can make a correct program, including safe source code, misbehave or crash. That warning is part of the project's stated operating model and belongs in the decision to use it for development.

By default, Relax type-checks each function before execution and runs its borrow checker in the background. The README documents relax run --check-first as the option that waits for borrow checking. It also directs release builds to cargo build --release with rustc. These are distinct instructions: one changes when a development run waits for checking, while the other specifies the compiler used to build what you ship.

Getting started means keeping the checkout in place

The README builds relax-runner and runs its executable from a Cargo package's directory using the package name. Relax reads its standard library from the checkout it was built in, so that directory stays in place. The commands below reproduce the documented quick start. They are a documentation example; the repository installation, build and test measurements are reported in the run section.

git clone https://github.com/makepad/relax
cargo build --release --manifest-path relax/Cargo.toml -p relax-runner --bin relax
cargo new hello
cd hello
../relax/target/release/relax run --quiet hello
../relax/target/release/relax test hello
../relax/target/release/relax check hello

The README's network instructions say a dependency-free package needs no network. For crates.io dependencies, Relax uses Cargo's registry cache when available and otherwise downloads from crates.io. RELAX_OFFLINE=1 or CARGO_NET_OFFLINE disables downloads. Another documented requirement affects tests invoking external rustc: relax test creates no rustc-format .rlib or .rmeta for the crate, so a test handing that library to rustc needs cargo build --lib first.

Function bodies are the documented live-patching unit. Changes to struct layout, imports, trait or implementation headers, and macros wait for a restart; the README gives relax inspect <pid> session relaunch for that route. Makepad's application runner and development hub live in Makepad's repository. Its makepad run commands therefore belong to that application host, rather than the standalone Relax quick-start sequence above.

Relax vs rustc, Cargo and rustc_codegen_cranelift

Relax's README assigns release builds to rustc; rustc_codegen_cranelift changes the Rust compiler's code-generation backend. The distinction is architectural. Relax replaces the language pipeline described in its README, while Cranelift's Rust backend targets code generation within the Rust compiler. The compatibility threads use Cargo and rustc as controls, which makes them useful reference points for evaluating the same reproduction under different development tools.

Choice What its primary material says Pick it when
Relax Its README describes on-demand compilation and live function edits. You want to explore live iteration and investigate application compatibility.
Rust with Cargo Rust's repository contains the compiler, standard library and documentation. You need Relax's recommended release route and the compatibility control used in the reports.
rustc_codegen_cranelift Its README describes an alternative Rust compiler backend distributed in nightly builds. You want to explore different debug code generation within the Rust compiler.

The Cranelift backend's README describes a potential improvement in debug compilation time. Relax's README describes a live compiler that compiles functions when called and patches function edits. Those descriptions answer different workflow questions: changing the backend used for a build versus keeping a process alive while code changes. Neither project description supplies a comparative timing from our November 21 repository run.

Project activity includes named repairs

GitHub recorded 626 stars, 23 open issues and pull requests, and a last push on November 22, 2026. The repository metadata dates those observations. The issue discussions also contain concrete maintainer responses: the bytemuck report names c5f7716f74, and the faer synthesis names 5b24d3c291. Those commit references let readers follow individual repairs without treating repository attention as an application result.

In issue #154, makepaddev welcomes x86 SIMD contributions through AVX-512 and asks for small instruction-family pull requests with differential tests against rustc, including edge values. The contributor describes a trial implementation and distinguishes expressible vector operations from fp16/bf16 primitive-type needs and system-state operations. The thread documents contribution direction and the proposed work's boundaries, rather than a completed instruction-support release.

FAQ

Laotree reports cross-workspace cache reuse on PR #206's branch, including preservation of each workspace's own paths. Cache reuse is one of the concrete questions raised in the issue discussions, alongside macro expansion and process launches. The answers below keep the reported outcome and commit where available; the linked discussions retain the reproductions, command order and file arrangements needed to understand those outcomes.

Can Relax reuse compiled caches across workspaces without returning another workspace's paths?

Laotree reports that result on PR #206's branch in issue #170. The copied CLI stack created zero new identities, and the manifest-directory example printed each workspace's own path. The useful distinction is between reusing compiled identities and returning the right observable value: this report addresses both in the named branch exercises, including the workspace-dependent CARGO_MANIFEST_DIR value.

Can switching between relax run and relax test cause incorrect cache reuse?

Issue #142 reports incorrect value reuse and replayed diagnostics, followed by successful retests. Laotree reports both standalone orders passing on c2c5fc7e and the app sequence clean on 2fc616c3. The earlier app sequence produced 195 E0119/E0592 diagnostics; the later sequence produced zero. Command order and cache state are part of this reproduction, alongside the application's dependency graph.

Why does an inner closure using an outer closure's reference parameter fail under Relax when rustc accepts it?

Issue #77 records false E0373 and a segmentation fault, then identifies 7450404 as the repair. art-shen's corrected retest printed [10], matching rustc, after discovering the stale executable. Adding move to the inner closure was the original workaround; the later result concerns the original program executed with the intended rebuilt Relax binary.

Why does tinyvec's impl_mirrored macro report a local ambiguity in Relax?

Issue #37 associates the ambiguity with empty visibility fragments and reports a repair through 428faa2f. The follow-up records tinyvec execution and objc2-foundation checking on c2cc38b5. A hand-written single-file copy had worked while the dependency failed. That contrast makes the dependency's crate context a necessary part of understanding the original macro-expansion failure.

Why does deny(unsafe_code) reject bytemuck derives under Relax?

Issue #238 reports that Relax treated unsafe implementations generated by external derives as caller code. The maintainer reports the fix in c5f7716f74, changing treatment of generated procedural-macro tokens while continuing to lint tokens passed through from macro input. The report concerns lint provenance for derives such as bytemuck's Pod and Zeroable, rather than the background borrow-checking setting.

Can Relax compile faer's Mat::as_ref without an internal compiler error?

The issue #240 synthesis reports the lifetime-region repair in 5b24d3c291 for faer 0.24.4's Mat::as_ref. The maintainer also reports adding missing AArch64 floating-point reduction intrinsics raised through pulp. The original run contained both the fatal internal compiler error and additional intrinsic messages, which explains why the response addresses two separate compiler problems.

Why does format! fail when a local alloc module is in scope?

Issue #239 reports a local alloc module interfering with the macro path and remains open. The initial reproduction passes under cargo test but fails under Relax; the synthesis records a later dependency-free reduction. Removing the import or moving formatting helped the original example. Those workarounds change its source arrangement rather than documenting a general compiler repair.

Can a Relax JIT test re-execute itself through an external shell?

moorbrook reports the shell case passing on 04f19e9f in issue #139. The same comment records remaining failures in artifact discovery and forwarded test relaunch. Direct launch, shell launch and forwarding through a package binary are separate process chains in that discussion, and the passing shell result applies to its particular chain.

Why is a generated macro re-exported from another source file reported as unsupported?

Issue #128 identifies cross-file registration as the missing link and names ddff0959 as the fix. The contributor reports the three-file example printing 1 on 04f19e9f. The same shape worked in one file. Its application example reached icu_locale_core during GUI startup, connecting the small reproduction to the reported desktop application's failure.

Is full AVX-512 support welcome in Relax?

makepaddev explicitly welcomes x86 SIMD coverage through AVX-512 in issue #154. The response asks for small pull requests grouped by instruction family and differential tests against rustc, including edge values. The contributor's trial work distinguishes instructions expressible with the current model from fp16/bf16 operations needing primitive types and operations involving system state.

What we have not tested yet

Our checks cover a successful build and a failed cargo test command at 5dc818e. The visible tail omits the individual causes of the six wasm_backend failures and the actual Rust and operating-system versions; lab-rust:1 is an image label. The Compose refusal supplies no application-runtime result, and its contradictory summary cannot support deployment or port-binding claims. No command or quick-start example was executed for this revision.

Our repository checks did not reproduce contributor GUI sessions, live patching, process-launch routes or individual compatibility repairs. PR #206's merge and release availability are unconfirmed here, and its proposed permission design was not audited. The readable cache excerpts do not resolve the detailed mechanism behind incorrect constant-value reuse. We have no independent latency, steady-state performance, runtime-memory or memory-safety comparison with rustc or Cranelift.

The SIMD discussion and repaired examples do not demonstrate full instruction or crate compatibility. Cranelift's README separately lists partial std::arch support and experimental panic unwinding, unsupported on Windows and macOS. GitHub counts do not measure adoption or support capacity. Existing review-page contents, rendered layout, related links and recommendation modules were outside this review. A next evaluation should retain rustc as a control and record the executable while exercising application startup, test-to-run order, workspace moves and required process launches.

Alternatives

ProjectWhat it isPick it when
Rust with Cargo gh↗The Rust compiler, standard library and documentation, used with Cargo for package builds.Choose it for release builds, as Relax recommends, and as the compatibility control used in the issue reports.
rustc_codegen_craneliftAn alternative code-generation backend for the Rust compiler, distributed in nightly builds.Consider it for exploring different debug code generation within the Rust compiler, subject to its documented feature support.

What people are saying

  1. [velocity-scout] makepad/relax

Sources

  1. Relax README and experimental-use warning
  2. Rust compiler repository
  3. Rust Cranelift backend README
  4. Relax public repository facts
  5. Workspace cache design and branch results, issue #170
  6. Cache correctness history, issue #142
  7. Open alloc macro-path reproduction, issue #239

More dev tools reviews