Forem: RECTOR SOL

Migrating from Manual Borsh to LUMOS: A Step-by-Step Guide

RECTOR SOL — Wed, 17 Dec 2025 23:15:29 +0000

Tired of maintaining duplicate type definitions in Rust and TypeScript? Here's how to migrate your existing Borsh code to LUMOS.

Why Migrate?

✅ Zero runtime overhead - Generated code is identical to manual Borsh
✅ Type synchronization - TypeScript and Rust always match
✅ Reduced maintenance - Single source of truth
✅ Fewer bugs - Eliminates serialization mismatches

Migration time: 5-30 minutes per struct/enum

Step 1: Audit Your Existing Code

Find All Borsh Types

Rust:

# Find structs with Borsh derives
rg '#\[derive.*Borsh' --type rust

# Find Account macros
rg '#\[account\]' --type rust

TypeScript:

# Find Borsh schemas
rg 'borsh\.(struct|rustEnum)' --type ts

Step 2: Before & After Example

Before (Manual Borsh)

Rust (state.rs):

use anchor_lang::prelude::*;

#[account]
pub struct PlayerAccount {
    pub wallet: Pubkey,
    pub level: u16,
    pub experience: u64,
    pub items: Vec<Pubkey>,
}

TypeScript (types.ts):

import { PublicKey } from '@solana/web3.js';
import * as borsh from '@coral-xyz/borsh';

export interface PlayerAccount {
  wallet: PublicKey;
  level: number;
  experience: number;
  items: PublicKey[];
}

export const PlayerAccountSchema = borsh.struct([
  borsh.publicKey('wallet'),
  borsh.u16('level'),
  borsh.u64('experience'),
  borsh.vec(borsh.publicKey(), 'items'),
]);

After (LUMOS Schema)

Create schema/player.lumos:

#[solana]
#[account]
struct PlayerAccount {
    wallet: PublicKey,
    level: u16,
    experience: u64,
    items: [PublicKey],
}

Generate code:

lumos generate schema/player.lumos

That's it! Both Rust and TypeScript are generated automatically.

Step 3: Update Imports

Rust:

// OLD:
use crate::state::PlayerAccount;

// NEW:
mod generated;
use generated::PlayerAccount;

TypeScript:

// OLD:
import { PlayerAccount, PlayerAccountSchema } from './types';

// NEW:
import { PlayerAccount, PlayerAccountBorshSchema } from './generated';

Step 4: Verify Binary Compatibility

Critical: Ensure LUMOS-generated code produces identical bytes.

#[test]
fn test_borsh_compatibility() {
    let player = PlayerAccount {
        wallet: Pubkey::new_unique(),
        level: 10,
        experience: 5000,
        items: vec![Pubkey::new_unique()],
    };

    // Serialize with manual implementation
    let manual_bytes = player.try_to_vec().unwrap();

    // Serialize with LUMOS-generated
    let generated_bytes = player.try_to_vec().unwrap();

    assert_eq!(manual_bytes, generated_bytes, "Binary output must match!");
}

Type Mapping Reference

Manual Rust	Manual TypeScript	LUMOS
`Pubkey`	`PublicKey`	`PublicKey`
`u16`	`number`	`u16`
`u64`	`number`	`u64`
`Vec<T>`	`T[]`	`[T]`
`Option<T>`	`T \	undefined`
`String`	`string`	`String`
`bool`	`boolean`	`bool`

Migration Checklist

[ ] Install LUMOS CLI: cargo install lumos-cli
[ ] Create .lumos schema files
[ ] Generate Rust and TypeScript code
[ ] Update imports in existing code
[ ] Run binary compatibility tests
[ ] Remove old manual type definitions
[ ] Update CI/CD to regenerate on schema changes

Gradual Migration Strategy

You don't have to migrate everything at once:

Phase 1: New types → Use LUMOS from the start
Phase 2: High-churn types → Migrate types you change often
Phase 3: Stable types → Migrate remaining types

CI/CD Integration

# .github/workflows/codegen.yml
name: Generate LUMOS Code

on: [push, pull_request]

jobs:
  generate:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: cargo install lumos-cli
      - run: lumos generate schema/*.lumos
      - run: git diff --exit-code || (echo "Generated files outdated!" && exit 1)

Get Started

cargo install lumos-cli
lumos generate your-schema.lumos

Documentation: https://docs.lumos-lang.org/guides/migration-guide/
GitHub: https://github.com/getlumos/lumos

Questions about migration? Drop them below!

LUMOS + Anchor: The Perfect Combo for Solana Development

RECTOR SOL — Wed, 17 Dec 2025 23:14:26 +0000

Using Anchor for Solana development? Here's how LUMOS supercharges your workflow by generating Anchor-compatible code from schemas.

LUMOS + Anchor: Better Together

LUMOS complements Anchor, it doesn't replace it.

Think of it this way:

Anchor = The framework that runs your Solana program
LUMOS = The tool that generates Anchor code from a schema

Why Use Both?

Without LUMOS	With LUMOS
Manually write Rust structs	Define once in `.lumos` schema
Manually write TypeScript types	Auto-generate TypeScript
Hope Rust ↔ TS stay in sync	Guaranteed sync (same source)
Calculate account space by hand	Auto-calculated `LEN` constants
Write IDL manually or extract	Auto-generate IDL from schema

Quick Start

1. Define Schema

// game.lumos
#[solana]
#[account]
struct GameConfig {
    authority: PublicKey,
    max_players: u32,
    entry_fee: u64,
    prize_pool: u64,
}

#[solana]
#[account]
struct Player {
    wallet: PublicKey,
    game: PublicKey,
    score: u64,
    joined_at: i64,
}

#[solana]
enum GameInstruction {
    Initialize { max_players: u32, entry_fee: u64 },
    JoinGame,
    UpdateScore { score: u64 },
    ClaimPrize,
}

2. Generate Anchor Program

lumos anchor generate game.lumos \
  --name game_program \
  --typescript

3. Generated Structure

game_program/
├── programs/game_program/
│   ├── src/
│   │   ├── lib.rs           # Program entry point
│   │   └── state.rs         # Account structs
│   └── Cargo.toml
├── target/idl/
│   └── game_program.json    # Anchor IDL
└── client/
    └── game_program.ts      # TypeScript client

CLI Commands

Generate Complete Program

lumos anchor generate <SCHEMA> [OPTIONS]

Options:
  -o, --output <DIR>      Output directory
  -n, --name <NAME>       Program name
  -V, --version <VER>     Program version (default: 0.1.0)
  -a, --address <ADDR>    Program address
      --typescript        Generate TypeScript client
      --dry-run           Preview without writing

Example:

lumos anchor generate game.lumos \
  --name my_game \
  --version 1.0.0 \
  --address "Game111111111111111111111111111111111111111" \
  --typescript

Generate Only IDL

lumos anchor idl game.lumos --pretty -o target/idl/game.json

Calculate Account Space

lumos anchor space game.lumos --format rust

Output:

impl GameConfig {
    pub const LEN: usize = 8 + 32 + 4 + 8 + 8; // 60 bytes
}

impl Player {
    pub const LEN: usize = 8 + 32 + 32 + 8 + 8; // 88 bytes
}

Generated Code Example

Rust (`state.rs`)

use anchor_lang::prelude::*;

#[account]
pub struct GameConfig {
    pub authority: Pubkey,
    pub max_players: u32,
    pub entry_fee: u64,
    pub prize_pool: u64,
}

impl GameConfig {
    pub const LEN: usize = 8 + 32 + 4 + 8 + 8;
}

#[account]
pub struct Player {
    pub wallet: Pubkey,
    pub game: Pubkey,
    pub score: u64,
    pub joined_at: i64,
}

impl Player {
    pub const LEN: usize = 8 + 32 + 32 + 8 + 8;
}

TypeScript (`game_program.ts`)

import { PublicKey } from '@solana/web3.js';
import * as borsh from '@coral-xyz/borsh';

export interface GameConfig {
  authority: PublicKey;
  maxPlayers: number;
  entryFee: number;
  prizePool: number;
}

export const GameConfigSchema = borsh.struct([
  borsh.publicKey('authority'),
  borsh.u32('maxPlayers'),
  borsh.u64('entryFee'),
  borsh.u64('prizePool'),
]);

When to Use LUMOS vs Anchor Alone

Scenario	Recommendation
Starting a new Anchor project	✅ Use LUMOS
Existing project, want type sync	✅ Use LUMOS
Simple program, few account types	⚠️ Either works
Complex program, many shared types	✅ Use LUMOS
Team with mixed Rust/TS developers	✅ Use LUMOS

Bottom line: If you're writing TypeScript clients that interact with your Anchor program, LUMOS saves you from maintaining duplicate type definitions.

Get Started

cargo install lumos-cli
lumos anchor generate schema.lumos --typescript

Documentation: https://docs.lumos-lang.org/frameworks/anchor/
GitHub: https://github.com/getlumos/lumos

Questions? Drop them below!

Type-Safe Rust ↔ TypeScript Communication for Solana

RECTOR SOL — Wed, 17 Dec 2025 23:14:14 +0000

Building a Solana dApp with both on-chain Rust and off-chain TypeScript? Here's how to keep your types perfectly synchronized.

The Problem

You define a struct in Rust:

#[account]
pub struct PlayerAccount {
    pub wallet: Pubkey,
    pub level: u16,
    pub experience: u64,
}

Then manually recreate it in TypeScript:

export interface PlayerAccount {
  wallet: PublicKey;
  level: number;
  experience: number;
}

What could go wrong?

Field order mismatch → deserialization fails
Type size differences → corrupted data
Forgotten updates → runtime errors

The Solution: LUMOS

Define once, generate both:

// schema.lumos
#[solana]
#[account]
struct PlayerAccount {
    wallet: PublicKey,
    level: u16,
    experience: u64,
    inventory: [String],
    last_active: i64,
}

Generate:

lumos generate schema.lumos

Complete Workflow

┌─────────────────┐     ┌──────────────────┐     ┌─────────────────────┐
│   schema.lumos  │────▶│  lumos generate  │────▶│  generated.rs/.ts   │
└─────────────────┘     └──────────────────┘     └─────────────────────┘
                                                          │
                        ┌─────────────────────────────────┼─────────────────────────────────┐
                        │                                 │                                 │
                        ▼                                 ▼                                 ▼
              ┌─────────────────┐              ┌─────────────────┐              ┌─────────────────┐
              │  Rust Program   │◀────────────▶│  Solana RPC     │◀────────────▶│  TypeScript     │
              │  (Anchor/Borsh) │              │  (On-chain)     │              │  Client         │
              └─────────────────┘              └─────────────────┘              └─────────────────┘

Rust Program Usage

use anchor_lang::prelude::*;

mod generated;
use generated::PlayerAccount;

#[program]
pub mod game_program {
    use super::*;

    pub fn initialize(ctx: Context<Initialize>, wallet: Pubkey) -> Result<()> {
        let player = &mut ctx.accounts.player;
        player.wallet = wallet;
        player.level = 1;
        player.experience = 0;
        player.inventory = Vec::new();
        player.last_active = Clock::get()?.unix_timestamp;
        Ok(())
    }

    pub fn add_experience(ctx: Context<UpdatePlayer>, amount: u64) -> Result<()> {
        let player = &mut ctx.accounts.player;
        player.experience = player.experience.checked_add(amount).unwrap();
        player.last_active = Clock::get()?.unix_timestamp;
        Ok(())
    }
}

TypeScript Client Usage

Fetch Account Data

import { Connection, PublicKey } from '@solana/web3.js';
import { PlayerAccount, PlayerAccountBorshSchema } from './generated';

async function getPlayerAccount(
  connection: Connection,
  playerPubkey: PublicKey
): Promise<PlayerAccount> {
  const accountInfo = await connection.getAccountInfo(playerPubkey);

  if (!accountInfo) {
    throw new Error('Player account not found');
  }

  // Skip 8-byte discriminator for Anchor accounts
  const data = accountInfo.data.slice(8);
  return PlayerAccountBorshSchema.decode(data);
}

Subscribe to Updates

function subscribeToPlayer(
  connection: Connection,
  playerPubkey: PublicKey,
  callback: (player: PlayerAccount) => void
): number {
  return connection.onAccountChange(
    playerPubkey,
    (accountInfo) => {
      const data = accountInfo.data.slice(8);
      const player = PlayerAccountBorshSchema.decode(data);
      callback(player);
    },
    'confirmed'
  );
}

// Usage
const subscriptionId = subscribeToPlayer(connection, playerPubkey, (player) => {
  console.log(`Level: ${player.level}, XP: ${player.experience}`);
});

Build Transactions

import * as anchor from '@coral-xyz/anchor';

async function addExperience(
  program: anchor.Program,
  playerPubkey: PublicKey,
  amount: number
): Promise<string> {
  const tx = await program.methods
    .addExperience(new anchor.BN(amount))
    .accounts({ player: playerPubkey })
    .rpc();

  console.log(`Added ${amount} XP. TX: ${tx}`);
  return tx;
}

Type Mapping Reference

LUMOS	Rust	TypeScript
`u8-u64`	`u8-u64`	`number`
`u128`	`u128`	`bigint`
`i8-i64`	`i8-i64`	`number`
`bool`	`bool`	`boolean`
`String`	`String`	`string`
`PublicKey`	`Pubkey`	`PublicKey`
`[T]`	`Vec<T>`	`T[]`
`Option<T>`	`Option<T>`	`T \

Benefits

✅ Single Source of Truth - Define types once
✅ Guaranteed Sync - Rust and TypeScript always match
✅ Correct Borsh - Field order and sizes guaranteed
✅ Zero Runtime Overhead - Generated code is identical to manual
✅ IDE Support - Full TypeScript autocomplete

Get Started

{% raw %}

cargo install lumos-cli
lumos generate schema.lumos

Documentation: https://docs.lumos-lang.org/guides/client-interaction/
GitHub: https://github.com/getlumos/lumos

Questions? Drop them below!

LUMOS in 5 Minutes: Your First Solana Schema

RECTOR SOL — Wed, 17 Dec 2025 23:12:48 +0000

Want type-safe Rust + TypeScript for your Solana app? Let's get you from zero to working schema in exactly 5 minutes.

Minute 1: Installation

cargo install lumos-cli

Verify:

lumos --version
# Output: lumos-cli 0.1.0

No Rust? Use npm instead:

npx @getlumos/cli --version

Minute 2: Initialize Project

lumos init my-game
cd my-game

This creates:

my-game/
├── schema.lumos    ← Your schema definition
├── lumos.toml      ← Configuration
└── README.md       ← Getting started guide

Minute 3: Write Your Schema

Open schema.lumos:

#[solana]
#[account]
struct PlayerAccount {
    wallet: PublicKey,
    level: u16,
    experience: u64,
    equipped_items: [PublicKey],
}

#[solana]
struct MatchResult {
    player: PublicKey,
    opponent: Option<PublicKey>,
    score: u64,
    timestamp: i64,
}

What's happening:

#[solana] - Solana-specific type
#[account] - Anchor account (uses Anchor macros)
PublicKey - Maps to Pubkey in Rust, PublicKey in TS
[PublicKey] - Vector/array
Option<T> - Optional value

Minute 4: Generate Code

lumos generate schema.lumos

Output:

  Generating Rust code
       Wrote ./generated.rs
  Generating TypeScript code
       Wrote ./generated.ts
    Finished generated 2 type definitions

Rust Output (`generated.rs`)

use anchor_lang::prelude::*;

#[account]
pub struct PlayerAccount {
    pub wallet: Pubkey,
    pub level: u16,
    pub experience: u64,
    pub equipped_items: Vec<Pubkey>,
}

TypeScript Output (`generated.ts`)

import { PublicKey } from '@solana/web3.js';
import * as borsh from '@coral-xyz/borsh';

export interface PlayerAccount {
  wallet: PublicKey;
  level: number;
  experience: number;
  equipped_items: PublicKey[];
}

export const PlayerAccountBorshSchema = borsh.struct([
  borsh.publicKey('wallet'),
  borsh.u16('level'),
  borsh.u64('experience'),
  borsh.vec(borsh.publicKey(), 'equipped_items'),
]);

Minute 5: Use in Your Project

Anchor Program

mod generated;
use generated::*;

#[program]
pub mod my_game {
    use super::*;

    pub fn create_player(ctx: Context<CreatePlayer>) -> Result<()> {
        let player = &mut ctx.accounts.player;
        player.wallet = *ctx.accounts.user.key;
        player.level = 1;
        player.experience = 0;
        Ok(())
    }
}

TypeScript Client

import { PlayerAccount, PlayerAccountBorshSchema } from './generated';

async function getPlayer(pubkey: PublicKey): Promise<PlayerAccount> {
  const accountInfo = await connection.getAccountInfo(pubkey);
  return PlayerAccountBorshSchema.deserialize(accountInfo.data);
}

You're Done!

In 5 minutes you:

✅ Installed LUMOS CLI
✅ Created your first .lumos schema
✅ Generated type-safe Rust + TypeScript
✅ Learned the complete workflow

What you got:

Type-safe schemas shared between languages
Automatic Borsh serialization
Zero manual boilerplate
Anchor-ready code

Next Steps

Questions? Drop them below!

Use LUMOS Without Installing Rust - npm Package Guide

RECTOR SOL — Wed, 17 Dec 2025 23:12:44 +0000

Want to use LUMOS for Solana schema generation but don't want to install Rust? The @getlumos/cli npm package has you covered!

Why Use the npm Package?

No Rust Toolchain Required - Works with Node.js only
Cross-Platform - Single package for all platforms
Programmatic API - Use LUMOS in build scripts
TypeScript Support - Full type definitions included
Lightweight - 261 KB compressed

Installation

Global Installation

npm install -g @getlumos/cli
# or
yarn global add @getlumos/cli
# or
pnpm add -g @getlumos/cli

Verify installation:

lumos --version
# Output: 0.1.0

No Installation (npx)

Run directly without installing:

npx @getlumos/cli generate schema.lumos

CLI Usage

Generate Code

# Basic usage
lumos generate schema.lumos

# With custom output paths
lumos generate schema.lumos \
  --output-rust src/generated.rs \
  --output-typescript src/generated.ts

Add to package.json Scripts

{
  "scripts": {
    "codegen": "lumos generate schema.lumos",
    "prebuild": "npm run codegen"
  }
}

Programmatic API

Use LUMOS in your JavaScript/TypeScript code:

import { generate, validate } from '@getlumos/cli';

// Validate first
const validation = await validate('schema.lumos');
if (!validation.valid) {
  console.error('Schema validation failed');
  process.exit(1);
}

// Generate
const result = await generate('schema.lumos', {
  outputRust: 'src/generated.rs',
  outputTypeScript: 'src/generated.ts'
});

console.log('Generated Rust code:', result.rust);
console.log('Generated TypeScript code:', result.typescript);

Build Tool Integration

Vite Plugin

import { Plugin } from 'vite';
import { generate } from '@getlumos/cli';

export function lumosPlugin(schemaPath: string): Plugin {
  return {
    name: 'vite-plugin-lumos',
    async buildStart() {
      await generate(schemaPath);
    }
  };
}

Webpack Plugin

const { generate } = require('@getlumos/cli');

class LumosPlugin {
  constructor(schemaPath) {
    this.schemaPath = schemaPath;
  }

  apply(compiler) {
    compiler.hooks.beforeCompile.tapPromise('LumosPlugin', async () => {
      await generate(this.schemaPath);
    });
  }
}

CI/CD Integration

GitHub Actions

name: Generate LUMOS Code

on: [push, pull_request]

jobs:
  generate:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: '20'
      - run: npm install
      - run: npx @getlumos/cli generate schema.lumos

npm vs Rust CLI Comparison

Feature	npm (`@getlumos/cli`)	Rust (`lumos-cli`)
Installation	`npm install -g`	`cargo install`
Requirements	Node.js 16+	Rust toolchain
Size	261 KB	~10 MB
Speed	WASM (~10-20% slower)	Native (fastest)
Programmatic API	JavaScript/TypeScript	Rust only

Choose npm if:

You don't have Rust installed
You want programmatic API access
You're building JavaScript/TypeScript projects

Choose Rust if:

You want maximum performance
You need LSP integration

Get Started

npx @getlumos/cli generate schema.lumos

npm Registry: https://www.npmjs.com/package/@getlumos/cli
Documentation: https://docs.lumos-lang.org/guides/npm-package/
GitHub: https://github.com/getlumos/lumos

Questions? Drop them in the comments!

LUMOS vs Codama: Understanding Solana's Schema Generation Tools

RECTOR SOL — Wed, 17 Dec 2025 23:00:33 +0000

Building on Solana? You've probably wondered: "Should I use LUMOS or Codama?"

The answer: Both. They're complementary, not competing.

Let me explain why.

TL;DR

LUMOS = Define data schemas → Generate Rust + TypeScript code (pre-deployment)
Codama = Parse existing programs → Generate client SDKs (post-deployment)

They work at different layers and can be used together.

Where Each Tool Fits

┌─────────────────────────────────────────────────────────────┐
│                   YOUR SOLANA PROGRAM                       │
│  ┌────────────────────────────────────────────────────────┐ │
│  │                                                        │ │
│  │   ┌──────────────────┐                                 │ │
│  │   │  Account Data    │ ◄── LUMOS generates this        │ │
│  │   │  (structs/enums) │     (data structure code)       │ │
│  │   └──────────────────┘                                 │ │
│  │                                                        │ │
│  │   ┌──────────────────┐                                 │ │
│  │   │  Instructions    │     (you write this manually    │ │
│  │   │  (program logic) │      or with Anchor)            │ │
│  │   └──────────────────┘                                 │ │
│  │                                                        │ │
│  └────────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────┘
                              ▲
                              │ Codama parses program
                              │ and generates...
                              ▼
┌─────────────────────────────────────────────────────────────┐
│                        CLIENTS                              │
│  ┌─────────┐  ┌─────────┐  ┌─────────┐  ┌─────────┐         │
│  │   JS    │  │  Rust   │  │ Python  │  │  Dart   │         │
│  │ Client  │  │ Client  │  │ Client  │  │ Client  │         │
│  └─────────┘  └─────────┘  └─────────┘  └─────────┘         │
│                                                             │
│  ◄── Codama generates these (SDK code to interact)          │
└─────────────────────────────────────────────────────────────┘

Key insight: LUMOS generates code that goes inside your program. Codama generates code that interacts with your program from outside.

What is Codama?

Codama is a code generation framework that creates standardized descriptions of Solana programs. It works around a central concept called the Codama IDL.

Core workflow:

Existing Program → Parse → Codama IDL → Generate Clients
     or
Anchor IDL → Convert → Codama IDL → Generate Clients

What Codama does:

Parses existing Solana programs or Anchor IDL files
Creates a unified IDL representation with 60+ node types
Generates client SDKs in multiple languages (JS, Rust, Python, Dart)
Produces documentation and tooling for program interfaces

Primary use case: "I have a deployed Solana program, now I need to generate client libraries."

What is LUMOS?

LUMOS is a schema-first DSL for defining data structures with guaranteed type safety across Rust and TypeScript.

Core workflow:

.lumos Schema → Parse → IR → Generate Rust + TypeScript

What LUMOS does:

Defines data structures in a clean, Rust-like syntax
Generates Rust structs with proper Borsh serialization
Generates TypeScript interfaces with matching Borsh schemas
Ensures type safety between on-chain and off-chain code
Supports Anchor framework integration via #[account] attribute

Primary use case: "I want a single source of truth for my data types."

Key Differences

1. Workflow Direction

Aspect	LUMOS	Codama
Direction	Forward (schema → code)	Reverse (program → clients)
Input	`.lumos` schema files	Existing programs or Anchor IDL
Stage	Pre-deployment	Post-deployment

2. What They Generate

LUMOS generates data structure code:

// Input: schema.lumos
#[solana]
#[account]
struct PlayerAccount {
    wallet: PublicKey,
    level: u16,
    experience: u64,
}

// Output: generated.rs (goes INTO your program)
use anchor_lang::prelude::*;

#[account]
pub struct PlayerAccount {
    pub wallet: Pubkey,
    pub level: u16,
    pub experience: u64,
}

Codama generates client SDK code:

// Output: client SDK (CALLS your program from outside)
await program.methods
  .createPlayer()
  .accounts({
    player: playerPda,
    authority: wallet.publicKey,
  })
  .rpc();

3. Feature Comparison

Feature	LUMOS	Codama
Struct definitions	✅	✅
Enum definitions	✅	✅
Borsh serialization	✅	✅
Instruction builders	❌	✅
Error types	❌	✅
CLI generation	❌	✅
Go support	✅	❌
Ruby support	✅	❌
Dart support	❌	✅

When to Use Each

Use LUMOS When:

✅ Defining new data structures for a Solana program
✅ Need Rust + TypeScript type synchronization with Borsh
✅ Building new programs and want a single source of truth
✅ Want compile-time guarantees that types match
✅ Need Go or Ruby code generation

Use Codama When:

✅ Building clients for existing/deployed programs
✅ Need full SDK generation with instruction builders
✅ Want Dart support or Umi framework integration
✅ Generating documentation for your program
✅ Need CLI tools for program interaction

Using Both Together

Here's how a complete workflow looks:

┌─────────────────────────────────────────────────────────────┐
│  PHASE 1: Define Data Structures (LUMOS)                    │
│                                                             │
│  schema.lumos → lumos generate → generated.rs + generated.ts│
└─────────────────────────────────────────────────────────────┘
                              ▼
┌─────────────────────────────────────────────────────────────┐
│  PHASE 2: Build Program (Anchor/Native)                     │
│                                                             │
│  Use generated.rs in your program + write instructions      │
└─────────────────────────────────────────────────────────────┘
                              ▼
┌─────────────────────────────────────────────────────────────┐
│  PHASE 3: Deploy & Generate Clients (Codama)                │
│                                                             │
│  Deploy program → Parse IDL → Generate full client SDKs     │
└─────────────────────────────────────────────────────────────┘

Summary

Aspect	LUMOS	Codama
Philosophy	Schema-first	IDL-centric
Direction	Schema → Code	Program → Clients
Stage	Pre-deployment	Post-deployment
Focus	Data structures	Full program interface

They're complementary tools:

Use LUMOS when defining your data schemas during development
Use Codama when generating client libraries for distribution

Get Started

LUMOS: lumos-lang.org | GitHub
Codama: GitHub

# Install LUMOS CLI
cargo install lumos-cli

# Generate from schema
lumos generate schema.lumos

Have questions? Drop them in the comments below!

Forem: RECTOR SOL

Migrating from Manual Borsh to LUMOS: A Step-by-Step Guide

Why Migrate?

Step 1: Audit Your Existing Code

Find All Borsh Types

Step 2: Before & After Example

Before (Manual Borsh)

After (LUMOS Schema)

Step 3: Update Imports

Step 4: Verify Binary Compatibility

Type Mapping Reference

Migration Checklist

Gradual Migration Strategy

CI/CD Integration

Get Started

LUMOS + Anchor: The Perfect Combo for Solana Development

LUMOS + Anchor: Better Together

Why Use Both?

Quick Start

1. Define Schema

2. Generate Anchor Program

3. Generated Structure

CLI Commands

Generate Complete Program

Generate Only IDL

Calculate Account Space

Generated Code Example

Rust (state.rs)

TypeScript (game_program.ts)

When to Use LUMOS vs Anchor Alone

Get Started

Type-Safe Rust ↔ TypeScript Communication for Solana

The Problem

The Solution: LUMOS

Complete Workflow

Rust Program Usage

TypeScript Client Usage

Fetch Account Data

Subscribe to Updates

Build Transactions

Type Mapping Reference

Benefits

Get Started

LUMOS in 5 Minutes: Your First Solana Schema

Minute 1: Installation

Minute 2: Initialize Project

Minute 3: Write Your Schema

Minute 4: Generate Code

Rust Output (generated.rs)

TypeScript Output (generated.ts)

Minute 5: Use in Your Project

Anchor Program

TypeScript Client

You're Done!

Next Steps

Use LUMOS Without Installing Rust - npm Package Guide

Why Use the npm Package?

Installation

Global Installation

No Installation (npx)

CLI Usage

Generate Code

Add to package.json Scripts

Programmatic API

Build Tool Integration

Vite Plugin

Webpack Plugin

CI/CD Integration

GitHub Actions

npm vs Rust CLI Comparison

Get Started

LUMOS vs Codama: Understanding Solana's Schema Generation Tools

TL;DR

Where Each Tool Fits

What is Codama?

What is LUMOS?

Key Differences

1. Workflow Direction

2. What They Generate

3. Feature Comparison

Rust (`state.rs`)

TypeScript (`game_program.ts`)

Rust Output (`generated.rs`)

TypeScript Output (`generated.ts`)