# Basics

At its core, NovaNet is powered by the memory-efficient **non-uniform incremental verifiable computation (NIVC)** scheme, SuperNova/Nebula The foundational codebase is written in Rust, with many components open-sourced and developed in collaboration with other leading teams in the IVC space.

NovaNet is designed for flexibility. Developers can add custom opcodes tailored to specific use cases or utilize the pre-existing opcodes for more conventional applications. Its zkFramework is initially implemented for the WebAssembly (WASM) virtual machine, ensuring high portability across various environments. With NovaNet, zkApps can run seamlessly in browsers, on blockchains, or anywhere else WASM is supported.

### **Why is NovaNet Fast?**

**TL;DR:** Most of the heavy cryptographic work (the "SNARK machinery") happens only at the final step, thanks to folding schemes.

**Incremental and Parallelized Computation**

NovaNet leverages IVC, as described in the Nova paper, to perform zero-knowledge computations incrementally, minimizing costs at each iteration. Here's how it works:

1. Problems are divided into smaller chunks, with each chunk executed as its own SuperNova instance.
2. These chunks can be processed in parallel.
3. When recombining the chunks, NovaNet proves that they followed the correct sequence and produced the claimed outputs for each segment of the execution trace.

**What Sets NovaNet Apart?**

While other systems, such as [Risc0](https://www.youtube.com/playlist?list=PLcPzhUaCxlCirUkJY0ltpjdtzWcz5U_6y), use approaches like Merkle trees and sorting (referred to as "continuations"), NovaNet takes a different path. It employs **offline memory checking**, inspired by techniques described in [JOLT](https://people.cs.georgetown.edu/jthaler/Jolt-paper.pdf) and earlier by [Blum et al](https://ieeexplore.ieee.org/document/185352)., and adapts these methods specifically for folding schemes. This design choice eliminates the need for Merkle tree overhead, resulting in faster and more efficient proofs.

### Getting Started with WASM

To use NovaNet, you'll first need to compile your code into a WASM file. Here’s how:

**For Rust Developers:**

Run the following command on your existing Rust code (with minimal adjustments):

```
sudo cargo build --target=wasm32-unknown-unknown --release
```

#### For Go Developers:

```
GOOS=js GOARCH=wasm go build -o main.wasm
```

#### Other Languages:

Over 30 programming languages can compile into WASM, including C, C++, Python, and JavaScript. Additionally, WASM runs natively in most modern browsers, making it highly versatile.

### Next Steps

Now that you’ve generated your WASM file, you’re ready to integrate it with NovaNet. Let’s dive into the next section to learn how!


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://devs.novanet.xyz/for-developers/basics.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.