NETMORY RISC-V MACHINE — INSTANCE

A self-contained RISC-V machine for development, research, and experimentation

Explore RISC-V from the inside. NETMORY is an emulated RISC-V machine that combines a firmware-based computing environment, native code-development tools, persistent storage, networking services, and signed firmware verification in one integrated system.

Instead of relying on a separate development computer to cross-compile every program, NETMORY provides its own RISC-V assembler and C compiler. Write code, compile it for the target architecture, store it on the machine, and run it there.

Whether you are exploring computer architecture, developing low-level software, studying secure firmware, or simply interested in a different approach to computing, NETMORY provides a hands-on environment for experimentation.

Key features

Develop directly on RISC-V

NETMORY includes an integrated, firmware-native RISC-V development toolchain.

• Native RISC-V C compiler and assembler: create executable code for the machine without a separate cross-compilation workflow.

• On-device development: create, compile, store, and run programs within the environment.

• C language support: work with supported C constructs, including functions, arrays, structures, pointers, and other implemented language features.

• Compiler safety checks: the developing C toolchain can reject certain provable programming errors, including out-of-bounds array accesses, division by zero, uninitialized local-variable reads, and direct returns of addresses of local variables.

• Freestanding execution: the toolchain is designed for the machine’s own environment rather than a conventional desktop operating system and standard-library stack.

The compiler implements a supported subset of C; it should not be assumed to provide full ISO C compatibility. The checks cover specific classes of errors, including pointers and memory misuse.

Work through a browser

NETMORY provides a web interface for interacting with the machine, including development and system-management functions.

The interface supports tasks such as:

• Editing and saving files.

• Accessing machine configuration.

• Inspecting runtime information and performance-related data.

• Working with the integrated development environment without needing a conventional desktop IDE installed on the target machine.

A UART text console is also available for direct command-line interaction.

Built-in networking

NETMORY integrates networking services into its firmware environment, including:

• HTTPS web serving.

• WebSocket communication.

• SSH access.

• File transfer through supported SSH-based services.

• SMTP email capabilities.

These services make the machine useful for experimenting with networked applications and embedded-style services alongside low-level RISC-V development.

Network access and individual services depend on the machine’s configuration and network environment. 

Signed firmware and secure-boot experiments

NETMORY incorporates Ed25519-based signature verification for supported firmware images. The secure-boot path checks signed firmware before allowing it to run, helping detect tampering with the verified image.

This provides a practical environment for exploring firmware integrity, trust boundaries, and the relationship between boot configuration and executable code.

Secure boot has a defined scope: image verification does not automatically make every configuration choice secure, and signature verification is not a substitute for a complete security review.

Persistent-Memory Architecture and Storage

The machine incorporates 1 GB of persistent main memory that retains its contents without power. A 64 MB RAM drive resides directly in this persistent memory, providing a persistent working area for files and machine data. The RAM drive and the 64 MB NVMe drive operate independently, each providing its own storage space.

This architecture allows the machine to boot and operate without either DRAM or an NVMe drive. The 1 GB persistent main memory is sufficient to run the system, while the RAM drive provides persistent file storage without requiring a separate storage device.

The machine also incorporates 4 GB of DRAM and a 64 MB NVMe drive for configurations that use these devices. Neither DRAM nor NVMe is required for booting in the persistent-memory-only configuration.

Beyond its standard configuration, the design provides a platform for investigating alternative memory architectures, including persistent-memory-based execution. Experimental boot and memory configurations remain under development, and capabilities beyond the demonstrated configurations should not be assumed to be universally available.

This architecture challenges the conventional separation between volatile main memory and nonvolatile storage, demonstrating how persistent main memory can support system execution and file storage without requiring DRAM or a separate NVMe device.

Technical specifications

The machine is emulated; the USB flash drive is the delivery medium, not a dedicated physical RISC-V computer. Exact behavior depends on the supplied software image and its configuration.

Who is NETMORY for?

• • FPGA Manufacturers — An opportunity to license the NETMORY architecture for integration into FPGA-based products, using programmable logic and, where appropriate, hardened FPGA resources. Potential licensees include Altera (Intel), AMD (Xilinx), and Microchip.

  • ASIC and Semiconductor Manufacturers — An opportunity to license the architecture for implementation as a dedicated ASIC, enabling a purpose-built silicon product based on NETMORY.

  • Design Verification Engineers — A platform for evaluating the architecture, verifying hardware behavior, and assessing system integration across programmable logic, hardened FPGA resources, and dedicated silicon implementations.

  • Developers and Researchers — An environment for exploring RISC-V architecture, firmware, native code development, networking, and persistent-memory concepts.

  NETMORY offers potential licensees alternative implementation paths: integration into an FPGA product or implementation as a dedicated ASIC. The appropriate path depends on the licensee's technology, product strategy, and target market.

Standard configuration and experimental features

The standard configuration is the recommended starting point. It uses the supplied QEMU-based environment and its configured memory and storage paths.

The development changelog also documents work on additional capabilities, including alternative boot sources, persistent-memory-only execution, expanded compiler checks, and large-file handling. Some of these developments are experimental or configuration-dependent; they should not be interpreted as promises that every feature is enabled in every supplied instance.

NETMORY is an evolving technical platform. The changelog describes implementation progress and development tests, which may not always correspond to the exact feature set of a particular distributed image.

Architecture Licensing Opportunities

NETMORY is available for evaluation and potential licensing by FPGA manufacturers and semiconductor companies interested in incorporating the architecture into their products or developing a dedicated ASIC implementation.

Organizations interested in evaluating the design for product integration, FPGA implementation, or custom silicon development are invited to contact us to discuss licensing opportunities and technical details.

What makes NETMORY different?

NETMORY brings together several areas that are often explored separately: RISC-V execution, firmware-level development, an on-device C toolchain, browser-based interaction, network services, and signed firmware verification.

The result is an environment for learning by doing—one in which you can investigate not only the programs running on the machine, but also the mechanisms that make the machine work.

NETMORY RISC-V MACHINE — INSTANCE
A practical platform for exploring the architecture, software, and security of a self-contained RISC-V environment.