Chapter 2 is where RUDRA gets real. We build a Number Summarizer: feed it 1..n, it prints each number's even/odd status, totals them up, and classifies the sum. Small enough to fit in your head. Real enough to teach you everything.

The program

fn sum_to(n: int) -> int {
    let mut total = 0;
    for i in 1..(n + 1) {
        total = total + i;
    }
    return total;
}

fn is_even(x: int) -> bool {
    return x % 2 == 0;
}

fn main() {
    let n = 5;
    print("RUDRA number summary");
    for i in 1..(n + 1) {
        if is_even(i) {
            print("{i} is even");
        } else {
            print("{i} is odd");
        }
    }
    let s = sum_to(n);
    print("sum: {s}");
    if is_even(s) {
        print("the sum is even");
    } else {
        print("the sum is odd");
    }
}

The ideas that do all the work

• let vs let mut — variables are immutable by default. Reassign a plain let and the compiler stops you with the exact line number. Mutability is opt-in, which means every mutation in your code is a deliberate decision.
• Ranges end exclusive — 1..6 means 1 through 5. This WILL bite you exactly once; after that you'll never forget. The idiom for "1 through n" is 1..(n + 1).
• The accumulator — total = total + i; inside the loop. (No += in RUDRA's book — the explicit form keeps beginners honest about what's happening.)
• Functions with types — fn sum_to(n: int) -> int. Parameters and return types are written out. The compiler checks every call.

The honest workflow

There's no keyboard-input API in the book at this stage — so n lives in the source. Change it and re-run:

rudrac summary.rux --run

Edit → run → read output → repeat. n = 5, 10, 20… each run teaches you something.

The 3 bugs you will definitely write

Debugging method: problem → behavior → reason → fix → retest.

1. Off-by-one — you write 1..n and n silently vanishes from the sum. Runs fine. Wrong answer. The exclusive end strikes.
2. Missing mut — you reassign a plain let. Compiler error, exact line given. Add mut, move on.
3. = vs == — assignment inside a condition. Compiler error; conditions need comparison.

Every one of these has bitten a professional this month. You're in good company.

Refactor like you mean it

Repeated logic becomes a function (is_even, sum_to). Names say what they mean. One idea per function. And the rule that keeps you honest: refactor only with features you've already learned — no cleverness debt.

Proof it works

Real runs, real numbers.

Keep going

🎥 Start the course — Chapter 1 video: https://www.youtube.com/watch?v=-adNF7Fi0Pg

📥 Download RUDRA (free): https://github.com/rakshanex/rudra

💬 WhatsApp channel: https://whatsapp.com/channel/0029Vb8hknnGE56kO24pbq47

Next chapters build on this foundation — the course follows the official book, chapter by chapter.

Question: which of the 3 bugs has bitten YOU most recently — off-by-one, missing mut, or = vs ==? Confess in the comments.

Piyush Kumar — Founder & Director, RAKSHANEX TECHNOLOGIES. Cybersecurity specialist (pentesting, red teaming, SOC, DFIR). Builder of RUDRA, OmniCore OS, AgentTrace. Author of "The RUDRA Programming Language" and four cybersecurity books.

Install the compiler. Install the linker. Configure the build system. Sacrifice something to the linker gods. Then — maybe — your program runs.

RUDRA skips all of that. Chapter 1 of the course is about one thing: going from zero to a running native binary as fast as humanly possible.

One archive. That's the whole toolchain.

Download RUDRA from https://github.com/rakshanex/rudra and you get four small tools:

No GCC. No Clang. No assembler. No linker. RUDRA emits x86-64 machine code and writes the executable itself.

Your first program

hello.rux:

fn main() {
    print("Hello, RUDRA!");
}

rudrac hello.rux --run
# ✅ Compiled: build/hello
# Hello, RUDRA!

Three lines. One command. A real native binary — a few kilobytes, starts in about a millisecond.

The project workflow you'll use forever

rudra new myapp && cd myapp
rudra run     # compile + run
rudra build   # native binary
rudra fmt     # format code
rudra test    # run test_* functions

Every project is just a Rux.toml manifest plus src/main.rux. No build scripts, no 400-line config files.

What happens between source and binary

RUDRA's compilation pipeline has 8 stages: lex → parse → resolve imports → type-check → monomorphize generics → emit x86-64 → native ELF executable. You don't need to memorize them — but knowing your language doesn't hide a C compiler under the hood changes how you think about it.

One more trick before you go

print("2 + 2 = {2 + 2}");   // 2 + 2 = 4

String interpolation with {...} — any expression, evaluated inline. You'll use this constantly.

Keep going

🎥 Watch Chapter 1 (full video lesson): https://www.youtube.com/watch?v=-adNF7Fi0Pg

📥 Download RUDRA (free): https://github.com/rakshanex/rudra

💬 WhatsApp channel: https://whatsapp.com/channel/0029Vb8hknnGE56kO24pbq47

Next: Chapter 2 — we build a real Number Summarizer with loops, mutable state, and functions. And we debug it like professionals.

Question: what's the most painful install experience you've ever had with a programming language? Tell me in the comments — I need to feel better about my 2 AM linker story.

Piyush Kumar — Founder & Director, RAKSHANEX TECHNOLOGIES. Cybersecurity specialist (pentesting, red teaming, SOC, DFIR). Builder of RUDRA, OmniCore OS, AgentTrace. Author of "The RUDRA Programming Language" and four cybersecurity books.