Quickstart

This quickstart gets you streaming live Solana data in a few minutes using the ORE demo — a real, deployed Arete stack for the ORE mining program. It’s the fastest way to see Arete in action.

Prerequisites

Choose how you want to run the CLI:

Step 1: Install the CLI

Install the native binary via Cargo:

cargo install a4-cli

Then use the a4 command:

a4 create my-app

This is the same CLI — Cargo installs it as a4, and so does npm.

No installation needed — just run:

npx @usearete/a4 create my-app

This downloads and runs the CLI without installing it globally.

Install globally via npm:

npm install -g @usearete/a4

Then use the a4 command:

a4 create my-app

Create Your App

Step 2: Scaffold the project

a4 create my-app

npx @usearete/a4 create my-app

a4 create my-app

You’ll be prompted to select a template:

Template	Description	Run Command
`react-ore`	React + Vite dashboard	`npm run dev` → open localhost:5173
`typescript-ore`	TypeScript CLI client	`npm start`
`rust-ore`	Rust + Tokio client	`cargo run`

Step 3: Or specify the template directly

a4 create my-app --template rust-ore  # or react-ore, typescript-ore

npx @usearete/a4 create my-app --template react-ore  # or typescript-ore, rust-ore

a4 create my-app --template react-ore  # or typescript-ore, rust-ore

That’s it. You’re streaming live Solana data.

What You Just Built

The scaffolded app connects to a deployed Arete Stack — a streaming data pipeline that:

Watches Solana for ORE mining program activity
Transforms raw transactions into structured round data (round ID, motherlode, deployment totals)
Streams updates to your app via WebSocket as they happen on-chain

Solana

ORE program

→

Arete

ORE stack

→

Your App

Live feed

No RPC calls. No polling. No custom indexer. Just streaming data.

Available Templates

Template	Command	What You Get
react-ore	`npx @usearete/a4 create my-app`	React + Vite dashboard showing live ORE mining rounds
typescript-ore	`npx @usearete/a4 create my-app`	TypeScript CLI that streams ORE data to your terminal
rust-ore	`npx @usearete/a4 create my-app`	Rust + Tokio client streaming ORE round updates

All templates connect to the public ORE stack at wss://ore.stack.arete.run.

You can also specify the template directly:

npx @usearete/a4 create my-app --template react-ore

What’s Inside

The React template uses arete-react with a pre-built stack definition:

import { AreteProvider } from "arete-react";
import { OreDashboard } from "./components/OreDashboard";

export default function App() {
  return (
    <AreteProvider
      websocketUrl="wss://ore.stack.arete.run"
      autoConnect={true}
    >
      <OreDashboard />
    </AreteProvider>
  );
}

import { useArete } from "arete-react";
import { ORE_STREAM_STACK } from "arete-stacks/ore";

export function OreDashboard() {
  const { views, isConnected } = useArete(ORE_STREAM_STACK);
  const { data: rounds } = views.OreRound.latest.use({ take: 5 });

  return (
    <div>
      <p>{isConnected ? "Live" : "Connecting..."}</p>
      {rounds?.map((round) => (
        <div key={round.id?.round_id}>
          Round #{round.id?.round_id} — Motherlode: {round.state?.motherlode}
        </div>
      ))}
    </div>
  );
}

The TypeScript template uses arete-typescript with typed views:

import { Arete } from "arete-typescript";
import { ORE_STREAM_STACK, type OreRound } from "arete-stacks/ore";

const a4 = await Arete.connect("wss://ore.stack.arete.run", {
  stack: ORE_STREAM_STACK,
});

for await (const update of a4.views.OreRound.latest.watch({ take: 1 })) {
  if (update.type === "upsert" || update.type === "patch") {
    console.log(`Round #${update.data.id?.round_id}`);
    console.log(`Motherlode: ${update.data.state?.motherlode}`);
  }
}

The Rust template uses a4-sdk with typed views:

use a4_sdk::prelude::*;
use a4_stacks::ore::{OreStack, OreRound};

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let a4 = Arete::<OreStack>::connect().await?;

    let mut stream = a4.views.ore_round.latest().listen();

    while let Some(round) = stream.next().await {
        println!("Round # {:?}", round.id.round_id);
        println!("Motherlode: {:?}", round.state.motherlode);
    }
    Ok(())
}

Using an AI Coding Agent?

Install Arete agent skills so your AI can write correct code without you looking up docs:

npx skills add AreteA4/skills

Now try asking your agent: “Show me the ORE mining round data in a table with live updates.”

See Build with AI for the full guide and prompt cookbook.

Next Steps

Now that you’ve seen Arete in action, where you go next depends on what you’re building:

Using an existing on-chain program that has a Arete stack?

Connect to a Stack — Add Arete to an existing project
React SDK — Build a full React app against a deployed stack
TypeScript SDK — Use Arete in Node.js, Vue, Svelte, or vanilla JS
Rust SDK — Native Rust client

Have your own on-chain program and want to stream its data?

Build Your Own Stack — Create a custom data stream for any Solana program

Want to understand what’s happening under the hood?

How It Works — Stacks, Views, and how live data flows

Using an AI coding tool?

Build with AI — Let your agent write Arete code with the right context