solana-program & solana-sdk

solana-program is the on-chain standard library for native Rust programs targeting Agave 4.1.1 sBPF. solana-sdk (and split client crates) power off-chain Rust binaries that build transactions, sign, and talk to RPC. Together they are the foundation beneath Anchor 0.32.1 and lightweight frameworks like Pinocchio.

Recipe

Quick-reference recipe card - copy-paste ready.

# On-chain (Cargo.toml)
[dependencies]
solana-program = "2.2"
 
# Off-chain client binary
[dependencies]
solana-sdk = "2.2"

use solana_program::{
    account_info::AccountInfo,
    entrypoint,
    entrypoint::ProgramResult,
    pubkey::Pubkey,
};

When to reach for this:

• Writing native on-chain programs without Anchor macros.
• Building Rust CLIs, bots, or test harnesses off-chain.
• Understanding what Anchor expands into under the hood.
• Auditing low-level account validation and CPI helpers.

Working Example

// programs/native_counter/src/lib.rs (on-chain)
use solana_program::{
    account_info::{next_account_info, AccountInfo},
    entrypoint,
    entrypoint::ProgramResult,
    msg,
    program_error::ProgramError,
    pubkey::Pubkey,
};
 
entrypoint!(process_instruction);
 
pub fn process_instruction(
    _program_id: &Pubkey,
    accounts: &[AccountInfo],
    _instruction_data: &[u8],
) -> ProgramResult {
    let iter = &mut accounts.iter();
    let payer = next_account_info(iter)?;
    if !payer.is_signer {
        return Err(ProgramError::MissingRequiredSignature);
    }
    msg!("payer: {}", payer.key);
    Ok(())
}

// client/src/main.rs (off-chain)
use solana_sdk::{
    signature::{Keypair, Signer},
    system_instruction,
    transaction::Transaction,
};
use solana_client::rpc_client::RpcClient;
 
fn main() {
    let rpc = RpcClient::new("https://api.devnet.solana.com".to_string());
    let payer = Keypair::new();
    let ix = system_instruction::transfer(&payer.pubkey(), &payer.pubkey(), 1);
    let bh = rpc.get_latest_blockhash().unwrap();
    let tx = Transaction::new_signed_with_payer(&[ix], Some(&payer.pubkey()), &[&payer], bh);
    let _sig = rpc.send_and_confirm_transaction(&tx).unwrap();
}

What this demonstrates:

• On-chain entrypoint receives accounts and instruction data.
• Signer checks are manual in native code.
• Off-chain SDK composes system instructions and signs transactions.
• RPC client is separate (solana-client) but pairs with solana-sdk types.

Deep Dive

How It Works

• solana-program is no_std friendly for sBPF targets via cargo build-sbf.
• solana-sdk targets full Rust std for hosts building and signing transactions.
• Crates split in 2.x lines - import only what each binary needs to reduce compile time.
• Anchor anchor-lang re-exports and wraps many solana-program primitives.

Rust Crate Table (on-chain vs off-chain)

TypeScript / NPM Table (client parity)

Rust Notes

// Programs: avoid std-only crates in Cargo.toml
// Clients: prefer solana_sdk::commitment_config::CommitmentConfig::confirmed()
 
// CPI example imports
use solana_program::program::invoke;

Gotchas

• Mixing 1.x and 2.x crate families - type mismatches across workspace. Fix: one SDK generation per repo, aligned with Agave 4.1.1.
• std in on-chain crates - breaks cargo build-sbf. Fix: audit cargo tree for forbidden deps.
• Using solana-sdk inside programs - pulls incompatible features. Fix: solana-program only on-chain.
• Duplicate pubkey types across crates - conversion churn. Fix: standardize imports per binary.
• Assuming Anchor hides validation - native code must enforce owner/signer manually.

Alternatives

FAQs

Related

• anchor-lang & anchor-spl - framework crates
• Native Program Basics - native patterns
• Rust for Solana Basics - Rust primer
• @solana/kit Basics - TS client stack

Stack versions: This page was written for Agave 4.1.1, Solana CLI 3.0.10, Anchor 0.32.1, anchor-lang 0.32.1, Rust 1.91.1, @solana/kit 7.0.0, Surfpool 0.12.0, and LiteSVM 0.6.x.