chore: Release galdr version 0.2.2

Grid is now dynamic (w/h up to a max, fixed-stride storage so slot indices
stay stable and content isn't remapped). Ruler marks (+) on empty cells for
orientation; cursor clamps on shrink; status shows the size.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01GLUwWE2KmFPzhKaf67tWbx

Cargo.lock

@@ -320,7 +320,7 @@ dependencies = [
 
 [[package]]
 name = "galdr"
-version = "0.2.0"
+version = "0.2.2"
 dependencies = [
  "anyhow",
  "arc-swap",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "galdr"
-version = "0.2.0"
+version = "0.2.2"
 edition = "2021"
 description = "A terminal grid synthesizer: signal flows spatially through single-glyph unit generators, voiced by MIDI, rendered low-latency to PipeWire"
 license = "MIT"

README.md

@@ -59,7 +59,10 @@ galdr [--latency <frames>] [--poly <n>] [--rate <hz>] [--midi-name <s>]
 
 galdr creates a virtual MIDI input port named **galdr**; connect orca or any
 sequencer/DAW to it. `--midi-name` connects to an existing port instead.
-Cursor keys move; type a glyph to place it; Backspace clears; Esc quits.
+
+Keys: cursor keys move; type a glyph to place it; Backspace clears; `?` toggles
+help; Esc quits. Resize the grid with `(` / `)` (width) and `_` / `+` (height)
+by one ruler division, or Ctrl+arrows by one cell (orca's bindings).
 
 Runtime deps: PipeWire and ALSA (MIDI). Built in Rust; reuses the native
 PipeWire path from spectrust.

aur/PKGBUILD

@@ -1,6 +1,6 @@
 # Maintainer: Bendik Aagaard Lynghaug <bendik.lynghaug@gmail.com>
 pkgname=galdr
-pkgver=0.2.0
+pkgver=0.2.2
 pkgrel=1
 pkgdesc="Terminal grid synthesizer: signal flows through single-glyph unit generators, MIDI in, low-latency PipeWire out"
 arch=('x86_64' 'aarch64')

src/dsp.rs

@@ -9,7 +9,7 @@
 //! params, lowercase a-z read MIDI CC (a = CC 0). A neighbour to the left/right
 //! supplies a parameter; `M` instead reads the left cell as a second signal.
 
-use crate::grid::{Grid, H, SLOTS, W};
+use crate::grid::{Grid, MAX_W, SLOTS};
 
 pub const MAX_STATE: usize = 4 * SLOTS;
 pub const TAU: f32 = std::f32::consts::TAU;
@@ -110,20 +110,23 @@ pub fn compile(grid: &Grid) -> Program {
     let mut nodes = Vec::new();
     let mut st = 0usize;
     let mut has_env = false;
-    for row in 0..H {
+    for row in 0..grid.h {
-        for col in 0..W {
+        for col in 0..grid.w {
             let Some((op, ssize)) = op_of(grid.get(col, row)) else { continue };
             if matches!(op, Op::Env) {
                 has_env = true;
             }
-            let input =
+            let input = if row > 0 && occupied(grid.get(col, row - 1)) {
-                if row > 0 && occupied(grid.get(col, row - 1)) { Some((row - 1) * W + col) } else { None };
+                Some((row - 1) * MAX_W + col)
-            let lsig = if col > 0 { Some(row * W + col - 1) } else { None };
+            } else {
+                None
+            };
+            let lsig = if col > 0 { Some(row * MAX_W + col - 1) } else { None };
             let left = if col > 0 { param_of(grid.get(col - 1, row)) } else { Param::None };
-            let right = if col + 1 < W { param_of(grid.get(col + 1, row)) } else { Param::None };
+            let right = if col + 1 < grid.w { param_of(grid.get(col + 1, row)) } else { Param::None };
             let this_st = st;
             st = (st + ssize).min(MAX_STATE - 4);
-            nodes.push(Node { op, out: row * W + col, input, lsig, left, right, st: this_st });
+            nodes.push(Node { op, out: row * MAX_W + col, input, lsig, left, right, st: this_st });
         }
     }
     Program { nodes, has_env }

src/grid.rs

@@ -1,31 +1,55 @@
-//! The fixed-size character grid that is the editor surface.
+//! The character grid — the editor surface. Logical size (`w`×`h`) is
+//! resizable up to the max; cells are stored at a fixed `MAX_W` stride so a
+//! resize never remaps existing content and compiled slot indices stay stable.
 
-pub const W: usize = 24;
+pub const MAX_W: usize = 40;
-pub const H: usize = 16;
+pub const MAX_H: usize = 24;
-pub const SLOTS: usize = W * H;
+pub const SLOTS: usize = MAX_W * MAX_H;
+pub const DEFAULT_W: usize = 24;
+pub const DEFAULT_H: usize = 16;
+pub const RULER: usize = 8;
 
 #[derive(Clone)]
 pub struct Grid {
+    pub w: usize,
+    pub h: usize,
     cells: Vec<char>,
 }
 
 impl Grid {
     pub fn new() -> Self {
-        Grid { cells: vec!['.'; SLOTS] }
+        Grid { w: DEFAULT_W, h: DEFAULT_H, cells: vec!['.'; SLOTS] }
     }
 
     #[inline]
     pub fn get(&self, col: usize, row: usize) -> char {
-        if col < W && row < H {
+        if col < self.w && row < self.h {
-            self.cells[row * W + col]
+            self.cells[row * MAX_W + col]
         } else {
             '.'
         }
     }
 
     pub fn set(&mut self, col: usize, row: usize, c: char) {
-        if col < W && row < H {
+        if col < self.w && row < self.h {
-            self.cells[row * W + col] = c;
+            self.cells[row * MAX_W + col] = c;
         }
     }
+
+    /// Resize to nh×nw, clamped to [1, MAX]. Content keeps its position.
+    pub fn resize(&mut self, nh: usize, nw: usize) {
+        self.h = nh.clamp(1, MAX_H);
+        self.w = nw.clamp(1, MAX_W);
+    }
+}
+
+/// orca-c's ruler snap: resize by one ruler division, snapped to a
+/// ruler-aligned size (1, 9, 17, ...) rather than a plain +/-1.
+pub fn ruler_snap(size: usize, delta_rulers: isize) -> usize {
+    if size == 0 {
+        return if delta_rulers > 0 { RULER * delta_rulers as usize } else { 1 };
+    }
+    let size = if delta_rulers < 0 { size + RULER - 1 } else { size };
+    let n = ((size as isize - 1) / RULER as isize + delta_rulers).max(0);
+    (RULER as isize * n + 1) as usize
 }

src/tui.rs

@@ -1,6 +1,8 @@
-//! Grid editor. crossterm renderer adapted from orca-rs's grid view (same
+//! Grid editor. crossterm renderer adapted from orca-rs's grid view: a centered
-//! centered-canvas + per-glyph colour approach); no embedded scope - run a
+//! canvas with per-glyph colour, ruler marks, resize bindings, and a change-diff
-//! spectrum analyzer (e.g. spectrust) on the side if you want one.
+//! so only cells that actually change repaint (a full clear+redraw each frame
+//! flickers over SSH on terminals that ignore synchronized-update). `?` toggles
+//! a detailed help overlay; run a spectrum analyzer on the side if you want one.
 
 use std::io::{self, Write};
 use std::sync::atomic::{AtomicU32, Ordering};
@@ -12,30 +14,81 @@ use crossterm::cursor::{Hide, MoveTo, Show};
 use crossterm::event::{self, Event, KeyCode, KeyEventKind, KeyModifiers};
 use crossterm::style::{Attribute, Color, Print, SetAttribute, SetForegroundColor};
 use crossterm::terminal::{
-    disable_raw_mode, enable_raw_mode, BeginSynchronizedUpdate, Clear, ClearType,
+    disable_raw_mode, enable_raw_mode, Clear, ClearType, EnterAlternateScreen, LeaveAlternateScreen,
-    EndSynchronizedUpdate, EnterAlternateScreen, LeaveAlternateScreen,
 };
 use crossterm::{execute, queue, terminal};
 
 use crate::dsp::{compile, Program};
-use crate::grid::{Grid, H, W};
+use crate::grid::{ruler_snap, Grid, RULER};
+
+const HELP: &[&str] = &[
+    "galdr — grid synthesizer",
+    "",
+    "Signal flows DOWN: a cell's input is the cell above it. Operators are",
+    "UPPERCASE. A digit 0-9 to the left/right is a constant param; a lowercase",
+    "a-z reads MIDI CC (a = CC 0). Every note plays the whole grid; each ! sums",
+    "into the master, so parallel columns stack voices/timbres.",
+    "",
+    "SOURCES   O sine   A saw   U pulse   V triangle   N noise",
+    "          left param = pitch ratio (O/A) or pulse width (U)",
+    "FILTERS   L lowpass   H highpass   B bandpass   (state-variable)",
+    "          left = cutoff, right = resonance (higher glyph = more)",
+    "SHAPERS   S soft clip/tanh (left=drive)   C hard clip (left=threshold)",
+    "          F wavefolder (left=amount)      D decimate/bitcrush (left=rate)",
+    "AMP/MOD   E envelope, note-gated (left=attack, right=release)",
+    "          G gain (left=amount)            R ring modulator (left=ratio)",
+    "ROUTING   M mix — adds the cell to its LEFT      ! output to master",
+    "",
+    "KEYS      arrows move · type a glyph to place · Backspace clears",
+    "          ( ) width -/+   _ + height -/+   Ctrl+arrows resize by one",
+    "          ? toggle this help · Esc quit",
+];
+
+#[derive(Clone, Copy, PartialEq)]
+enum Cs {
+    Fg(Color),
+    Cursor,
+}
 
-// Foreground colour by glyph category. (orca-rs uses one Normal colour; galdr
-// tints by role so a patch reads at a glance.)
 fn glyph_color(c: char) -> Color {
     match c {
-        'O' | 'A' | 'U' | 'V' | 'N' => Color::Cyan,          // sources
+        'O' | 'A' | 'U' | 'V' | 'N' => Color::Cyan,
-        'L' | 'H' | 'B' => Color::Blue,                      // filters
+        'L' | 'H' | 'B' => Color::Blue,
-        'S' | 'C' | 'F' | 'D' => Color::Yellow,              // shapers
+        'S' | 'C' | 'F' | 'D' => Color::Yellow,
-        'E' | 'G' | 'R' | 'M' => Color::Green,               // amp / mod
+        'E' | 'G' | 'R' | 'M' => Color::Green,
-        '!' => Color::Magenta,                               // output
+        '!' => Color::Magenta,
-        '0'..='9' => Color::Grey,                            // constants
+        '0'..='9' => Color::Grey,
-        'a'..='z' => Color::DarkYellow,                      // CC registers
+        'a'..='z' => Color::DarkYellow,
-        '.' => Color::DarkGrey,                              // empty
         _ => Color::White,
     }
 }
 
+struct Renderer {
+    cells: Vec<(char, Cs)>,
+    status: String,
+    tw: u16,
+    th: u16,
+    gw: usize,
+    gh: usize,
+    help: bool,
+    init: bool,
+}
+
+impl Renderer {
+    fn new() -> Self {
+        Renderer {
+            cells: Vec::new(),
+            status: String::new(),
+            tw: 0,
+            th: 0,
+            gw: 0,
+            gh: 0,
+            help: false,
+            init: false,
+        }
+    }
+}
+
 pub fn run(
     prog: Arc<ArcSwap<Program>>,
     voices: Arc<AtomicU32>,
@@ -46,61 +99,96 @@ pub fn run(
     let mut out = io::stdout();
     execute!(out, EnterAlternateScreen, Hide)?;
     let (mut cx, mut cy) = (0usize, 0usize);
+    let mut help = false;
+    let mut r = Renderer::new();
 
-    let res = main_loop(&mut out, &prog, &voices, &mut grid, latency, &mut cx, &mut cy);
+    let res = (|| -> io::Result<()> {
+        loop {
+            draw(&mut out, &grid, cx, cy, voices.load(Ordering::Relaxed), latency, help, &mut r)?;
+            if !event::poll(Duration::from_millis(33))? {
+                continue;
+            }
+            let Event::Key(k) = event::read()? else { continue };
+            if k.kind != KeyEventKind::Press {
+                continue;
+            }
+            let ctrl = k.modifiers.contains(KeyModifiers::CONTROL);
+            let mut resized = false;
+            let mut edited = false;
+            match k.code {
+                KeyCode::Esc => {
+                    if help {
+                        help = false;
+                    } else {
+                        return Ok(());
+                    }
+                }
+                KeyCode::Char('c') if ctrl => return Ok(()),
+                KeyCode::Char('?') => help = !help,
+                _ if help => {}
+                KeyCode::Char('(') => {
+                    grid.resize(grid.h, ruler_snap(grid.w, -1));
+                    resized = true;
+                }
+                KeyCode::Char(')') => {
+                    grid.resize(grid.h, ruler_snap(grid.w, 1));
+                    resized = true;
+                }
+                KeyCode::Char('_') => {
+                    grid.resize(ruler_snap(grid.h, -1), grid.w);
+                    resized = true;
+                }
+                KeyCode::Char('+') => {
+                    grid.resize(ruler_snap(grid.h, 1), grid.w);
+                    resized = true;
+                }
+                KeyCode::Left if ctrl => {
+                    grid.resize(grid.h, grid.w.saturating_sub(1));
+                    resized = true;
+                }
+                KeyCode::Right if ctrl => {
+                    grid.resize(grid.h, grid.w + 1);
+                    resized = true;
+                }
+                KeyCode::Up if ctrl => {
+                    grid.resize(grid.h.saturating_sub(1), grid.w);
+                    resized = true;
+                }
+                KeyCode::Down if ctrl => {
+                    grid.resize(grid.h + 1, grid.w);
+                    resized = true;
+                }
+                KeyCode::Left => cx = cx.saturating_sub(1),
+                KeyCode::Right => cx = (cx + 1).min(grid.w - 1),
+                KeyCode::Up => cy = cy.saturating_sub(1),
+                KeyCode::Down => cy = (cy + 1).min(grid.h - 1),
+                KeyCode::Backspace | KeyCode::Delete => {
+                    grid.set(cx, cy, '.');
+                    edited = true;
+                }
+                KeyCode::Char(c) => {
+                    grid.set(cx, cy, if c == ' ' { '.' } else { c });
+                    edited = true;
+                    cx = (cx + 1).min(grid.w - 1);
+                }
+                _ => {}
+            }
+            if resized {
+                cx = cx.min(grid.w - 1);
+                cy = cy.min(grid.h - 1);
+            }
+            if resized || edited {
+                prog.store(Arc::new(compile(&grid)));
+            }
+        }
+    })();
 
     execute!(out, Show, LeaveAlternateScreen)?;
     disable_raw_mode()?;
     res
 }
 
-fn main_loop(
+#[allow(clippy::too_many_arguments)]
-    out: &mut io::Stdout,
-    prog: &Arc<ArcSwap<Program>>,
-    voices: &Arc<AtomicU32>,
-    grid: &mut Grid,
-    latency: u32,
-    cx: &mut usize,
-    cy: &mut usize,
-) -> io::Result<()> {
-    loop {
-        draw(out, grid, *cx, *cy, voices.load(Ordering::Relaxed), latency)?;
-
-        if event::poll(Duration::from_millis(33))? {
-            if let Event::Key(k) = event::read()? {
-                if k.kind != KeyEventKind::Press {
-                    continue;
-                }
-                if k.code == KeyCode::Esc
-                    || (k.code == KeyCode::Char('c') && k.modifiers.contains(KeyModifiers::CONTROL))
-                {
-                    return Ok(());
-                }
-                let mut changed = false;
-                match k.code {
-                    KeyCode::Left => *cx = cx.saturating_sub(1),
-                    KeyCode::Right => *cx = (*cx + 1).min(W - 1),
-                    KeyCode::Up => *cy = cy.saturating_sub(1),
-                    KeyCode::Down => *cy = (*cy + 1).min(H - 1),
-                    KeyCode::Backspace | KeyCode::Delete => {
-                        grid.set(*cx, *cy, '.');
-                        changed = true;
-                    }
-                    KeyCode::Char(c) => {
-                        grid.set(*cx, *cy, if c == ' ' { '.' } else { c });
-                        changed = true;
-                        *cx = (*cx + 1).min(W - 1);
-                    }
-                    _ => {}
-                }
-                if changed {
-                    prog.store(Arc::new(compile(grid)));
-                }
-            }
-        }
-    }
-}
-
 fn draw(
     out: &mut io::Stdout,
     grid: &Grid,
@@ -108,38 +196,90 @@ fn draw(
     cy: usize,
     voices: u32,
     latency: u32,
+    help: bool,
+    r: &mut Renderer,
 ) -> io::Result<()> {
     let (tw, th) = terminal::size()?;
-    let off_x = (tw as usize).saturating_sub(W) / 2;
-    let off_y = (th as usize).saturating_sub(H + 1) / 2;
 
-    queue!(out, BeginSynchronizedUpdate, Clear(ClearType::All))?;
+    let full = !r.init
-    for row in 0..H {
+        || tw != r.tw
-        queue!(out, MoveTo(off_x as u16, (off_y + row) as u16))?;
+        || th != r.th
-        for col in 0..W {
+        || help != r.help
-            let c = grid.get(col, row);
+        || grid.w != r.gw
-            queue!(out, SetAttribute(Attribute::Reset))?;
+        || grid.h != r.gh;
-            if col == cx && row == cy {
+    if full {
-                queue!(out, SetAttribute(Attribute::Reverse))?;
+        queue!(out, Clear(ClearType::All))?;
+        r.cells = vec![('\0', Cs::Fg(Color::Reset)); grid.w * grid.h];
+        r.status.clear();
+        r.tw = tw;
+        r.th = th;
+        r.gw = grid.w;
+        r.gh = grid.h;
+        r.help = help;
+        r.init = true;
+    }
+
+    if help {
+        if full {
+            let oy = (th as usize).saturating_sub(HELP.len()) / 2;
+            let ox = (tw as usize).saturating_sub(74) / 2;
+            for (i, line) in HELP.iter().enumerate() {
+                queue!(
+                    out,
+                    MoveTo(ox as u16, (oy + i) as u16),
+                    SetAttribute(Attribute::Reset),
+                    SetForegroundColor(if i == 0 { Color::Magenta } else { Color::Grey }),
+                    Print(line)
+                )?;
+            }
+        }
+        return out.flush();
+    }
+
+    let off_x = (tw as usize).saturating_sub(grid.w) / 2;
+    let off_y = (th as usize).saturating_sub(grid.h + 1) / 2;
+    for row in 0..grid.h {
+        for col in 0..grid.w {
+            let raw = grid.get(col, row);
+            // ruler mark on empty intersections, for orientation while sizing
+            let disp = if raw == '.' {
+                if row % RULER == 0 && col % RULER == 0 { '+' } else { '.' }
             } else {
-                queue!(out, SetForegroundColor(glyph_color(c)))?;
+                raw
+            };
+            let cs = if col == cx && row == cy {
+                Cs::Cursor
+            } else if raw == '.' {
+                Cs::Fg(Color::DarkGrey)
+            } else {
+                Cs::Fg(glyph_color(raw))
+            };
+            let idx = row * grid.w + col;
+            if r.cells[idx] == (disp, cs) {
+                continue;
             }
-            queue!(out, Print(c))?;
+            r.cells[idx] = (disp, cs);
+            queue!(out, MoveTo((off_x + col) as u16, (off_y + row) as u16), SetAttribute(Attribute::Reset))?;
+            match cs {
+                Cs::Cursor => queue!(out, SetAttribute(Attribute::Reverse))?,
+                Cs::Fg(color) => queue!(out, SetForegroundColor(color))?,
+            }
+            queue!(out, Print(disp))?;
         }
     }
 
-    // Status line beneath the grid.
+    let status =
-    let status = format!(
+        format!("voices {voices}   {}x{}   latency {latency}f   ? help   Esc quit", grid.w, grid.h);
-        "voices {voices}  latency {latency}f   O~ A^ U pulse V tri N noise | L H B filt | S C F D shape | E env G gain R ring M mix | ! out   Esc quit"
+    if status != r.status {
-    );
+        r.status = status.clone();
-    let s: String = status.chars().take(tw as usize).collect();
+        let pad: String = format!("{status:<width$}", width = tw as usize);
         queue!(
             out,
             MoveTo(0, th.saturating_sub(1)),
             SetAttribute(Attribute::Reset),
             SetForegroundColor(Color::DarkGrey),
-        Print(s)
+            Print(pad.chars().take(tw as usize).collect::<String>())
         )?;
-    queue!(out, EndSynchronizedUpdate)?;
+    }
     out.flush()
 }