Scarp v0.0.5-alpha.3

Scarp v0.0.5-alpha.3

Source commit: 7715c28df09c7703b39e14fddb963275b25df476

Scarp documentation

Scarp v0.0.5-alpha.2

Scarp v0.0.5-alpha.2

Source commit: e4db8e191cd7ea623123cae7348450ca6c95b170

Scarp documentation

Scarp v0.0.5-alpha.1

Scarp v0.0.5-alpha.1 — source modules candidate

Status: unpublished experimental development candidate. No tag, release request
or draft authorizes publication. The latest published prerelease remains
v0.0.4-alpha.4.

The next version is 0.0.5-alpha.1 rather than 0.0.4-alpha.5 because this
milestone adds language-level program organization and explicit public source
loading APIs after the 0.0.4 numerical series. It remains experimental; this is
not a stability or production-readiness claim.

Implemented

• Relative .srp imports with explicit aliases and qualified public functions
  and immutable scalar literal constants. Private helpers, typed symbols,
  named/default arguments, purity, needs/ensures and local mutual references
  integrate with the existing resolver and immutable runtime.
• Separate bounded graph discovery, linking, checking and execution APIs.
  Filesystem and in-memory loaders keep I/O out of the lexer/parser. Compiled
  module programs own their sources and support independent concurrent execution.
• Canonical source deduplication, cycle detection, relative path/root checks,
  bounded reads and independent file/depth/source/import/expansion limits.
• Source-aware E0037–E0043 diagnostics, cross-file parameter locations and runtime
  traces. Existing diagnostic codes, single-file semantic errors, seven CLI
  resource flags, numerical behavior and atomic output are preserved.
• A three-file numerical example, exact diagnostic fixtures, public API/CLI
  regressions and a beginner import tutorial. Introductory docs now distinguish
  published alpha.4 from this development candidate.

cargo run --locked --offline -- run examples/module_demo.srp
cargo run --locked --offline -- check examples/module_demo.srp

Compatibility and limits

Ordinary single-file source remains supported. import, pub and as are
contextual identifiers. Public Rust syntax enums gain import/export and dot
variants; exhaustive matches need updating. Existing source-string APIs do not
perform implicit I/O and direct module declarations to the new explicit APIs.
Public Span and Diagnostic layouts remain intact; module errors add an owned
source-map wrapper.

Libraries are declaration-only. Exported values are scalar literals, not runtime
globals, vectors or tiles. Imports cannot be re-exported. Cyclic module graphs,
packages, network loading, user-defined structures, native compilation and LSP
are deferred. Source limits are logical caps, not a process-memory guarantee.
The filesystem loader assumes a trusted tree and is not a race-proof sandbox
against concurrent hostile filesystem mutation. See modules.

Rust 2021, minimum Rust 1.74, no external Rust dependencies, Apache-2.0,
publish = false and unsafe_code = "forbid" remain unchanged.

Candidate verification and publication

The required gates remain formatting, strict Clippy, debug/release tests, build,
warnings-as-errors Rustdoc, check scripts, examples, documentation checks, both
benchmark smoke suites, four hosted Rust jobs and three native package jobs.
Candidate evidence must name its exact source SHA and actual completed runs.
Packages retain Windows x64 MSVC, Linux x64 GNU and macOS ARM64, checksums,
extraction smoke tests and exact-source verification. Required package contents
now include the module guide, tutorial, specification and nested library files,
in addition to the inherited alpha.4 files.

Before publication, obtain fresh maintainer approval for this exact version and
fully verified source SHA. Only then may a reviewed release request enable the
existing guarded publisher. Previous alpha.4 approval does not authorize this
candidate. Published tags/assets and historical release notes remain unchanged.
No website or GitHub Pages deployment is included.

Scarp v0.0.4-alpha.4

Scarp v0.0.4-alpha.4 — numerical and runtime candidate

Status: unpublished experimental prerelease candidate, prepared 1 November 2026.
The source version is not publication evidence. No alpha.4 tag or release request
has been created. Exact version/source approval follows all verification gates.

Numerical additions

• Immutable tile values with explicit row/column counts, row-major visible
  cells, shape-aware equality, stable display and typed funcra signatures.
• tile, height, width, cell, lane, unroll and turn, adapted from
  PR #53 onto current vector windows and cumulative allocation accounting.
• matvec, matmul, tileadd and tilescale for bounded linear algebra.
  All dimensions, output sizes and work estimates use checked arithmetic.
• The post-alpha.3 main additions: shared window, materializing stitch,
  logsumexp, logsoftmax, stable score selection, crossentropy, logprob,
  lossgrad and onehot. Existing vector kernels retain their behavior.
• Seven tested executable demonstrations cover inference, linear composition,
  score decoding, softmax/loss, one-hot targets, forward computation and windows.

Tiles have at most 65,536 finite binary64 cells, and each axis is in 0..=65536.
Empty axes remain part of value identity. (m,0)*(0,n) returns m*n positive
zeros under ordinary size/work/allocation caps. Matrix products use ordered
Neumaier compensation compatible with dot. Products, sums, compensation and
final cells must remain finite; cancellation cannot excuse intermediate overflow.
Subnormals and signed-zero storage follow existing scalar rules. There is no
broadcasting, implicit numeric conversion or mutable cell access.

Runtime and correctness

Compiler-planned scope retirement from PR #51 drops inaccessible values at block
exits and loop transfers. Function completion retires locals while retaining
parameters/results for postconditions. Defaults, recursion, terminal frame
replacement and output snapshots preserve immutable values. The test-only
must-initialization audit checks reachable plans, default/result dependencies,
slot indices, jumps and prematurely retired postcondition parameters; it is not
a proof covering all possible future language features.

Eligible terminal self-calls reuse slot, supplied-parameter and expression
buffers after outgoing argument evaluation. They retain existing initialization
work charges, defaults, needs checks, call limits and bounded source traces.
The measurement procedure and observations are recorded in
the performance guide; no cross-language speed claim is made.

Fresh buffers prepay cumulative numerical payload and native work before
reservation/loops. Matrix multiplication charges its full inner-product work
even for a one-cell result. Tile construction/unroll share visible storage;
lane/transpose/arithmetic allocate fresh charged payload. Zero-output kernels
skip empty nested loops. Selected tile output charges row delimiters as well as
cells, including zero-width shapes.

New fixtures verify dimension and cell spans, shape explanations and nested
funcra context. Existing E0015/E0017/E0024/E0029/E0030–E0036 meanings are
preserved; no new diagnostic codes were required. Both program streams remain
empty after semantic or budget failures.

Compatibility and limits

Existing source syntax, CLI command/option names, exit codes and Rust execution
entry points remain valid. Public Rust enums gain Tile and matrix built-in
variants, requiring updates to exhaustive matches. The package remains
dependency-free, Apache-2.0, edition 2021, Rust 1.74 minimum, publish = false,
and unsafe_code = "forbid".

The allocation ledger counts cumulative new element payload, not peak live
storage, parser/frame/container overhead or process RSS. A visible window/tile
can retain its entire backing allocation. Snapshot storage is a separate logical
quantity. This remains an interpreter for small numerical programs, without a
production BLAS, tensor framework, modules, autograd, GPU or native-code backend.

Build, packages and release gates

cargo build --locked --offline --release
cargo run --locked --offline -- run examples/matrix_forward.srp
cargo test --locked --offline

Native archive targets remain Windows x64 MSVC, Linux x64 GNU and macOS ARM64.
Use scripts/package.ps1 on each matching native toolchain; it builds, extracts
and tests the executable and every expected-output example. Archives include
guides, examples and an exact-source clean build record. Three archives, three
sidecar SHA-256 files and one SHA256SUMS manifest are required.

The final validation record must contain formatting, Clippy, debug/release tests,
build, Rustdoc, Windows/Unix validation, both benchmark smoke suites, four hosted
Rust jobs, three native package jobs and source/archive checksum verification
for the exact approved source. Current evidence and remaining gates are tracked
in the integration PR and engineering report; older draft-PR runs are insufficient.

The completed alpha.3 request is removed. A new reviewed request must contain
the explicitly approved full source_commit SHA. The existing publisher checks
both that source's exact-main CI/packages and the current control revision,
creates a new annotated tag only after gates, verifies a draft, publishes with
prerelease=true/make_latest=false, then checks all public downloads. Until
approval, there is no release request, tag, draft release or publication.

See tiles, memory lifetimes,
budgets, testing, and
release engineering.

Scarp v0.0.4-alpha.3

Scarp v0.0.4-alpha.3 — Numerical Functions and Bounded Memory Control

Experimental prerelease candidate. The GitHub release page must be checked for
actual publication status, exact commit and verified downloads:
https://github.com/sanskarIN/scarp-lang/releases/tag/v0.0.4-alpha.3

Included in the source and expected native packages

• New pure numerical functions norm(vector) -> float and
  normalize(vector) -> vector. The scaled L2 implementation avoids
  unnecessary intermediate square overflow/underflow, while rejecting a
  nonrepresentable final scalar norm. Normalizing empty or all-zero vectors
  gives E0034; norm([]) yields +0.0.
• Terminal self-transfer in funcra: a direct
  return same_function(arguments); can replace the current function frame
  when that function has no ensures postconditions. Each logical call
  still counts toward the total-call and execution-step budgets, and
  preconditions/defaults run every invocation. Nonterminal calls and
  functions with postconditions retain ordinary frames. Selected errors
  retain bounded call traces; both output streams remain atomic on errors.
• New independent --max-vector-bytes for scarp run and scarp check,
  plus ExecutionOptions.max_vector_bytes and the Rust host helper
  numeric::evaluate_with_vector_limit. Default quota: 8,388,608
  cumulative newly reserved numeric payload bytes. It applies to new
  vector literals, fill/add/scale/clamp/softmax and normalize buffers.
  It does not double-count immutable references; prior allocations do not
  get refunded when a value leaves scope. E0036 reports quota exhaustion.
• The earlier ten alpha.2 numerical kernels, finite float/vector types,
  typed funcra contracts, iteration and other execution limits remain.
• Three new runnable exact-output examples: scaled_norm,
  terminal_recursion, and vector_allocation.
• Branch lifecycle housekeeping: maintain main, development, temporary
  release/* integration branches and focused feature PRs, and prune only
  inactive scarp/* heads fully contained in main after live ancestry
  and open-PR protection checks.

Example

bind v = [3.0, 4.0];
print(norm(v));
print(normalize(v));

Output:

5.0
[0.6, 0.8]

For a separate quota example:

scarp run --max-vector-bytes 24 examples/vector_allocation.srp
scarp check --max-vector-bytes 24 examples/vector_allocation.srp
scarp run --max-call-depth 1 examples/terminal_recursion.srp

Delivery and security gates

This release may publish only from an exact main source commit after
successful Rust source, formatting, Clippy, tests and documentation checks
on Linux/macOS/Windows plus minimum Rust 1.74, along with all three native
package jobs on the identical source SHA. Candidate archive contents and
SHA-256 digests are validated against source blobs before a draft is
published; public download digests are verified again before completion.
An unsuccessful or incomplete gate is not a published release.

Targets: Windows x64 MSVC, Linux x64 GNU and Apple Silicon macOS. Source
builds require Rust 1.74+, with Apache-2.0 licensing and no new external
Rust dependencies, general GC/ownership/pointer syntax or unsafe Rust.

API changes and limitations

The public Rust ExecutionOptions struct gains a required
max_vector_bytes field for hosts constructing exhaustive literals.
Using ExecutionOptions::default() or struct update
..ExecutionOptions::default() requires no additional edit, and the
two-field ExecutionLimits remains unchanged. Rust enum additions and
resource counts remain experimental and are not guaranteed stable.

The new quota counts cumulative finite-vector element payload allocated
through the interpreter, not live heap, total process RAM, host-supplied
vectors, parser allocations, Vec/Arc overhead, strings, thread
stacks or OS buffers. It is not a sandbox or a custom low-level memory
management system. Execution remains interpreted: there is no LSP, package
manager, autograd, GPU backend, native codegen or general tensor engine in
this prerelease. Other independent experimental draft PRs remain unmerged.

Scarp v0.0.4-alpha.2

Scarp v0.0.4-alpha.2 — Numerical Computing Foundation

Experimental alpha prerelease, scheduled for 2026-10-31 at 10:00 AM IST
(04:30 UTC), with maintainer authorization. The
release page
records actual publication status and downloads. Publication cannot begin before
the requested time and must pass the exact-main source/package/asset gates.
Published v0.0.4-alpha.1 remains unchanged and does not include vectors.

Included

• Immutable finite binary64 vector literals, checked zero-based indexing and
  length, whole-vector replacement, shared value/output snapshots and equality.
• Vector parameters/results/defaults, named user arguments, recursion, pure
  kernels, needs/ensures contracts and bounded heap frames.
• Ten positional kernels: len, sum, mean, dot, mse, add, scale, clamp, fill and
  softmax. Fill order is float value then integer count; no implicit conversions.
• Compensated reductions, overflow-resistant mean/MSE and maximum-shifted
  softmax. Underflow/subnormals are allowed; nonfinite stored values/results fail.
• At most 65,536 elements per vector; prepaid work and allocation, fallible
  buffer reservation, per-vector output preparation and logical snapshot bytes.
• E0032–E0035 add length, bounds, domain and allocation diagnostics. E0001–E0031,
  all six execution option fields and run/check/tokens spellings are preserved.
• Three executable numerical examples with exact fixtures, an independently
  computed softmax reference and verified native/interpreted benchmarks.

See vectors,
the numerical tutorial,
error repairs,
embedding,
compatibility,
testing and
checkpoint validation.

pure funcra score(values: vector) -> float {
    return dot(values, values);
}
print(score(fill(0.5, 4)));

Exact stdout: 1.0 followed by LF. Existing user functions named after kernels
retain precedence, while local bindings keep their independent namespace.
Builtins require positional arguments; user functions still accept names/defaults.

Packages and validation gates

Candidate archives target Windows x64 MSVC, Linux x64 GNU on Ubuntu 22.04, and
Apple Silicon macOS on macOS 15. Source builds require Rust 1.74 or later.
No third-party dependency, unsafe code, installer or registry publication is added.

The existing workflow must build and smoke-test all 23 examples, both streams,
silent checks, vector/function calls and deliberate numeric/budget failures.
Verify the three native archives, their companion checksums and combined
SHA256SUMS against the exact final source SHA and every packaged Git blob.
Candidate artifacts are not evidence of public release. The scheduled request
opens on 31 October at 04:30 UTC and expires at 18:30 UTC (midnight after that
day in India). Retries are scheduled for 10:15 and 10:35 AM IST. GitHub may queue
scheduled jobs later; a closed window prevents tag/publication actions.

Required checks remain fmt, Clippy, debug/release tests, build, rustdoc, full shell
and PowerShell scripts, release-tool tests, minimum Rust and all three native
platforms. Review their actual run results in the milestone PR. Measurements and
limitations are in the performance guide.

Compatibility and remaining limits

Public token/AST/value/type enums and diagnostics gain vector variants. Exhaustive
Rust matches need updates. Integers and floats do not implicitly convert, arrays
are not mutable in place, and vector arithmetic uses kernels rather than operators.
Legacy scalar/function semantics and historical release files are preserved.

Work limits bound cumulative vector payload allocation; they do not bound all
parser/host/container memory. Snapshot caps count logical storage, not encoded
bytes. Native kernels use platform exponentials, so nontrivial softmax results
need tolerances. Ordered sum/dot can reject overflowing intermediates even when
later cancellation would make a result finite. No exact arithmetic is promised.

No tensors, differentiation, GPUs, native backend, bitwise stack, CLI rename,
imports, package manager, custom types or self-hosting. Future tensor design
should start from reviewed shape/stride/storage semantics and explicit memory
limits, not import the old experimental stack wholesale.

Scarp v0.0.4-alpha.1

Scarp v0.0.4-alpha.1 — Finite Floating-Point Scalars

Experimental prerelease, 2026-10-30. This adds finite binary64 scalars to the
typed-function system from beta.3. Existing tags and assets remain unchanged.
Syntax and Rust API compatibility remain subject to change. The
prerelease page
records publication status and native downloads. Publication uses explicit
maintainer authorization and successful exact-main source/package gates.

Included

• Finite IEEE-754 binary64 float scalars, decimal/scientific literals,
  inferred immutable/mutable bindings, assignment, negation, arithmetic,
  comparisons and numeric equality. Plain integer literals remain signed i64.
• Typed float parameters, results and defaults in existing funcra declarations,
  positional/named calls, recursion, purity and needs/ensures contracts.
• A private checked FiniteFloat Rust wrapper rejects NaN and either infinity.
  Arithmetic overflow is diagnosed before storing a nonfinite result.
• Both signed zeros are observable in output and host bits, compare equal, and
  are rejected as divisors with E0008. Subnormal results and underflow to signed
  zero are allowed. Binary arithmetic rounds; decimal fractions are not exact.
• Locale-independent shortest round-trip output with a float marker: 1.0,
  -0.0, and scientific notation where appropriate. Fixed/scientific selection
  follows Rust's float formatter and is not a separate cross-version guarantee.
• E0030 for malformed or nonfinite literals, E0031 for nonfinite arithmetic.
  Existing E0001–E0029 assignments and source-linked call traces are preserved.
• All six budgets, heap call frames, silent check, stored output snapshots,
  and atomic validation of stdout/stderr remain in force. Source, evaluation,
  contract and budget failures replay no program output. Sink I/O can fail after
  earlier bytes; logical budgets do not bound all process memory or parsing.
• Twenty exact-output examples, including Newton root refinement and exponential
  smoothing. Native smoke tests exercise floats, streams and deliberate failures.

pure funcra blend(value: float, target: float, weight: float = 0.25) -> float
    needs weight >= 0.0 and weight <= 1.0;
{
    return value + (target - value) * weight;
}
print(blend(10.0, 20.0), blend(weight: 0.5, target: 20.0, value: 10.0));

Exact stdout: 12.5 15.0 followed by LF. See
floats,
functions,
budgets, and the
implementation audit.

Compatibility from beta.3

Existing integer, string, boolean, binding, output, function and CLI behavior is
preserved. Numeric operands must share a type: 1 + 0.5 is a type error; use
1.0 + 0.5. Bindings infer one fixed type. There are no casts or new local
type-annotation syntax. float is a contextual type name, not a reserved binding
word. 1., .5, 1e, and 1.2.3 are rejected with E0030; 1e309 is a valid
token whose magnitude is rejected during parsing. tokens remains lexical.

Rust hosts must handle new Float variants in public token/AST/value/type enums
and the two new diagnostics in exhaustive matches. Value::as_float() returns
an optional finite f64 copy; FiniteFloat::new() is the checked constructor.
Legacy integer expression entry points keep their i64 result. See
compatibility
and embedding.

Native packages and commands

The native package workflow targets Windows x64 MSVC, Linux x64 GNU on Ubuntu
22.04, and Apple Silicon macOS on macOS 15. No Intel macOS, Windows ARM64,
installer or registry package is included. Source builds require Rust 1.74 or
later; running an extracted binary does not require Rust. Zero third-party
Rust dependencies, unsafe-forbid policy, and publish = false remain unchanged.

Expected archive names use scarp-0.0.4-alpha.1- followed by
x86_64-pc-windows-msvc.zip, x86_64-unknown-linux-gnu.tar.gz, or
aarch64-apple-darwin.tar.gz. Each has a companion .sha256; SHA256SUMS
combines all three. The prerelease page provides these seven files after publication.
Archives include the executable, license, guides, all examples/fixtures and a
clean BUILD-INFO.txt with exact commit, compiler and native target. Checksums
detect corruption; archives are not promised byte-identical across build hosts.

./scarp --version
./scarp run examples/float_refinement.srp
./scarp run examples/float_smoothing.srp
./scarp check --max-calls 1000 examples/float_refinement.srp

Expected version: scarp 0.0.4-alpha.1. Use ./scarp.exe on Windows. Existing
run, check and tokens spellings are preserved; no CLI rename is included.

Validation and remaining scope

The feature audit records the accepted
feature's exact-main source/package runs and local regression evidence. The
release preparation must separately pass fmt, Clippy, debug/release tests, build,
rustdoc, both check scripts, release-tool tests, Rust 1.74 and stable native CI.
Verify all three downloaded archives against that final source's Git blobs,
build records, permissions and SHA-256 before considering an alpha release.
See release preparation
for the authorization and asset gates.

Vectors, tensors, automatic differentiation, GPUs, casts, numerical built-ins,
bit operations, native compilation, CLI redesign, imports, package management,
custom types and self-hosting are excluded. No native performance-parity claim
is made. Numerical vectors are the recommended next separate milestone after
successful scalar integration and explicit scope review.

Scarp v0.0.3-beta.3 — Typed Functions

Scarp v0.0.3-beta.3 — Typed Functions

Experimental prerelease, 2026-10-29. This publishes the typed funcra function
system integrated into main after beta.2, with CLI resource controls, updated
guides, and stronger native-package verification. Syntax and Rust APIs remain
experimental. The temporary 0.0.4-dev integration identifier was never a public
release; beta.3 is the next requested sequential public beta. Existing tags and
assets remain unchanged.

Included

• Typed file-level funcra declarations with integer, string, boolean, and unit
  results, explicit returns, lexical isolation, and immutable parameters.
• Forward calls, recursion and mutual recursion, positional/named/default
  arguments, source-order argument evaluation, and static return-path checking.
• Verified pure funcra declarations and executable boolean needs / ensures
  contracts. Postconditions inspect result. These are runtime checks, not proofs.
• Heap-managed call frames, bounded source call traces, immutable signature and
  call-graph metadata, and function calls in saved repeat counts.
• CLI --max-call-depth, --max-calls, --max-live-slots, and
  --max-capture-bytes, alongside existing work/output limits. Both run and
  check enforce all six, including snapshot caps for programs without calls.
• Resource failures identify the exhausted budget, configured cap, and CLI/API
  control. Source, type, arithmetic, contract, and budget failures discard
  pending stdout and stderr. Sink failures may leave earlier bytes.
• Native archives test all 18 exact-output examples, separate streams, deliberate
  failures, and CLI resource boundaries. Verification compares bundled root
  documentation, all guides, and all examples with exact release Git blobs.

pure funcra scale(value: integer, factor: integer = 2) -> integer
    needs factor > 0;
    ensures result == value * factor;
{
    return value * factor;
}

print(scale(6), scale(factor: 3, value: 7));

12 21

See functions, budgets, and
the language reference for complete rules.

Run after extraction

The prerelease page
provides three native archives, their .sha256 files, and SHA256SUMS:

Archive suffix	Native platform
x86_64-pc-windows-msvc.zip	Windows x64 MSVC
x86_64-unknown-linux-gnu.tar.gz	Linux x64 GNU, built on Ubuntu 22.04
aarch64-apple-darwin.tar.gz	Apple Silicon macOS

Verify the matching checksum before extracting. Archives include the executable,
license, guides, examples/expected output, and BUILD-INFO.txt with the full
version, exact source SHA, compiler, native target, and clean working-tree state.
No installer, registry package, Intel macOS, or Windows ARM64 binary is provided.
Checksums detect corruption; they are not signatures.

./scarp --version
./scarp run examples/functions.srp
./scarp run examples/function_contracts.srp
./scarp run --max-call-depth 512 examples/function_recursion.srp
./scarp check --max-capture-bytes 1048576 examples/functions.srp

Use ./scarp.exe on Windows. Expected version: scarp 0.0.3-beta.3.
Rust 1.74 or later is required only for source builds; there are no third-party
Rust dependencies and publish = false remains set.

Compatibility from beta.2

Existing bind/var, output, loop, and arithmetic semantics and command spellings
are preserved. println remains an exact alias. run, check, and tokens
remain the commands; compile, exec, verify, and inspect are unsupported.

Function words funcra, pure, return, needs, and ensures become reserved
binding names. Unknown call names now report E0023. E0001–E0019 keep their
assignments; E0020–E0029 add function/contract/resource diagnostics. Rust hosts
with exhaustive public enum matches must handle the new function, call, return,
token, and unit variants. See compatibility.

Existing entry-point signatures and two-field ExecutionLimits literals remain
valid. Old entry points use additional default caps: 256 active user frames,
100,000 cumulative calls, 1,000,000 live slots, and 16 MiB logical output snapshot
storage. Programs without functions also use slot/snapshot caps. Hosts needing
different limits can use additive ExecutionOptions APIs; CLI users can set
all six budgets. Logical execution limits do not bound all parser allocations
or total process memory.

Scope and validation

This release adapts only the function core from the older experimental stack.
Decimals, vectors, bit operations, numerical built-ins, C/native compilation,
and the redesigned CLI remain separate. There are no closures, first-class or
nested functions, imports, custom types, standard library, package manager, or
self-hosting. Function execution is interpreted; native performance parity has
not been established.

Publication requires successful exact-final-main Rust checks on Windows, Linux,
macOS and Rust 1.74, plus all three native package jobs. A separate publisher
checks those seven jobs, archive hashes/source records, every packaged source
file, and draft downloads before publishing an annotated tag and prerelease.
All seven public asset URLs are then downloaded without credentials and checked.
See release preparation for the process and
the validation record for baseline/local evidence.

Scarp v0.0.3-beta.2 — Variables and Output Polish

Scarp v0.0.3-beta.2 — Variables and Output Polish

Experimental prerelease, 2026-10-28. This publishes the reviewed main declaration
and output changes after v0.0.3-beta.1, plus focused variable diagnostic repairs.
No new language feature is introduced in this maintenance pass.

Included

• Immutable bind and mutable var declarations with the existing scope,
  shadowing, primitive typing, checked arithmetic, and value-snapshot rules.
• Canonical print, raw write, explicit eprint/ewrite, zero/multiple
  arguments, and optional trailing commas. println remains an exact alias.
• Explicit dual-writer library APIs and CLI routing. Selected output is prepared
  before either stream receives bytes; source/runtime/budget failures discard it.
• Contextual repairs for incomplete declarations and assignments, with unchanged
  error codes and precise spans. More specific expression errors keep their help.
• Reviewed while/repeat loops, nearest-loop break/continue, saved repeat counts,
  default work/output budgets, and all five existing string escapes.

bind step = 2;
var total = 0;
repeat 3 as index {
    total += step;
}
write("total: ");
print(total);

Exact stdout: total: 6\n. scarp check evaluates this program silently.

Upgrade from beta.1

Replace declaration tokens let with bind and let mut with var.
Legacy declarations produce E0005 and migration help before output. Strings and
comments retain their text. See the migration guide.
The original v0.0.2 examples remain preserved as exact historical fixtures.

Use print for ordinary line output and write to continue the same line.
Adjacent arguments display with one ASCII space. Generated line endings are LF
on every platform. Empty raw writes emit nothing but still count against the
selected-output budget. See output and budgets.

Existing single-writer Rust entry points retain their signatures. A selected
nonempty stderr event requires the additive dual-writer API and otherwise fails
before stdout. Writer failures during replay can leave earlier bytes. Syntax
hosts must update Statement::Let to Statement::Declaration and handle the
additive Statement::Output, OutputTarget, and TokenKind::Comma variants.

Commands remain run, check, tokens, help, and version. This package supports
checked signed i64, strings, and booleans. Functions remain on the separate
development stack in PRs #27 and #37. Their diagnostic improvements are not
included in these main binaries. Floats/vectors, native compilation, closures,
and the CLI redesign also remain outside this release.

Downloads and verification

The prerelease
contains native archives for Windows x64 MSVC, Linux x64 GNU (Ubuntu 22.04), and
Apple Silicon macOS. Each archive includes the binary, license, documentation,
all 15 examples and expected outputs, and a build record containing version,
target, compiler, clean source state, and the exact release commit.

Three .sha256 files and the combined SHA256SUMS cover the three archives.
Use sha256sum --check on Linux, shasum -a 256 -c on macOS, or compare
Get-FileHash -Algorithm SHA256 on Windows. Checksums detect corruption and are
not signed provenance attestations. The annotated tag and build records identify
the reviewed source; packages are taken only from its successful native jobs.

./scarp --version
./scarp run examples/output.srp
./scarp check examples/repeat.srp

Use ./scarp.exe on Windows. Expected version: scarp 0.0.3-beta.2.
The raw-output example ends in done without a final newline. check succeeds
silently. Source builds retain Rust 2021, Rust 1.74 minimum, zero third-party Rust
dependencies, forbidden unsafe code, Apache-2.0, and publish = false.

Earlier published tags and packages remain unchanged. This is not stable
v0.0.3 and does not publish a package-registry crate.

Scarp v0.0.3-beta.1 - Iteration & Safe Execution

Scarp v0.0.3-beta.1 — Iteration & Safe Execution

Experimental beta, 2026-10-27. This is a prerelease, not stable v0.0.3.

Included

• The reviewed while/break/continue implementation from PR #16, integrated through
  #28 while preserving the published v0.0.2 notes and original feature branches.
• New repeat count as index counted loops with a saved integer count, immutable
  zero-based exclusive index, fixed storage, and nearest-loop control.
• Fresh deterministic limits: 1,000,000 work steps and 100,000 selected prints,
  with --max-steps / --max-prints for run/check and existing embedding APIs.
• Tab \t and carriage-return \r string escapes alongside backslash, quote, LF.
• Clear loop/count/index/budget diagnostics, contextual CLI help, iteration and
  budget guides, exact diagnostic fixtures, and raw-byte package verification.

let mut total = 0;
repeat 5 as index {
    total += index;
}
println(total); // 10

The count is evaluated once before binding the index. Zero skips execution but
still type-checks the body. Negative counts fail with E0019. Continue advances a
repeat index or reevaluates a while guard; break exits the nearest loop. All
source/runtime/budget failures leave program output empty before replay. Writer
failures can leave earlier bytes. See iteration and
budgets for scope, work accounting, and examples.

Compatibility and exclusions

Keep let, let mut, println, and scarp run/check/tokens. Check evaluates
selected arithmetic and loops silently; tokens only lexes. Existing v0.0.2
example sources and expected bytes are preserved and checked by a digest manifest.
Repeat/as stay contextual identifiers, including existing assignments to repeat.
Existing embedding function signatures and ExecutionLimits literals remain valid.
Public AST/diagnostic enum additions require exhaustive Rust match updates.

The default execution limits also bound previously unbounded programs. Print
limits bound selected statements, not string byte length. Limits do not bound
parse memory or act as a general sandbox. Both new escapes produce literal
control bytes; there is no interpolation or formatting system.

This beta excludes funcra/functions/closures, floats/vectors, bit operations,
native C/executable/object compilation, project/package managers, bind/var,
print/write/explicit stream syntax, and the exec/verify/inspect CLI redesign.
Those experimental branches remain separate. There is no stable v0.0.3 release
or package-registry publication.

Downloads and verification

Use the v0.0.3-beta.1 prerelease.

Archive	Platform
scarp-0.0.3-beta.1-x86_64-pc-windows-msvc.zip	Windows x64 MSVC
scarp-0.0.3-beta.1-x86_64-unknown-linux-gnu.tar.gz	Linux x64 GNU, built on Ubuntu 22.04
scarp-0.0.3-beta.1-aarch64-apple-darwin.tar.gz	Apple Silicon macOS

Each archive has a .sha256 file. SHA256SUMS combines all three digests.
Linux: sha256sum --check <archive>.sha256; macOS:
shasum -a 256 -c <archive>.sha256; Windows: compare
(Get-FileHash ./<archive> -Algorithm SHA256).Hash with the checksum file.
These are corruption checks, not signed provenance attestations.

Every package contains the binary, license, guides, all example sources/outputs,
and BUILD-INFO.txt recording version, target, exact commit, compiler, and clean
source state. Packages must come from the final reviewed main commit's successful
platform workflow, then pass checksum/source-record verification before upload.
Rust checks cover Windows/Linux/macOS and minimum Rust 1.74; native package jobs
extract and execute all fourteen examples plus budget/help/error checks.

After extraction:

./scarp --version
./scarp run examples/repeat.srp
./scarp check --max-steps 2000000 examples/loops.srp

Use ./scarp.exe on Windows. Expected version: scarp 0.0.3-beta.1.
Repeat prints 8 and 0, each followed by LF; check succeeds silently.
Downloaded native binaries do not require Rust. Source builds require Rust 1.74
or later; the project retains Rust 2021, zero third-party Rust dependencies,
unsafe_code = "forbid", Apache-2.0, and publish = false.

Verified publication evidence

Source and annotated tag target: d26bb370baa3963cb8cbc0c2d1c17a9bc30e7618.
Final-main Rust checks
and native packages
passed all seven jobs on Windows/Linux/macOS and minimum Rust 1.74.
Local validation passed 412 Rust test executions and 10 Python release/compatibility
checks. All 14 package examples were verified; all 22 original v0.0.2 example
files retain their published bytes. All three archives and their uploaded copies
were checked against clean build records and the exact source commit.

Integrated PRs: #28 (reviewed #16 loop source), #29 (repeat), #30 (escapes),
#31 (diagnostics/help), #32 (original fixtures), #33 (beta preparation).
PRs #17–#20 and #22–#27 remain separate from this release.

SHA-256 archive digests:

2ee12791ee7b562e6e279b0e184a0e5600a29003f6dc09b9b03f7716927e9891  scarp-0.0.3-beta.1-aarch64-apple-darwin.tar.gz
467bc7cbc37fe11eff8e40ef4ac91bb9a01e90c451afb636ea2737e41ec5ab2a  scarp-0.0.3-beta.1-x86_64-unknown-linux-gnu.tar.gz
99370fed3782cfbcbf49774e73885249284551c185ab7adfdb755862eacd9011  scarp-0.0.3-beta.1-x86_64-pc-windows-msvc.zip