DCDart v0.1.3 — safety and Windows interoperability

DCDart v0.1.3 fixes four reproduced correctness problems:

• Misaligned atomic loads, stores and read-modify-write operations now deliberately trap before the access.
• Raw and packed memory accesses explicitly permit byte alignment instead of making an invalid LLVM alignment promise.
• Result.propagate() cleans up owned locals, weak references, owned parameters, and references held by unfinished calls, constructors, methods and assignments.
• Windows x64 Result arguments and returns now follow the C calling convention, including external and indirect calls.

The audit also corrects an outdated claim: unchecked nullable source access is already rejected by the frontend. Foreign pointer validity, read-only pointer provenance, text lifetimes, multi-object runtime linking and other recorded language gaps remain open; this release does not claim they are all resolved.

Validation: 54 conformance suites with zero failures/skips on macOS ARM64 and Linux x86-64/ARM64; backend and optimizer tests; packaged compiler execution on all four release hosts, including Windows aggregate interoperability. Native archives require Dart SDK exactly 3.12.2 and Clang/LLVM. Linux baseline is Ubuntu 24.04/glibc 2.39+. Windows linking requires Visual Studio C++ tools.

Install using the DotCorr Homebrew tap on macOS ARM64/Linux, or DotCorr Scoop bucket on Windows x86-64. Compiler hosts are distinct from generated-code targets. Existing iOS/Android target support is preserved; this release does not add device execution evidence or phone-hosted packages.

DCDart 0.1.2 — ownership and control-flow correctness

DCDart 0.1.2 fixes object-ownership errors and fills several everyday control-flow gaps while preserving the native iOS and Android targets introduced in 0.1.1.

• Release temporary objects after borrowed calls, constructor initialization, fresh receiver access, weak-reference operations, and discarded indirect calls.
• Honor method @owned parameters. Returning a borrowed parameter or strong field now acquires ownership before local cleanup; borrowed weak returns are diagnosed until weak-to-weak retain exists.
• Support boolean literals, general !, and short-circuit && / ||. Guarded division tests verify that skipped operands are never executed.
• Prevent the reproduced freestanding zero/copy loops from introducing undeclared libc dependencies through LLVM optimization.
• Accept both valid x86 sequential-consistency barrier forms in the fence test, retaining per-ordering and optimization checks.

Rebuild DCDart object files together when upgrading: returned managed-object ownership is corrected in this release.

Install on macOS ARM64 or Linux x86-64/ARM64:

brew tap dotcorr/tap
brew trust --formula dotcorr/tap/dcdart
brew install dcdart
# Existing installation: brew update && brew upgrade dcdart

Windows x86-64:

scoop bucket add dotcorr https://github.com/DotCorr/scoop-bucket
scoop install dotcorr/dcdart

Source compilation requires Dart SDK 3.12.2 and Clang/LLVM. Linux archives target Ubuntu 24.04 / glibc 2.39+. Windows native linking requires Visual Studio C++ tools. iOS and Android are generated-code targets, not phone-hosted compiler packages.

The language audit records all 65 existing gap entries and distinguishes fixes, remaining safety issues, feature work, and historical claims. This release does not claim complete Dart support or closure of every language gap.

Website and installation docs · Editable playground

Validation: 51 conformance suites, zero failures and zero skips on macOS ARM64, Linux x86-64, and Linux ARM64; backend and optimizer unit tests; native packaged-compiler ownership and boolean regressions on all four hosts including Windows x86-64. Release build evidence. The live hosted compiler reports 0.1.2 and passed real WASM ownership/short-circuit probes and browser edit/error/timeout tests.

DC Dart 0.1.1 — native iOS and Android targets

DC Dart 0.1.1 adds native compilation targets for iOS arm64, iOS Simulator arm64, and Android arm64. Device and simulator use distinct Apple platform triples; Android uses its Android ABI target. Existing desktop and bare-metal targets remain unchanged.

The compiler is development tooling. Its hosted Dart frontend is not linked into generated applications. This release supports DC Dart's existing low-level language subset; it does not promise full hosted Dart or arbitrary Dart packages without a VM.

Validation: mobile target tests and native-host regressions passed. One shared DC Dart source compiled and linked for all four targets. Five behavioral checks ran on macOS and iOS Simulator. Android arm64 linked as both executable and shared library with only libc/libdl dependencies. Android device execution was not performed.

Install the Darwin arm64 archive and keep its directory structure. Run core/dcc/bin/dcc --version to verify 0.1.1. Set DCDART_DART to an installed Dart SDK 3.12.2 executable; the frontend kernel format requires that version. Xcode/LLVM and Android NDK remain development toolchain prerequisites for their respective targets. The archive includes provenance and a SHA256 checksum file is attached.

Use --target ios-arm64, --target ios-simulator-arm64, or --target android-arm64 with dcc build --mode bare. --emit-header produces the C ABI header alongside the native object. See core/docs/mobile-targets-0.1.1.md and the committed mobile-native conformance harness for exact verification commands.

Distribution update — 13 September 2026

The official Homebrew tap now installs 0.1.1 on macOS ARM64 and Linux x86-64/ARM64:

brew tap dotcorr/tap
brew trust --formula dotcorr/tap/dcdart
brew install dcdart
# Existing installations: brew update && brew upgrade dcdart

Native Windows x86-64 is available in the official Scoop bucket:

scoop bucket add dotcorr https://github.com/DotCorr/scoop-bucket
scoop install dotcorr/dcdart

Additional Linux and Windows archives were built from the unchanged v0.1.1 compiler source. On Ubuntu 24.04 x86-64, Ubuntu 24.04 ARM64, and Windows x86-64, each packaged compiler compiled a DCDart sum function, linked it to a C host, and executed sumTo(100) = 4950. The build harness corrects Git Bash’s source-import path spelling during bootstrap; compiler source is unchanged. Each archive includes provenance and has a separate .sha256 asset. The original SHA256SUMS attachment covers the original macOS archive only.

Linux archives require glibc 2.39 or newer. All hosts require Dart SDK 3.12.2 and Clang/LLVM for compilation; native Windows linking also requires the Visual Studio C++ tools. iOS/Android remain output targets requiring Xcode/NDK development SDKs, not phone-installed compiler packages. No native Windows ARM64 or macOS Intel compiler archive is published in this release.

The macOS ARM64 Homebrew bottle is now published. Clean Homebrew (macOS and Linux) and Scoop (Windows) installations each compiled, linked, and executed a native check returning 97; see the installation check run. The updated website documentation includes all eleven targets and current installation commands.

DCDart v0.1.0 — initial public release

First public release of DCDart.

Highlights

• Native AOT compiler: dcc build --mode bare compiles DCDart source to real object files (ELF, Mach-O, COFF) through the DC-IR pipeline and LLVM. No VM, no interpreter, no JIT.
• ARC memory management with compile-time elision and a local cycle collector — retain/release you can count with dc-objdump --arc.
• Ten codegen targets, including freestanding bare-x86_64 for kernel work: zero undefined symbols, enforced mechanically on every change.
• C ABI at every boundary: --emit-header writes a C header for FFI, so C, Rust, and Python can call into compiled DCDart directly.
• Verified: all 48 conformance suites pass on Darwin/arm64 (hosted link mode).
• The full design-decision record is public: 72 ADRs, 13 escalations, and the known-gaps ledger — including the benchmarks that were rewritten when the numbers were initially dishonest.

Install

Homebrew (macOS, Apple Silicon):

brew tap dotcorr/tap https://github.com/DotCorr/homebrew-tap
brew install dotcorr/tap/dcdart

Then compile a program (pass the shipped prelude — its path is matched lexically, so spell it the same in your import):

dcc build --mode bare --target host main.dart -o main.o --emit-header main.h \
  --prelude $(brew --prefix)/opt/dcdart/libexec/core/runtime/dc-core-bare/prelude.dart

Tarball: dcdart-v0.1.0-darwin-arm64.tar.gz — a self-contained AOT dcc binary plus the freestanding prelude. Extract and run core/dcc/bin/dcc build --mode bare <source.dart> -o <out.o>. A Dart SDK 3.12.2 on PATH (or DCDART_DART) is required for the kernel-frontend stage.

License

Apache-2.0 with LLVM exceptions. The exception guarantees that programs compiled with dcc are entirely yours — no conditions of the license attach to the binaries you build and distribute.