nasa/spacewasmPublic

A flight-compliant WebAssembly interpreter.

AI summary: A flight-compliant WebAssembly interpreter developed by NASA for aerospace applications.

Stars
1.6K
+5 today
Forks
70
Watchers
9
Open issues
12
Open PRs
13
Contributors
~14
Commits
301
Branches
10

RustApache-2.0Created Jun 24, 2026Last push 1d agoLatest release v0.7.1+6 stars this week+21 this month

Quick answers

What is spacewasm?
A flight-compliant WebAssembly interpreter developed by NASA for aerospace applications.
What does spacewasm do?
SpaceWasm is a specialized WebAssembly (Wasm) interpreter engineered by NASA to meet the stringent requirements of spaceflight environments. It provides a secure, isolated runtime for executing Wasm modules on embedded systems and flight hardware. The interpreter is designed to be highly reliable, predictable, and compliant with aerospace software standards, ensuring that it can safely run dynamically loaded code or modular applications in orbit. By leveraging WebAssembly, SpaceWasm allows engineers to write mission logic in various high-level languages and compile it down to a universal, easily verifiable binary format for execution on spacecraft.
Who is spacewasm for?
SpaceWasm is intended for aerospace software engineers, embedded systems developers, and researchers building highly reliable systems for space exploration. Users must have a strong background in avionics software, WebAssembly, and systems programming.
How do I get started with spacewasm?
Review the repository documentation and CI workflows to understand the build and integration process.
How popular is spacewasm on GitHub?
nasa/spacewasm has 1,632 stars and 70 forks on GitHub, and gained 6 stars in the last 7 days.
What license does spacewasm use?
nasa/spacewasm is released under the Apache-2.0 license.

Star history

since Jul 31, 2026
05001K1.5KJul 2026Sep 2026Oct 2026Nov 2026
1.6K stars as of Nov 19, 2026. Measured daily since Jul 31, 2026; GitHub no longer exposes earlier star timestamps.

Contribution activity

commits per day, last 52 weeks
NovDecJanFebMarAprMayJunJulAugSepOctNovMonWedFri2025-11-16: 0 commits2025-11-17: 0 commits2025-11-18: 0 commits2025-11-19: 0 commits2025-11-20: 0 commits2025-11-21: 0 commits2025-11-22: 0 commits2025-11-23: 0 commits2025-11-24: 0 commits2025-11-25: 0 commits2025-11-26: 0 commits2025-11-27: 0 commits2025-11-28: 0 commits2025-11-29: 0 commits2025-11-30: 0 commits2025-12-01: 0 commits2025-12-02: 0 commits2025-12-03: 0 commits2025-12-04: 0 commits2025-12-05: 0 commits2025-12-06: 0 commits2025-12-07: 0 commits2025-12-08: 0 commits2025-12-09: 0 commits2025-12-10: 0 commits2025-12-11: 0 commits2025-12-12: 0 commits2025-12-13: 0 commits2025-12-14: 0 commits2025-12-15: 0 commits2025-12-16: 0 commits2025-12-17: 0 commits2025-12-18: 0 commits2025-12-19: 0 commits2025-12-20: 0 commits2025-12-21: 0 commits2025-12-22: 0 commits2025-12-23: 0 commits2025-12-24: 0 commits2025-12-25: 0 commits2025-12-26: 0 commits2025-12-27: 0 commits2025-12-28: 0 commits2025-12-29: 0 commits2025-12-30: 0 commits2025-12-31: 0 commits2026-01-01: 0 commits2026-01-02: 0 commits2026-01-03: 0 commits2026-01-04: 0 commits2026-01-05: 0 commits2026-01-06: 0 commits2026-01-07: 0 commits2026-01-08: 0 commits2026-01-09: 0 commits2026-01-10: 0 commits2026-01-11: 0 commits2026-01-12: 0 commits2026-01-13: 0 commits2026-01-14: 0 commits2026-01-15: 0 commits2026-01-16: 0 commits2026-01-17: 0 commits2026-01-18: 0 commits2026-01-19: 0 commits2026-01-20: 0 commits2026-01-21: 0 commits2026-01-22: 0 commits2026-01-23: 0 commits2026-01-24: 0 commits2026-01-25: 0 commits2026-01-26: 0 commits2026-01-27: 0 commits2026-01-28: 0 commits2026-01-29: 0 commits2026-01-30: 0 commits2026-01-31: 0 commits2026-02-01: 0 commits2026-02-02: 0 commits2026-02-03: 0 commits2026-02-04: 0 commits2026-02-05: 0 commits2026-02-06: 0 commits2026-02-07: 0 commits2026-02-08: 0 commits2026-02-09: 0 commits2026-02-10: 0 commits2026-02-11: 0 commits2026-02-12: 0 commits2026-02-13: 0 commits2026-02-14: 0 commits2026-02-15: 0 commits2026-02-16: 0 commits2026-02-17: 0 commits2026-02-18: 0 commits2026-02-19: 0 commits2026-02-20: 0 commits2026-02-21: 0 commits2026-02-22: 0 commits2026-02-23: 0 commits2026-02-24: 0 commits2026-02-25: 0 commits2026-02-26: 0 commits2026-02-27: 0 commits2026-02-28: 0 commits2026-03-01: 0 commits2026-03-02: 0 commits2026-03-03: 0 commits2026-03-04: 0 commits2026-03-05: 0 commits2026-03-06: 0 commits2026-03-07: 0 commits2026-03-08: 0 commits2026-03-09: 0 commits2026-03-10: 0 commits2026-03-11: 0 commits2026-03-12: 0 commits2026-03-13: 0 commits2026-03-14: 0 commits2026-03-15: 0 commits2026-03-16: 0 commits2026-03-17: 0 commits2026-03-18: 0 commits2026-03-19: 0 commits2026-03-20: 0 commits2026-03-21: 0 commits2026-03-22: 0 commits2026-03-23: 0 commits2026-03-24: 0 commits2026-03-25: 0 commits2026-03-26: 0 commits2026-03-27: 0 commits2026-03-28: 0 commits2026-03-29: 0 commits2026-03-30: 0 commits2026-03-31: 0 commits2026-04-01: 0 commits2026-04-02: 0 commits2026-04-03: 0 commits2026-04-04: 0 commits2026-04-05: 0 commits2026-04-06: 0 commits2026-04-07: 2 commits2026-04-08: 1 commit2026-04-09: 0 commits2026-04-10: 1 commit2026-04-11: 8 commits2026-04-12: 8 commits2026-04-13: 2 commits2026-04-14: 0 commits2026-04-15: 2 commits2026-04-16: 0 commits2026-04-17: 3 commits2026-04-18: 3 commits2026-04-19: 11 commits2026-04-20: 0 commits2026-04-21: 0 commits2026-04-22: 0 commits2026-04-23: 0 commits2026-04-24: 0 commits2026-04-25: 3 commits2026-04-26: 0 commits2026-04-27: 7 commits2026-04-28: 4 commits2026-04-29: 3 commits2026-04-30: 1 commit2026-05-01: 2 commits2026-05-02: 0 commits2026-05-03: 5 commits2026-05-04: 4 commits2026-05-05: 8 commits2026-05-06: 0 commits2026-05-07: 0 commits2026-05-08: 0 commits2026-05-09: 6 commits2026-05-10: 0 commits2026-05-11: 5 commits2026-05-12: 6 commits2026-05-13: 0 commits2026-05-14: 0 commits2026-05-15: 5 commits2026-05-16: 0 commits2026-05-17: 1 commit2026-05-18: 0 commits2026-05-19: 1 commit2026-05-20: 2 commits2026-05-21: 0 commits2026-05-22: 5 commits2026-05-23: 3 commits2026-05-24: 0 commits2026-05-25: 0 commits2026-05-26: 0 commits2026-05-27: 0 commits2026-05-28: 2 commits2026-05-29: 0 commits2026-05-30: 0 commits2026-05-31: 0 commits2026-06-01: 0 commits2026-06-02: 2 commits2026-06-03: 0 commits2026-06-04: 0 commits2026-06-05: 0 commits2026-06-06: 0 commits2026-06-07: 0 commits2026-06-08: 0 commits2026-06-09: 3 commits2026-06-10: 0 commits2026-06-11: 5 commits2026-06-12: 0 commits2026-06-13: 4 commits2026-06-14: 3 commits2026-06-15: 4 commits2026-06-16: 8 commits2026-06-17: 5 commits2026-06-18: 1 commit2026-06-19: 0 commits2026-06-20: 0 commits2026-06-21: 0 commits2026-06-22: 0 commits2026-06-23: 4 commits2026-06-24: 3 commits2026-06-25: 3 commits2026-06-26: 0 commits2026-06-27: 0 commits2026-06-28: 0 commits2026-06-29: 1 commit2026-06-30: 0 commits2026-07-01: 0 commits2026-07-02: 2 commits2026-07-03: 1 commit2026-07-04: 0 commits2026-07-05: 0 commits2026-07-06: 2 commits2026-07-07: 0 commits2026-07-08: 2 commits2026-07-09: 7 commits2026-07-10: 11 commits2026-07-11: 3 commits2026-07-12: 8 commits2026-07-13: 3 commits2026-07-14: 7 commits2026-07-15: 1 commit2026-07-16: 1 commit2026-07-17: 1 commit2026-07-18: 0 commits2026-07-19: 2 commits2026-07-20: 7 commits2026-07-21: 3 commits2026-07-22: 7 commits2026-07-23: 0 commits2026-07-24: 3 commits2026-07-25: 2 commits2026-07-26: 3 commits2026-07-27: 5 commits2026-07-28: 0 commits2026-07-29: 5 commits2026-07-30: 3 commits2026-07-31: 0 commits2026-08-01: 2 commits2026-08-02: 1 commit2026-08-03: 0 commits2026-08-04: 0 commits2026-08-05: 2 commits2026-08-06: 1 commit2026-08-07: 0 commits2026-08-08: 0 commits2026-08-09: 0 commits2026-08-10: 0 commits2026-08-11: 2 commits2026-08-12: 2 commits2026-08-13: 0 commits2026-08-14: 0 commits2026-08-15: 0 commits2026-08-16: 0 commits2026-08-17: 1 commit2026-08-18: 5 commits2026-08-19: 1 commit2026-08-20: 0 commits2026-08-21: 1 commit2026-08-22: 0 commits2026-08-23: 0 commits2026-08-24: 3 commits2026-08-25: 0 commits2026-08-26: 0 commits2026-08-27: 0 commits2026-08-28: 0 commits2026-08-29: 2 commits2026-08-30: 0 commits2026-08-31: 0 commits2026-09-01: 0 commits2026-09-02: 0 commits2026-09-03: 4 commits2026-09-04: 0 commits2026-09-05: 0 commits2026-09-06: 0 commits2026-09-07: 0 commits2026-09-08: 0 commits2026-09-09: 0 commits2026-09-10: 0 commits2026-09-11: 0 commits2026-09-12: 0 commits2026-09-13: 1 commit2026-09-14: 0 commits2026-09-15: 1 commit2026-09-16: 0 commits2026-09-17: 1 commit2026-09-18: 1 commit2026-09-19: 0 commits2026-09-20: 0 commits2026-09-21: 1 commit2026-09-22: 0 commits2026-09-23: 0 commits2026-09-24: 0 commits2026-09-25: 0 commits2026-09-26: 0 commits2026-09-27: 0 commits2026-09-28: 1 commit2026-09-29: 0 commits2026-09-30: 0 commits2026-10-01: 0 commits2026-10-02: 0 commits2026-10-03: 0 commits2026-10-04: 0 commits2026-10-05: 0 commits2026-10-06: 0 commits2026-10-07: 0 commits2026-10-08: 0 commits2026-10-09: 0 commits2026-10-10: 0 commits2026-10-11: 0 commits2026-10-12: 0 commits2026-10-13: 0 commits2026-10-14: 0 commits2026-10-15: 0 commits2026-10-16: 0 commits2026-10-17: 0 commits2026-10-18: 0 commits2026-10-19: 0 commits2026-10-20: 1 commit2026-10-21: 0 commits2026-10-22: 1 commit2026-10-23: 0 commits2026-10-24: 0 commits2026-10-25: 0 commits2026-10-26: 1 commit2026-10-27: 0 commits2026-10-28: 0 commits2026-10-29: 0 commits2026-10-30: 0 commits2026-10-31: 0 commits2026-11-01: 0 commits2026-11-02: 2 commits2026-11-03: 0 commits2026-11-04: 2 commits2026-11-05: 4 commits2026-11-06: 0 commits2026-11-07: 0 commits2026-11-08: 0 commits2026-11-09: 2 commits2026-11-10: 2 commits2026-11-11: 4 commits2026-11-12: 0 commits2026-11-13: 0 commits2026-11-14: 0 commits
301 commits in the last yearLessMore

Signals and awards

derived from tracked data
  • Actively maintained

    Pushed within 48 hours

  • Permissive license

    Apache-2.0

  • Continuous integration

    Automated checks passing

What spacewasm does

SpaceWasm is a specialized WebAssembly (Wasm) interpreter engineered by NASA to meet the stringent requirements of spaceflight environments. It provides a secure, isolated runtime for executing Wasm modules on embedded systems and flight hardware. The interpreter is designed to be highly reliable, predictable, and compliant with aerospace software standards, ensuring that it can safely run dynamically loaded code or modular applications in orbit. By leveraging WebAssembly, SpaceWasm allows engineers to write mission logic in various high-level languages and compile it down to a universal, easily verifiable binary format for execution on spacecraft.

SpaceWasm is intended for aerospace software engineers, embedded systems developers, and researchers building highly reliable systems for space exploration. Users must have a strong background in avionics software, WebAssembly, and systems programming.

  • Flight-compliant engineering: Architected and tested to meet the rigorous safety and reliability standards required for NASA spaceflight missions.
  • WebAssembly interpretation: Provides a robust runtime environment capable of executing standard Wasm binaries on specialized hardware.
  • Embedded system focus: Optimized for resource-constrained environments typical of avionics and satellite systems.
  • Language agnosticism: Allows mission software to be developed in languages like Rust, C++, or Go and compiled to Wasm for deployment.
  • Isolated execution: Ensures that Wasm modules run in a secure sandbox, preventing arbitrary code execution from crashing critical flight systems.

Where teams use it

In-orbit software updates

Mission operators securely transmit updated Wasm modules to a satellite to patch mission logic without requiring a full firmware rewrite.

Modular payload execution

Scientific instruments run distinct, isolated WebAssembly programs managed by the main flight computer to process data dynamically.

Cross-platform avionics

Aerospace engineers write critical control algorithms once in C++ and deploy them via SpaceWasm across vastly different hardware architectures.

Safe third-party code integration

Researchers upload experimental algorithms to an orbiting platform, relying on the interpreter's sandbox to protect the primary flight software.

Getting started: Review the repository documentation and CI workflows to understand the build and integration process.

README

main branch

SpaceWasm

license

SpaceWasm is an implementation of the WebAssembly specification meant to interpret Wasm binary on-board spacecraft. It is developed at NASA JPL Robotics.

SpaceWasm is the interpreter behind F´'s Svc::WasmSequencer, released in F´ v4.4.0. F´ is JPL's open-source flight-software framework and flew on the Ingenuity Mars Helicopter.

Rationale

  1. Command sequencing: High-level spacecraft activities are typically encoded outside of the embedded flight-software in command sequences. These activities can include anything from driving the Mars rover and operating its arm, to checking temperature ranges are nominal. Curiosity has executed more than 76,000 unique sequences on Mars. Historically, the form and capability of sequences has varied from mission to mission, even within JPL. Several deep-space missions use VML. Curiosity and Perseverance share a couple sequencing languages, and Europa Clipper has another. JWST uses JavaScript and Euclid uses MicroPython. SpaceWasm implements an industry standard, providing consolidation.

  2. Sandboxing: The cost and time of flight-software development is high due to its constrained requirements and scope. Validating a new flight-software capability often involves validating interactions with the entire system. This extends the V&V timeline and increases competition for testbed resources, which makes it hard to get new autonomy software into flight. WebAssembly gives the opportunity for untrusted or low-trust executables to make their way on-board in a way that flight-software can restrict access and compute time as well as monitor health and safety.

    On EO-1, the Autonomous Sciencecraft Experiment encountered two anomalies in flight. CPU load hit 100% against 80% on the testbed, which starved a memory-scrub task and triggered a fault response. Later, a new algorithm overwrote planner memory and the processor was restarted. Running those algorithms as separate Wasm modules prevents both failures. Flight software gives each module a fuel budget (REQ-5) and regains control when it's spent, so the memory scrub still runs. A load or store outside a module's linear memory traps instead of overwriting planner memory.

  3. Portability: WebAssembly provides well-defined interfaces and sandboxing that make transferring to another platform trivial. This includes platforms that flight computers typically target like PowerPC (the RAD750 on Perseverance), SPARC, ARM (the Snapdragon on Ingenuity), and RISC-V.

  4. Tooling: Standardizing to WebAssembly opens doors into a wide community of rich tooling and research! Most common languages (C, C++, Rust, Go, and others) can target WebAssembly and thus run in SpaceWasm. Despite the name, WebAssembly is not tied to the web.

Overview

This software comes with two major components:

  1. Decoder/Validator:

    Reads the Wasm binary in chunks and decodes it to an executable form. The decoder will use a fixed amount of memory and is intended to be measured per-Wasm binary on the ground using spacewasm validate, which reports the heap a module's load takes, section by section with --verbose.

    WebAssembly is validated during the decoding process and does not require another pass of the bytecode.

  2. Interpreter:

    A Wasm interpreter that can operate on linear memory and interface with hooks from the embedding.

SpaceWasm does not execute direct WebAssembly bytecode. Wasm bytecode is meant to be small and structured in a way to validate easily. These properties however make it slow to execute in-place. During the decoding process of Wasm instructions, SpaceWasm converts bytecode into another intermediate representation (IR) which includes properties better suited for interpretation. Read more about the IR in the specification.

Requirements

The requirements of SpaceWasm are levied from similar work produced by DLR.

See requirements.

SpaceWasm uses the Rust 2024 edition; the minimum supported Rust version is 1.87 (matching rust-version in Cargo.toml). Older toolchains fail to build with an edition2024 error.

Embedding

Embedding the interpreter refers to instantiating it and providing implementations for the functions that are imported into the module. Typically, the set of functions imported by the module are fixed and should be specified at compile time both for the Wasm module and the embedder.

For a reference embedding, see F´'s Svc::WasmSequencer (SDD), which drives SpaceWasm through the C API.

Dynamic Allocation

SpaceWasm has a unique dynamic memory allocation model. All of its design choices stem from requirements levied by common flight-software standards. Dynamic allocation follows the following rules:

  1. All allocations occur over a discrete number of fixed size blocks called pages. These pages are distinct from Wasm's linear memory pages.
  2. Deallocation cannot precede allocation.
  3. Sub-regions inside pages cannot grow or shrink, sizes should be fixed ahead of time.
  4. Memory usage must be deterministic.
  5. Any allocation failures must not result in panic.

The standard Rust allocation does not meet these constraints even with custom allocators. To that end, SpaceWasm provides its own data structures that guarantee these properties. These data-structures contain the bulk of the unsafe Rust semantics; the remainder lives in the performance-critical operand-stack, linear-memory, and IR access paths and the C FFI.

Note

These limitations are only enforced on the implementation of the interpreter and not on the Wasm bytecode it is made to interpret.

Wasm linear memory pages are allocated outside of dynamic memory pages.

Important

A consequence of this model is that a partially loaded module cannot be rolled back. Unlike the WebAssembly specification, module instantiation is not atomic: a failed module load leaves the engine unusable, and the embedder must discard and reconstruct it. See the API documentation for Module::new and spacewasm_load_module for details.

Streaming

Peak memory usage is often an important constraint on small systems found on spacecraft. Many Wasm interpreters require the Wasm binary to be given in one linear blob to the interpreter. This is typically fine for systems where the same regions of memory may be reused for different purposes. Flight software on spacecraft generally assign fixed portions of memory for certain purposes. Therefore, requiring the entire Wasm binary to fit into a single chunk of memory is not feasible.

SpaceWasm is highly optimized to reduce peak memory usage and not require deallocation after allocation required for streaming. To this end, there are certain constraints imposed on the WebAssembly specification.

SpaceWasm supports decoding and compiling Wasm binary in a single pass via a streaming mechanism. Chunks of the Wasm binary may be provided to the interpreter as they are read/requested from the filesystem. The stream must provide chunks synchronously.

Ground Tooling

The spacewasm command, from cargo install spacewasm_tools (or cargo binstall spacewasm_tools for a prebuilt binary), is the ground side of the interpreter: a Cargo linker that holds wasm-opt to exactly the proposals a release implements and splits debug info into a symbol file, a validator that loads a module as the flight interpreter would, and a resolver from the PCs a backtrace reports to source lines.

It also runs arbitrary modules that adhere to the WASI 0.1 (wasip1) spec in a sandboxed environment, with flags to mount host directories and set environment variables:

# compile example from crates/spacewasm_tools/tests/wasi/
$ clang --target=wasm32-wasip1 -mcpu=mvp hello_universe.c -o hello_universe.wasm

# rewrite what this release does not implement
$ spacewasm lower hello_universe.wasm

$ spacewasm run hello_universe.wasm
hello universe!

spacewasm trace runs a module's exports and prints the last instructions each executed, for debugging the interpreter itself; make trace feeds it a fuzzer seed. See the spacewasm_tools README for every command.

Interpreter Limitations

This Wasm interpreter imposes additional constraints beyond the WebAssembly specification to support resource-constrained spacecraft environments.

See our IR SPEC for the full list of limitations.

These constraints enable deterministic memory usage and efficient execution in resource-constrained environments while maintaining compatibility with most standard WebAssembly modules.

Limits for Wasm Module Producers

Because SpaceWasm compiles bytecode into a fixed-width IR that is typically larger than the original bytecode, the practical ceiling on raw module size is bounded by the IR code-page limit in the table below (~8 GiB of IR). This is far larger than any module expected on flight hardware; the binding constraint in practice is the peak memory configured for the streaming decoder, which is measured per-module on the ground with spacewasm validate: it loads the module against the flight configuration (--max-code-pages, --decoder-limits, --heap-page-size, --heap-pages) and reports the IR it compiles to and the global heap pages its load takes.

Here are a couple of limitations that may be relevant to developers of Wasm modules.

Limit Value Notes
Wasm page size 64 KiB / 1 B Custom-Page-Sizes proposal is supported
Linear memory pages 4 GiB Per the Wasm 1.0 spec. A module declaring more (or a max above this) is rejected. Note that the embedding will definitely limit this but it is dependent on how the interpreter is deployed.
IR Code 8 GiB Compiled IR, not raw bytecode. This limit is across all modules in the store. The IR / Bytecode ratio is printed by example as the "compilation ratio". It is difficult to estimate this upfront because it varies on the types of instructions used.
Function parameters 255 32-bit words Per function.
Local variables 65,535 32-bit words Per function.
Import name length 32 bytes Applies to each import's module name and field name; a longer name is rejected at decode time.
Custom section name 32 bytes The name of each custom section (e.g. the name section); a longer name is rejected at decode time.

Benchmarking

SpaceWasm is tested against the Coremark benchmark to trace performance regression. See coremark for more information.

Testing

Unit & Integration Tests

cargo test

The unit tests check for regressions on the unsafe container abstractions provided by SpaceWasm due to unique alloc usage. There are also simple unit tests that cover all Wasm instructions without needing full WAST execution.

The integration tests are spectests from the Wasm 1.0 MVP suite which was curated in https://github.com/WasmEdge/wasmedge-spectest. These tests validate the integrity of the Wasm interpreter against the specification.

Fuzzing

SpaceWasm includes a comprehensive fuzzing infrastructure using libfuzzer and wasm-smith.

# Run fuzzer
make fuzz

# Differentially test the validator against wasmi (SpaceWasm vs a reference)
make fuzz-validate-differential

# Analyze crashes with execution traces
make trace CRASH=fuzz/artifacts/no_traps/crash-xxx

Feature Support Matrix

Below is a table of the implemented and planned WebAssembly proposals with links to their tracking issue / implementation pull-request.

Feature Status
Wasm MVP All Versions
Mutable globals All Versions
Custom page sizes ≥0.2.0
Bulk memory operations Planned
Sign-extension operators ≥0.8.0
Non-trapping float-to-int conversions ≥0.8.0
SIMD Under Consideration
Multi-value Under Consideration
Multiple memories Under Consideration

Currently, all other proposals are not implemented, planned or considered.

Credits & Acknowledgments

Portions of this project are adapted from the open-source projects:

  • rust-lang/rust, which is dual-licensed under MIT OR Apache License 2.0.
  • DLR-FT/wasm-interpreter, which is licensed under the Apache License 2.0.
  • Wasmtime, which is licensed under the Apache License 2.0 with LLVM-exception.
  • WABT, which is licensed under the Apache License 2.0.
  • wasmedge-spectest, which is licensed under MIT.
  • WebAssembly Testsuite, which is licensed under the Apache License 2.0.
  • Coremark, which is licensed under the COREMARK ACCEPTABLE USE AGREEMENT.
  • Wasm Coremark, which provides no upstream license file; the wrapped CoreMark payload is governed by the COREMARK ACCEPTABLE USE AGREEMENT.
View on GitHub

Recent activity

commits and pull requests

Releases and announcements

24 total
  1. v0.7.1v0.7.1Sep 4, 2026

    ## What's Changed * Fix C header portability by @Kronos3 in https://github.com/nasa/spacewasm/pull/196 **Full Changelog**: https://github.com/nasa/spacewasm/compare/v0.7.0...v0.7.1

  2. v0.7.0v0.7.0Sep 4, 2026

    ## What's Changed * Pin CI Dependencies by @Kronos3 in https://github.com/nasa/spacewasm/pull/180 * Implement wast Action::Get by @Kronos3 in https://github.com/nasa/spacewasm/pull/181 * Missing tests by @Kronos3 in https://github.com/nasa/spacewasm/pull/182 * Add SIMD to 'planned' in README by @Kronos3 in https://github.com/nasa/spacewasm/pull/188 * Run integration tests with Miri by @h313 in https://github.com/nasa/spacewasm/pull/161 * Clean up code-base from external review by @Kronos3 in https://github.com/nasa/spacewasm/pull/189 * Clean up status and panics by @Kronos3 in https://github.com/nasa/spacewasm/pull/194 * Convert Vec<T> to Box<[T]> by @Kronos3 in https://github.com/nasa/spacewasm/pull/195 **Full Changelog**: https://github.com/nasa/spacewasm/compare/v0.6.4...v0.7.0

  3. v0.6.4v0.6.4Aug 24, 2026pre-release

    ## What's Changed * Enforce little endian for guest memory by @Kronos3 in https://github.com/nasa/spacewasm/pull/176 * Fix doc strings and clean up endianness constraints by @Kronos3 in https://github.com/nasa/spacewasm/pull/177 **Full Changelog**: https://github.com/nasa/spacewasm/compare/v0.6.3...v0.6.4

  4. v0.6.3v0.6.3Aug 19, 2026pre-release

    ## What's Changed * Allow br_table 1.0-vs-2.0 divergence in differential fuzzer by @myint in https://github.com/nasa/spacewasm/pull/174 * Reject else without if by @Kronos3 in https://github.com/nasa/spacewasm/pull/175 **Full Changelog**: https://github.com/nasa/spacewasm/compare/v0.6.2...v0.6.3

  5. v0.6.2v0.6.2Aug 18, 2026pre-release

    ## What's Changed * More Kani tests by @h313 in https://github.com/nasa/spacewasm/pull/168 * Add validate differential fuzzer by @myint in https://github.com/nasa/spacewasm/pull/169 * Expose C API for interacting with module globals by @Kronos3 in https://github.com/nasa/spacewasm/pull/172 * De-duplicate release notes by @Kronos3 in https://github.com/nasa/spacewasm/pull/173 **Full Changelog**: https://github.com/nasa/spacewasm/compare/v0.6.1...v0.6.2

Code frequency

additions and deletions
+124.2K-124.2KWeek of 2026-04-05: +5,580 linesWeek of 2026-04-05: -2,667 linesWeek of 2026-04-12: +5,291 linesWeek of 2026-04-12: -2,973 linesWeek of 2026-04-19: +3,991 linesWeek of 2026-04-19: -2,363 linesWeek of 2026-04-26: +5,460 linesWeek of 2026-04-26: -1,964 linesWeek of 2026-05-03: +124,165 linesWeek of 2026-05-03: -120,575 linesWeek of 2026-05-10: +11,003 linesWeek of 2026-05-10: -11,615 linesWeek of 2026-05-17: +2,778 linesWeek of 2026-05-17: -1,516 linesWeek of 2026-05-24: +270 linesWeek of 2026-05-24: -150 linesWeek of 2026-05-31: +9,218 linesWeek of 2026-05-31: -9,208 linesWeek of 2026-06-07: +3,517 linesWeek of 2026-06-07: -2,331 linesWeek of 2026-06-14: +54,691 linesWeek of 2026-06-14: -2,196 linesWeek of 2026-06-21: +970 linesWeek of 2026-06-21: -540 linesWeek of 2026-06-28: +2,315 linesWeek of 2026-06-28: -218 linesWeek of 2026-07-05: +2,745 linesWeek of 2026-07-05: -2,368 linesWeek of 2026-07-12: +6,273 linesWeek of 2026-07-12: -932 linesWeek of 2026-07-19: +7,978 linesWeek of 2026-07-19: -1,698 linesWeek of 2026-07-26: +3,116 linesWeek of 2026-07-26: -1,548 linesWeek of 2026-08-02: +90 linesWeek of 2026-08-02: -114 linesWeek of 2026-08-09: +817 linesWeek of 2026-08-09: -266 linesWeek of 2026-08-16: +2,859 linesWeek of 2026-08-16: -257 linesWeek of 2026-08-23: +863 linesWeek of 2026-08-23: -113 linesWeek of 2026-08-30: +3,252 linesWeek of 2026-08-30: -3,241 linesWeek of 2026-09-06: +0 linesWeek of 2026-09-06: -0 linesWeek of 2026-09-13: +1,257 linesWeek of 2026-09-13: -200 linesWeek of 2026-09-20: +179 linesWeek of 2026-09-20: -146 linesWeek of 2026-09-27: +763 linesWeek of 2026-09-27: -336 linesWeek of 2026-10-04: +0 linesWeek of 2026-10-04: -0 linesWeek of 2026-10-11: +0 linesWeek of 2026-10-11: -0 linesWeek of 2026-10-18: +458 linesWeek of 2026-10-18: -3 linesWeek of 2026-10-25: +18 linesWeek of 2026-10-25: -11 linesWeek of 2026-11-01: +514 linesWeek of 2026-11-01: -82 linesWeek of 2026-11-08: +15,452 linesWeek of 2026-11-08: -10,709 linesApr 5, 2026Nov 8, 2026
+275.9K lines added, -180.3K removed over the last year.

Commits per week

last 52 weeks
250Week of 2025-11-16: 0 commitsWeek of 2025-11-23: 0 commitsWeek of 2025-11-30: 0 commitsWeek of 2025-12-07: 0 commitsWeek of 2025-12-14: 0 commitsWeek of 2025-12-21: 0 commitsWeek of 2025-12-28: 0 commitsWeek of 2026-01-04: 0 commitsWeek of 2026-01-11: 0 commitsWeek of 2026-01-18: 0 commitsWeek of 2026-01-25: 0 commitsWeek of 2026-02-01: 0 commitsWeek of 2026-02-08: 0 commitsWeek of 2026-02-15: 0 commitsWeek of 2026-02-22: 0 commitsWeek of 2026-03-01: 0 commitsWeek of 2026-03-08: 0 commitsWeek of 2026-03-15: 0 commitsWeek of 2026-03-22: 0 commitsWeek of 2026-03-29: 0 commitsWeek of 2026-04-05: 12 commitsWeek of 2026-04-12: 18 commitsWeek of 2026-04-19: 14 commitsWeek of 2026-04-26: 17 commitsWeek of 2026-05-03: 23 commitsWeek of 2026-05-10: 16 commitsWeek of 2026-05-17: 12 commitsWeek of 2026-05-24: 2 commitsWeek of 2026-05-31: 2 commitsWeek of 2026-06-07: 12 commitsWeek of 2026-06-14: 21 commitsWeek of 2026-06-21: 10 commitsWeek of 2026-06-28: 4 commitsWeek of 2026-07-05: 25 commitsWeek of 2026-07-12: 21 commitsWeek of 2026-07-19: 24 commitsWeek of 2026-07-26: 18 commitsWeek of 2026-08-02: 4 commitsWeek of 2026-08-09: 4 commitsWeek of 2026-08-16: 8 commitsWeek of 2026-08-23: 5 commitsWeek of 2026-08-30: 4 commitsWeek of 2026-09-06: 0 commitsWeek of 2026-09-13: 4 commitsWeek of 2026-09-20: 1 commitsWeek of 2026-09-27: 1 commitsWeek of 2026-10-04: 0 commitsWeek of 2026-10-11: 0 commitsWeek of 2026-10-18: 2 commitsWeek of 2026-10-25: 1 commitsWeek of 2026-11-01: 8 commitsWeek of 2026-11-08: 8 commitsNov 16, 2025Nov 8, 2026
301 commits in the last 52 weeks.

When work happens

weekday and hour
SunMonTueWedThuFriSat036912151821Sun 0:00 — 1 commitsSun 1:00 — 0 commitsSun 2:00 — 0 commitsSun 3:00 — 0 commitsSun 4:00 — 0 commitsSun 5:00 — 0 commitsSun 6:00 — 1 commitsSun 7:00 — 5 commitsSun 8:00 — 6 commitsSun 9:00 — 5 commitsSun 10:00 — 3 commitsSun 11:00 — 1 commitsSun 12:00 — 3 commitsSun 13:00 — 2 commitsSun 14:00 — 2 commitsSun 15:00 — 5 commitsSun 16:00 — 2 commitsSun 17:00 — 1 commitsSun 18:00 — 1 commitsSun 19:00 — 1 commitsSun 20:00 — 1 commitsSun 21:00 — 1 commitsSun 22:00 — 1 commitsSun 23:00 — 1 commitsMon 0:00 — 0 commitsMon 1:00 — 0 commitsMon 2:00 — 0 commitsMon 3:00 — 0 commitsMon 4:00 — 0 commitsMon 5:00 — 0 commitsMon 6:00 — 2 commitsMon 7:00 — 4 commitsMon 8:00 — 10 commitsMon 9:00 — 5 commitsMon 10:00 — 2 commitsMon 11:00 — 3 commitsMon 12:00 — 1 commitsMon 13:00 — 3 commitsMon 14:00 — 1 commitsMon 15:00 — 2 commitsMon 16:00 — 2 commitsMon 17:00 — 1 commitsMon 18:00 — 3 commitsMon 19:00 — 4 commitsMon 20:00 — 3 commitsMon 21:00 — 3 commitsMon 22:00 — 2 commitsMon 23:00 — 0 commitsTue 0:00 — 0 commitsTue 1:00 — 1 commitsTue 2:00 — 0 commitsTue 3:00 — 0 commitsTue 4:00 — 0 commitsTue 5:00 — 0 commitsTue 6:00 — 1 commitsTue 7:00 — 3 commitsTue 8:00 — 5 commitsTue 9:00 — 8 commitsTue 10:00 — 10 commitsTue 11:00 — 4 commitsTue 12:00 — 1 commitsTue 13:00 — 2 commitsTue 14:00 — 3 commitsTue 15:00 — 2 commitsTue 16:00 — 8 commitsTue 17:00 — 3 commitsTue 18:00 — 1 commitsTue 19:00 — 3 commitsTue 20:00 — 3 commitsTue 21:00 — 0 commitsTue 22:00 — 0 commitsTue 23:00 — 1 commitsWed 0:00 — 0 commitsWed 1:00 — 0 commitsWed 2:00 — 0 commitsWed 3:00 — 0 commitsWed 4:00 — 0 commitsWed 5:00 — 1 commitsWed 6:00 — 0 commitsWed 7:00 — 1 commitsWed 8:00 — 6 commitsWed 9:00 — 7 commitsWed 10:00 — 6 commitsWed 11:00 — 1 commitsWed 12:00 — 6 commitsWed 13:00 — 5 commitsWed 14:00 — 1 commitsWed 15:00 — 0 commitsWed 16:00 — 2 commitsWed 17:00 — 2 commitsWed 18:00 — 0 commitsWed 19:00 — 1 commitsWed 20:00 — 0 commitsWed 21:00 — 3 commitsWed 22:00 — 0 commitsWed 23:00 — 0 commitsThu 0:00 — 0 commitsThu 1:00 — 0 commitsThu 2:00 — 0 commitsThu 3:00 — 1 commitsThu 4:00 — 0 commitsThu 5:00 — 0 commitsThu 6:00 — 1 commitsThu 7:00 — 8 commitsThu 8:00 — 4 commitsThu 9:00 — 2 commitsThu 10:00 — 2 commitsThu 11:00 — 2 commitsThu 12:00 — 0 commitsThu 13:00 — 0 commitsThu 14:00 — 1 commitsThu 15:00 — 1 commitsThu 16:00 — 3 commitsThu 17:00 — 4 commitsThu 18:00 — 2 commitsThu 19:00 — 3 commitsThu 20:00 — 0 commitsThu 21:00 — 1 commitsThu 22:00 — 0 commitsThu 23:00 — 1 commitsFri 0:00 — 0 commitsFri 1:00 — 0 commitsFri 2:00 — 0 commitsFri 3:00 — 0 commitsFri 4:00 — 0 commitsFri 5:00 — 0 commitsFri 6:00 — 1 commitsFri 7:00 — 2 commitsFri 8:00 — 6 commitsFri 9:00 — 6 commitsFri 10:00 — 1 commitsFri 11:00 — 1 commitsFri 12:00 — 0 commitsFri 13:00 — 2 commitsFri 14:00 — 0 commitsFri 15:00 — 1 commitsFri 16:00 — 4 commitsFri 17:00 — 2 commitsFri 18:00 — 3 commitsFri 19:00 — 3 commitsFri 20:00 — 0 commitsFri 21:00 — 2 commitsFri 22:00 — 0 commitsFri 23:00 — 0 commitsSat 0:00 — 0 commitsSat 1:00 — 0 commitsSat 2:00 — 0 commitsSat 3:00 — 0 commitsSat 4:00 — 0 commitsSat 5:00 — 0 commitsSat 6:00 — 0 commitsSat 7:00 — 0 commitsSat 8:00 — 3 commitsSat 9:00 — 6 commitsSat 10:00 — 1 commitsSat 11:00 — 2 commitsSat 12:00 — 2 commitsSat 13:00 — 6 commitsSat 14:00 — 1 commitsSat 15:00 — 0 commitsSat 16:00 — 0 commitsSat 17:00 — 3 commitsSat 18:00 — 1 commitsSat 19:00 — 0 commitsSat 20:00 — 7 commitsSat 21:00 — 3 commitsSat 22:00 — 0 commitsSat 23:00 — 1 commits
Commit volume by weekday and hour (UTC). Larger dots mean more commits.
DateListRankStars gained
Jul 11, 2026daily#22+2
  • ultraworkers/claw-code

    An agent-managed museum exhibit, built in Rust with Gajae-Code / LazyCodex — developed and maintained with no human intervention.

    194.8K stars · Rust

  • farion1231/cc-switch

    A cross-platform desktop All-in-One assistant for Claude Code, Codex, OpenCode,DeepSeek Harness and more. Only official website: ccswitch.io

    156K stars · Rust

  • openai/codex

    Lightweight coding agent that runs in your terminal

    136K stars · Rust

  • rust-lang/rust

    Empowering everyone to build reliable and efficient software.

    122.3K stars · Rust

  • pbakaus/impeccable

    The design vocabulary for your coding agent. Steer with polish and bolder, review with critique and audit, catch AI slop before it ships.

    114.1K stars · Rust

  • denoland/deno

    A modern runtime for JavaScript and TypeScript.

    109.1K stars · Rust