diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 91f7d9e..08e3277 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -16,6 +16,20 @@ option. Unless you explicitly state otherwise, any contribution intentionally su
the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any
additional terms or conditions.
+## AI assistance
+
+AI help is welcome. Luxe is built with plenty of it, much of it Luxe working on itself. Three things
+to hold to:
+
+- **Say so.** Name the tool and how much of the change it wrote in the pull request: "written with
+ Luxe on Claude Sonnet 5.5, then reviewed and edited by me", or "asked ChatGPT how the cache works,
+ wrote the fix myself". Tab completion doesn't count. A commit can carry the Linux kernel's
+ `Assisted-by: AGENT:MODEL` trailer.
+- **Understand it.** You should be able to explain what your change does and how it fits without
+ asking the tool. That's the bar for any change, and the one an agent makes easiest to skip.
+- **Write to people in your own words.** An issue or a pull request description is read by a person,
+ so keep it short, and label anything a model wrote.
+
## The gate
```bash
diff --git a/Cargo.lock b/Cargo.lock
index e1f7755..1b4a8b7 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1797,6 +1797,7 @@ dependencies = [
"base64",
"crossterm",
"futures",
+ "gif",
"image",
"luxe-core",
"luxe-tui",
diff --git a/README.md b/README.md
index 3a75b2e..a5941d5 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,9 @@
-
+
+
+
+
+
+
Luxe is a coding agent for your terminal, written in Rust. It works in your project with the model
you choose, then reads back what it changed as a Guided Review, so you can comment, ask for fixes,
@@ -156,6 +161,10 @@ Every page is also plain markdown in [`docs/guide/`](docs/guide/), and
the site and the demos are made; [`AGENTS.md`](AGENTS.md) has the rules an agent working here holds
to. Problems and questions go to [GitHub issues](https://github.com/evanwhittaker/luxe/issues).
+Luxe is built with AI assistance, much of it Luxe working on itself. Every change still passes the
+full test suite and CI before it merges, and its maintainer decides what does. If AI helped with
+yours, [say so](CONTRIBUTING.md#ai-assistance).
+
Luxe draws on Pi, by earendil-works, and on OpenCode, and on the unidirectional data flow of Elm
and Ratatui.
diff --git a/crates/luxe-cli/tests/mcp_commands/main.rs b/crates/luxe-cli/tests/mcp_commands/main.rs
index 87e1461..d39710a 100644
--- a/crates/luxe-cli/tests/mcp_commands/main.rs
+++ b/crates/luxe-cli/tests/mcp_commands/main.rs
@@ -15,6 +15,21 @@ fn project_server(project: &Path) {
std::fs::write(project.join(".mcp.json"), config.to_string()).unwrap();
}
+/// Whether Luxe launched the project's server. The marker is the proof when the child gets that far,
+/// but the child is this test binary starting up again, and on a slow runner Luxe can give up on the
+/// closed connection before that startup reaches the write; its report of the attempt is the proof
+/// then. A refused server is never launched, so neither can appear.
+fn started(project: &Path, stdout: &str) -> bool {
+ project.join("mcp-ran").exists() || stdout.contains("project-marker: failed to connect")
+}
+
+/// Whether Luxe refused to start the project's server: it says so, naming it. Checked alongside the
+/// absent marker, which alone would also pass for a server launched too slowly to have written it.
+fn refused(project: &Path, stdout: &str) -> bool {
+ stdout.contains("Not starting project MCP servers: project-marker")
+ && !project.join("mcp-ran").exists()
+}
+
fn tools(project: &Path, home: &Path, trust: bool) -> String {
run_mcp(project, home, trust, "tools")
}
@@ -56,8 +71,8 @@ fn tools_does_not_start_an_untrusted_project_server() {
let home = tempfile::tempdir().unwrap();
project_server(project.path());
let stdout = tools(project.path(), home.path(), false);
- assert!(!project.path().join("mcp-ran").exists(), "the project command ran: {stdout}");
- assert!(stdout.contains("project-marker") && stdout.contains("--trust-project"), "{stdout}");
+ assert!(refused(project.path(), &stdout), "the project command ran: {stdout}");
+ assert!(stdout.contains("--trust-project"), "{stdout}");
}
/// Refusing every project server would silently discard the CLI's explicit trust grant.
@@ -67,7 +82,7 @@ fn tools_starts_a_project_server_with_explicit_trust() {
let home = tempfile::tempdir().unwrap();
project_server(project.path());
let stdout = tools(project.path(), home.path(), true);
- assert!(project.path().join("mcp-ran").exists(), "the trusted command never ran: {stdout}");
+ assert!(started(project.path(), &stdout), "the trusted command never ran: {stdout}");
}
/// CLI tools must honor the same global opt-in the engine uses.
@@ -78,7 +93,7 @@ fn tools_honors_the_user_always_preference() {
project_server(project.path());
tooling_preference(&home.path().join("luxe"), "always");
let stdout = tools(project.path(), home.path(), false);
- assert!(project.path().join("mcp-ran").exists(), "the user opt-in was ignored: {stdout}");
+ assert!(started(project.path(), &stdout), "the user opt-in was ignored: {stdout}");
}
/// Explicit trust must not override the user's global refusal to start project tooling.
@@ -89,7 +104,7 @@ fn tools_honors_the_user_never_preference_even_with_trust() {
project_server(project.path());
tooling_preference(&home.path().join("luxe"), "never");
let stdout = tools(project.path(), home.path(), true);
- assert!(!project.path().join("mcp-ran").exists(), "the user refusal was ignored: {stdout}");
+ assert!(refused(project.path(), &stdout), "the user refusal was ignored: {stdout}");
}
/// A repository must not grant itself permission by setting the global-only tooling preference.
@@ -100,7 +115,7 @@ fn tools_ignores_a_project_always_preference() {
project_server(project.path());
tooling_preference(&project.path().join(".luxe"), "always");
let stdout = tools(project.path(), home.path(), false);
- assert!(!project.path().join("mcp-ran").exists(), "the project granted itself trust: {stdout}");
+ assert!(refused(project.path(), &stdout), "the project granted itself trust: {stdout}");
}
/// The trust filter must not block a server declared by the user, outside the project.
@@ -112,5 +127,5 @@ fn tools_starts_a_user_server_without_project_trust() {
std::fs::create_dir_all(home.path().join("luxe")).unwrap();
std::fs::rename(project.path().join(".mcp.json"), home.path().join("luxe/mcp.json")).unwrap();
let stdout = tools(project.path(), home.path(), false);
- assert!(project.path().join("mcp-ran").exists(), "the user command never ran: {stdout}");
+ assert!(started(project.path(), &stdout), "the user command never ran: {stdout}");
}
diff --git a/crates/luxe-core/src/redact.rs b/crates/luxe-core/src/redact.rs
index eea71e3..2150eb7 100644
--- a/crates/luxe-core/src/redact.rs
+++ b/crates/luxe-core/src/redact.rs
@@ -225,7 +225,9 @@ const PATTERNS: [(&str, &str, SecretConfidence, &str); 11] = [
r"AIza[0-9A-Za-z_\-]{35}",
"[REDACTED_GOOGLE_KEY]",
SecretConfidence::Format,
- "AIzaabcdefghijklmnopqrstuvwxyz012345678",
+ // Joined at compile time so the source holds no key-shaped run: a Google key has no
+ // checksum, so secret scanners flag any literal of its shape, invented ones included
+ concat!("AIza", "abcdefghijklmnopqrstuvwxyz012345678"),
),
(
r"(?:sk|rk)_(?:live|test)_[0-9A-Za-z]{10,}",
diff --git a/crates/luxe-tui/Cargo.toml b/crates/luxe-tui/Cargo.toml
index 46a23d4..b52d3b0 100644
--- a/crates/luxe-tui/Cargo.toml
+++ b/crates/luxe-tui/Cargo.toml
@@ -54,6 +54,8 @@ clipboard-images = ["clipboard"]
# Integration tests link the library without `cfg(test)`; normal dependents keep fixtures off.
luxe-tui = { path = ".", features = ["fixture"] }
tempfile = "3"
+# The README's animated wordmark (examples/wordmark_gif). Already in the tree through `image`.
+gif = "0.14"
[lints]
workspace = true
@@ -71,6 +73,10 @@ test = true
name = "wordmark_svg"
test = true
+[[example]]
+name = "wordmark_gif"
+test = true
+
[[example]]
name = "theme_css"
test = true
diff --git a/crates/luxe-tui/examples/wordmark_gif.rs b/crates/luxe-tui/examples/wordmark_gif.rs
new file mode 100644
index 0000000..7394a1c
--- /dev/null
+++ b/crates/luxe-tui/examples/wordmark_gif.rs
@@ -0,0 +1,197 @@
+//! wordmark_gif — the logotype as the terminal lights it, as a looping GIF for the README.
+//!
+//! Every frame comes from [`Wordmark::lines_at`], the same rows and the same two lights the
+//! dashboard draws, so the recording cannot drift from the product. GitHub shows a README image on
+//! its own page background, light or dark, so the background is transparent: the art is hard-edged
+//! cells, which GIF's one-bit transparency draws exactly.
+//!
+//! ```sh
+//! cargo run -p luxe-tui --example wordmark_gif -- dark > web/src/assets/generated/wordmark-dark.gif
+//! cargo run -p luxe-tui --example wordmark_gif -- light > web/src/assets/generated/wordmark-light.gif
+//! ```
+
+use luxe_tui::main_loop::ANIMATION_TICK;
+use luxe_tui::widgets::{
+ Wordmark, WordmarkInk, DRIFT_FRAME_TICKS, DRIFT_PERIOD_TICKS, SHINE_CYCLE_TICKS,
+ SHINE_SWEEP_TICKS,
+};
+use ratatui::style::Color;
+use std::borrow::Cow;
+use std::io::Write;
+
+/// Pixels per cell: the 10×22 grid `wordmark_svg` draws, twice over so the mark stays sharp on a
+/// high-density screen when the README shows it at half size.
+const CELL_W: usize = 20;
+const CELL_H: usize = 44;
+
+fn main() {
+ let dark = match std::env::args().nth(1).as_deref() {
+ Some("dark") => true,
+ Some("light") => false,
+ other => {
+ eprintln!("usage: wordmark_gif dark|light (got {other:?})");
+ std::process::exit(2);
+ }
+ };
+ let mut out = Vec::new();
+ write_gif(&mut out, ink(dark)).expect("encoding into memory cannot fail");
+ std::io::stdout().write_all(&out).expect("write the GIF to stdout");
+}
+
+/// The luxe theme's accent and canvas. `dark` sets how hard the shine pushes toward white: a light
+/// page washes the letters out sooner, so it gets the gentler peak the terminal uses on light
+/// themes. The canvas stays the dark one either way, so the drift deepens the brass on both.
+fn ink(dark: bool) -> WordmarkInk {
+ let theme = luxe_core::theme::ThemeRegistry::new().resolve("luxe").expect("a built-in theme");
+ let rgb = |token: &str| match theme.get(token) {
+ Some(luxe_core::theme::ColorValue::Rgb(red, green, blue)) => {
+ Color::Rgb(*red, *green, *blue)
+ }
+ other => panic!("the luxe theme's {token} is a color, not {other:?}"),
+ };
+ WordmarkInk { accent: rgb("accent"), canvas: Some(rgb("background")), dark }
+}
+
+/// The ticks a frame is drawn at across one loop: every tick while the shine crosses, every drift
+/// frame while it rests, as the terminal repaints.
+///
+/// One loop is one drift period, which has to close on itself for the GIF to loop without a seam.
+/// The shine crosses once at its start and rests for the remainder.
+fn frame_ticks() -> Vec {
+ (0..DRIFT_PERIOD_TICKS)
+ .filter(|&tick| tick < SHINE_SWEEP_TICKS || tick % DRIFT_FRAME_TICKS == 0)
+ .collect()
+}
+
+/// Each frame's delay in hundredths of a second, rounded against the running clock so the loop
+/// totals the drift period rather than gaining a rounding error per frame.
+fn delays(ticks: &[u64]) -> Vec {
+ let tick_ms = ANIMATION_TICK.as_millis() as f64;
+ let at = |tick: u64| (tick as f64 * tick_ms / 10.0).round() as i64;
+ let ends = ticks.iter().skip(1).copied().chain([DRIFT_PERIOD_TICKS]);
+ ticks.iter().zip(ends).map(|(&start, end)| (at(end) - at(start)).max(1) as u16).collect()
+}
+
+fn write_gif(out: &mut Vec, ink: WordmarkInk) -> Result<(), gif::EncodingError> {
+ let size = Wordmark::Full;
+ let (width, height) = (usize::from(size.width()) * CELL_W, usize::from(size.height()) * CELL_H);
+ let mut encoder = gif::Encoder::new(out, width as u16, height as u16, &[])?;
+ encoder.set_repeat(gif::Repeat::Infinite)?;
+ let ticks = frame_ticks();
+ for (&tick, delay) in ticks.iter().zip(delays(&ticks)) {
+ // The shine's own cycle is shorter than the loop; past it the shine rests
+ let shine = (tick < SHINE_CYCLE_TICKS).then_some(tick);
+ let (pixels, palette) = render(size, ink, tick, shine, width);
+ encoder.write_frame(&frame((width, height), pixels, palette, delay))?;
+ }
+ Ok(())
+}
+
+/// One whole-canvas frame, index 0 transparent.
+fn frame(
+ (width, height): (usize, usize),
+ pixels: Vec,
+ palette: Vec,
+ delay: u16,
+) -> gif::Frame<'static> {
+ gif::Frame {
+ width: width as u16,
+ height: height as u16,
+ buffer: Cow::Owned(pixels),
+ palette: Some(palette),
+ transparent: Some(0),
+ delay,
+ // Cleared between frames, or a cell turned transparent would keep the last frame's ink
+ dispose: gif::DisposalMethod::Background,
+ ..gif::Frame::default()
+ }
+}
+
+/// One frame as palette indices and the palette, index 0 transparent.
+fn render(
+ size: Wordmark,
+ ink: WordmarkInk,
+ drift: u64,
+ shine: Option,
+ width: usize,
+) -> (Vec, Vec) {
+ let mut palette = vec![0u8, 0, 0];
+ let mut pixels = vec![0u8; width * usize::from(size.height()) * CELL_H];
+ for (row, line) in size.lines_at(ink, drift, shine).iter().enumerate() {
+ let cells = line
+ .spans
+ .iter()
+ .flat_map(|span| span.content.chars().map(move |glyph| (glyph, span.style.fg)));
+ for (column, (glyph, fg)) in cells.enumerate() {
+ let Some(Color::Rgb(red, green, blue)) = fg else { continue };
+ let index = palette_index(&mut palette, [red, green, blue]);
+ ink_cell(&mut pixels, width, (column, row), glyph, index);
+ }
+ }
+ (pixels, palette)
+}
+
+/// Paints the part of cell `(column, row)` that `glyph` inks: all of it, or the top or bottom half.
+fn ink_cell(
+ pixels: &mut [u8],
+ width: usize,
+ (column, row): (usize, usize),
+ glyph: char,
+ index: u8,
+) {
+ let (top, bottom) = match glyph {
+ '█' => (0, CELL_H),
+ '▀' => (0, CELL_H / 2),
+ '▄' => (CELL_H / 2, CELL_H),
+ _ => return,
+ };
+ for y in row * CELL_H + top..row * CELL_H + bottom {
+ pixels[y * width + column * CELL_W..][..CELL_W].fill(index);
+ }
+}
+
+/// The palette slot for `color`, adding it the first time it is seen.
+fn palette_index(palette: &mut Vec, color: [u8; 3]) -> u8 {
+ let existing = palette.chunks(3).position(|entry| entry == color);
+ let index = existing.unwrap_or_else(|| {
+ palette.extend_from_slice(&color);
+ palette.len() / 3 - 1
+ });
+ u8::try_from(index).expect("a frame of one hue lit two ways stays far under 256 colors")
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ /// The loop is one drift period to the hundredth of a second, so it closes without a jump.
+ #[test]
+ fn the_frames_add_up_to_one_drift_period() {
+ let total: u32 = delays(&frame_ticks()).iter().map(|&delay| u32::from(delay)).sum();
+ let period_cs =
+ (DRIFT_PERIOD_TICKS as f64 * ANIMATION_TICK.as_millis() as f64 / 10.0).round();
+ assert_eq!(f64::from(total), period_cs);
+ }
+
+ /// The shine crosses frame by frame, and the rest repaints at the drift's slower cadence.
+ #[test]
+ fn the_shine_gets_every_tick_and_the_rest_every_drift_frame() {
+ let ticks = frame_ticks();
+ assert!((0..SHINE_SWEEP_TICKS).all(|tick| ticks.contains(&tick)));
+ assert!(ticks
+ .iter()
+ .filter(|&&tick| tick >= SHINE_SWEEP_TICKS)
+ .all(|tick| tick % DRIFT_FRAME_TICKS == 0));
+ }
+
+ /// The background is transparent and the letters are ink: a frame has both.
+ #[test]
+ fn a_frame_is_transparent_around_inked_letters() {
+ let size = Wordmark::Full;
+ let width = usize::from(size.width()) * CELL_W;
+ let (pixels, palette) = render(size, ink(true), 0, None, width);
+ assert!(pixels.contains(&0), "transparent background");
+ assert!(pixels.iter().any(|&index| index != 0), "inked letters");
+ assert!(palette.len() / 3 > 1);
+ }
+}
diff --git a/crates/luxe-tui/src/main_loop.rs b/crates/luxe-tui/src/main_loop.rs
index 0e113c2..0ccec31 100644
--- a/crates/luxe-tui/src/main_loop.rs
+++ b/crates/luxe-tui/src/main_loop.rs
@@ -42,6 +42,11 @@ use std::time::Duration;
use tokio::sync::mpsc;
use tokio::time::interval;
+/// The animation tick, about 30 a second: what every timed effect counts in, the wordmark's lights
+/// and the spinner included. Public so a recording of one, the README's wordmark, keeps the same
+/// time.
+pub const ANIMATION_TICK: Duration = Duration::from_millis(33);
+
/// Why the TUI returned control to the CLI.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum TuiExit {
@@ -181,7 +186,7 @@ pub async fn run(
let mut sources = Sources {
event_rx,
terminal_events: Some(EventStream::new()),
- tick: interval(Duration::from_millis(33)), // ~30fps
+ tick: interval(ANIMATION_TICK),
// One listener for the run, rather than a fresh registration on every pass of a loop that
// turns over as fast as the terminal can deliver keys.
interrupted: Box::pin(tokio::signal::ctrl_c()),
diff --git a/crates/luxe-tui/src/widgets.rs b/crates/luxe-tui/src/widgets.rs
index 1aa75bf..9f50319 100644
--- a/crates/luxe-tui/src/widgets.rs
+++ b/crates/luxe-tui/src/widgets.rs
@@ -34,7 +34,8 @@ pub use slab::{
pub use tool_glyph::{tool_glyph, tool_icon, GENERIC_TOOL};
pub use wordmark::{
banner_frame_due, render_wordmark, smoothstep, BannerClock, Wordmark, WordmarkInk, BAND,
- DRIFT_DEPTH, LEAN, PEAK_DARK, PEAK_LIGHT, SHINE_CYCLE_TICKS, SHINE_SWEEP_TICKS, STILL_TICK,
+ DRIFT_DEPTH, DRIFT_FRAME_TICKS, DRIFT_PERIOD_TICKS, LEAN, PEAK_DARK, PEAK_LIGHT,
+ SHINE_CYCLE_TICKS, SHINE_SWEEP_TICKS, STILL_TICK,
};
pub use wrap::{wrap_cells, wrap_line, wrap_lines, wrapped_row_starts};
diff --git a/crates/luxe-tui/src/widgets/wordmark.rs b/crates/luxe-tui/src/widgets/wordmark.rs
index 3993edb..4fcdb0d 100644
--- a/crates/luxe-tui/src/widgets/wordmark.rs
+++ b/crates/luxe-tui/src/widgets/wordmark.rs
@@ -23,8 +23,11 @@
//! wordmark in the flat accent and skip both rather than approximate them.
mod art;
+mod light;
use art::{column_groups, FULL_ART, LINE_ART, SMALL_ART};
+pub use light::smoothstep;
+use light::{blend_toward, Pass};
use ratatui::layout::{Alignment, Rect};
use ratatui::style::{Color, Modifier, Style};
use ratatui::text::{Line, Span};
@@ -194,14 +197,23 @@ impl Wordmark {
/// A still is a frame of the same animation rather than a separate code path, so what a reader
/// sees with `banner_animation = false` is a moment of what everyone else sees moving.
pub fn lines(self, ink: WordmarkInk, tick: Option) -> Vec> {
- let (tick, pass) = match tick {
- Some(tick) => (tick, Pass::at(self, ink, tick)),
- None => (STILL_TICK, None),
- };
+ match tick {
+ Some(tick) => self.lines_at(ink, tick, Some(tick)),
+ None => self.lines_at(ink, STILL_TICK, None),
+ }
+ }
+
+ /// The logotype's rows with each light set on its own: the drift at `drift`, and the shine at
+ /// `shine`, or none when that is `None`.
+ ///
+ /// The terminal runs both from one clock and keeps them out of step on purpose, so its pattern
+ /// takes minutes to repeat. A recording has to loop, so it sets the two to meet.
+ pub fn lines_at(self, ink: WordmarkInk, drift: u64, shine: Option) -> Vec> {
+ let pass = shine.and_then(|tick| Pass::at(self, ink, tick));
self.rows()
.iter()
.enumerate()
- .map(|(row, text)| self.row_line(text, row as u16, ink, tick, pass.as_ref()))
+ .map(|(row, text)| self.row_line(text, row as u16, ink, drift, pass.as_ref()))
.collect()
}
@@ -412,78 +424,13 @@ pub fn render_wordmark(
pub const SHINE_SWEEP_TICKS: u64 = SWEEP_TICKS;
/// One pass plus its rest, in ticks.
pub const SHINE_CYCLE_TICKS: u64 = CYCLE_TICKS;
+/// One whole pass of the drift, in ticks.
+pub const DRIFT_PERIOD_TICKS: u64 = DRIFT_TICKS;
+/// Ticks between drift frames while no shine runs.
+pub const DRIFT_FRAME_TICKS: u64 = DRIFT_FRAME;
fn shine_active(tick: u64) -> bool {
tick % CYCLE_TICKS < SWEEP_TICKS
}
-
-/// One tick of one pass: where the highlight band sits, and how hard it pushes.
-struct Pass {
- center: f32,
- half: f32,
- peak: f32,
- lean: f32,
-}
-
-impl Pass {
- /// The pass in flight at `tick`, or `None` while the logotype rests.
- fn at(size: Wordmark, ink: WordmarkInk, tick: u64) -> Option {
- let phase = tick % CYCLE_TICKS;
- if phase >= SWEEP_TICKS {
- return None;
- }
- let span = size.span();
- let half = (span * BAND).max(1.0);
- let travel = span + 2.0 * half;
- let progress = phase as f32 / SWEEP_TICKS as f32;
-
- Some(Self {
- // The band starts and ends clear of the letters, so a pass arrives and leaves rather
- // than appearing half-drawn across them.
- center: -half + progress * travel,
- half,
- peak: if ink.dark { PEAK_DARK } else { PEAK_LIGHT },
- lean: LEAN,
- })
- }
-
- /// How far this cell is lifted toward the highlight.
- fn lift(&self, column: u16, row: u16) -> f32 {
- let axis = f32::from(column) + self.lean * f32::from(row);
- let distance = ((axis - self.center).abs() / self.half).min(1.0);
- smoothstep(1.0 - distance) * self.peak
- }
-}
-
-/// Smooth 0→1 with zero slope at both ends, so a band edge has no seam.
-///
-/// The shape of the highlight, and the whole reason it reads as light rather than as a stripe: a
-/// linear falloff leaves a crease along the ridge and a hard shoulder at each edge. Public so the
-/// website samples this curve rather than approximating it.
-pub fn smoothstep(t: f32) -> f32 {
- let t = t.clamp(0.0, 1.0);
- t * t * (3.0 - 2.0 * t)
-}
-
-/// Alpha-blend `base` `amount` of the way toward `target`.
-///
-/// An ANSI/indexed palette has no channels to mix, so an unblendable color comes back untouched
-/// rather than as an invented RGB approximation of the terminal's own.
-fn blend_toward(base: Color, target: Color, amount: f32) -> Color {
- let (Color::Rgb(red, green, blue), Color::Rgb(tr, tg, tb)) = (base, target) else {
- return base;
- };
- if amount <= 0.0 {
- return base;
- }
- let amount = amount.clamp(0.0, 1.0);
- let lift = |channel: u8, toward: u8| {
- (f32::from(channel) + (f32::from(toward) - f32::from(channel)) * amount)
- .round()
- .clamp(0.0, 255.0) as u8
- };
- Color::Rgb(lift(red, tr), lift(green, tg), lift(blue, tb))
-}
-
#[cfg(test)]
mod tests;
diff --git a/crates/luxe-tui/src/widgets/wordmark/light.rs b/crates/luxe-tui/src/widgets/wordmark/light.rs
new file mode 100644
index 0000000..787e9f6
--- /dev/null
+++ b/crates/luxe-tui/src/widgets/wordmark/light.rs
@@ -0,0 +1,75 @@
+//! Light — the shine's band, the curve it falls off along, and the blend both lights paint with.
+//!
+//! The math of the two lights on their own, apart from the art they land on: the parent decides
+//! which cells are ink and asks here how far each one is lifted.
+
+use super::{Wordmark, WordmarkInk, BAND, CYCLE_TICKS, LEAN, PEAK_DARK, PEAK_LIGHT, SWEEP_TICKS};
+use ratatui::style::Color;
+
+/// One tick of one pass: where the highlight band sits, and how hard it pushes.
+pub(super) struct Pass {
+ center: f32,
+ half: f32,
+ peak: f32,
+ lean: f32,
+}
+
+impl Pass {
+ /// The pass in flight at `tick`, or `None` while the logotype rests.
+ pub(super) fn at(size: Wordmark, ink: WordmarkInk, tick: u64) -> Option {
+ let phase = tick % CYCLE_TICKS;
+ if phase >= SWEEP_TICKS {
+ return None;
+ }
+ let span = size.span();
+ let half = (span * BAND).max(1.0);
+ let travel = span + 2.0 * half;
+ let progress = phase as f32 / SWEEP_TICKS as f32;
+
+ Some(Self {
+ // The band starts and ends clear of the letters, so a pass arrives and leaves rather
+ // than appearing half-drawn across them.
+ center: -half + progress * travel,
+ half,
+ peak: if ink.dark { PEAK_DARK } else { PEAK_LIGHT },
+ lean: LEAN,
+ })
+ }
+
+ /// How far this cell is lifted toward the highlight.
+ pub(super) fn lift(&self, column: u16, row: u16) -> f32 {
+ let axis = f32::from(column) + self.lean * f32::from(row);
+ let distance = ((axis - self.center).abs() / self.half).min(1.0);
+ smoothstep(1.0 - distance) * self.peak
+ }
+}
+
+/// Smooth 0→1 with zero slope at both ends, so a band edge has no seam.
+///
+/// The shape of the highlight, and the whole reason it reads as light rather than as a stripe: a
+/// linear falloff leaves a crease along the ridge and a hard shoulder at each edge. Public so the
+/// website samples this curve rather than approximating it.
+pub fn smoothstep(t: f32) -> f32 {
+ let t = t.clamp(0.0, 1.0);
+ t * t * (3.0 - 2.0 * t)
+}
+
+/// Alpha-blend `base` `amount` of the way toward `target`.
+///
+/// An ANSI/indexed palette has no channels to mix, so an unblendable color comes back untouched
+/// rather than as an invented RGB approximation of the terminal's own.
+pub(super) fn blend_toward(base: Color, target: Color, amount: f32) -> Color {
+ let (Color::Rgb(red, green, blue), Color::Rgb(tr, tg, tb)) = (base, target) else {
+ return base;
+ };
+ if amount <= 0.0 {
+ return base;
+ }
+ let amount = amount.clamp(0.0, 1.0);
+ let lift = |channel: u8, toward: u8| {
+ (f32::from(channel) + (f32::from(toward) - f32::from(channel)) * amount)
+ .round()
+ .clamp(0.0, 255.0) as u8
+ };
+ Color::Rgb(lift(red, tr), lift(green, tg), lift(blue, tb))
+}
diff --git a/scripts/site-assets.sh b/scripts/site-assets.sh
index 24d6739..dc6e5d8 100755
--- a/scripts/site-assets.sh
+++ b/scripts/site-assets.sh
@@ -140,28 +140,9 @@ wordmark() { cargo run --quiet --release -p luxe-tui --example wordmark_svg -- "
tokens() { cargo run --quiet --release -p luxe-tui --example theme_css; }
catalog() { cargo run --quiet --release -p luxe-tui --example theme_css -- --json; }
shiki() { cargo run --quiet --release -p luxe-tui --example shiki_theme -- "$@"; }
-
-# The README's wordmark. GitHub shows an image on its own, where the CSS variables the site paints
-# the letters with do not exist and every letter would fall back to black, so this copy carries
-# the theme's own colors and its background: the same on GitHub's light pages as on its dark ones.
-banner() {
- python3 - "$1/wordmark.svg" "$1/tokens.css" <<'PY'
-import re, sys
-svg, css = (open(path).read() for path in sys.argv[1:])
-color = lambda name: re.search(rf"--luxe-{name}:\s*(#[0-9a-f]{{6}})", css).group(1)
-svg = re.sub(r"var\(--luxe-(wordmark-\d), currentColor\)", lambda m: color(m.group(1)), svg)
-width, height = (int(n) for n in re.search(r'viewBox="0 0 (\d+) (\d+)"', svg).groups())
-pad_x, pad_y = 120, 72
-box = (width + 2 * pad_x, height + 2 * pad_y)
-svg = re.sub(
- r'viewBox="[^"]*" width="\d+" height="\d+"',
- f'viewBox="{-pad_x} {-pad_y} {box[0]} {box[1]}" width="{box[0]}" height="{box[1]}"',
- svg,
-)
-background = f''
-print(svg.replace("", "\n " + background, 1), end="")
-PY
-}
+# The README's wordmark, animated as the terminal lights it, transparent for GitHub's light and dark
+# pages alike. Two variants: a light page washes the shine out sooner, so it gets the gentler one
+wordmark_gif() { cargo run --quiet --release -p luxe-tui --example wordmark_gif -- "$@"; }
generate() {
local target="$1" guide_target="$2"
@@ -171,7 +152,8 @@ generate() {
wordmark mark >"${target}/mark.svg"
wordmark tile >"${target}/tile.svg"
tokens >"${target}/tokens.css"
- banner "${target}" >"${target}/wordmark-banner.svg"
+ wordmark_gif dark >"${target}/wordmark-dark.gif"
+ wordmark_gif light >"${target}/wordmark-light.gif"
catalog >"${target}/themes.json"
facts "${target}" >"${target}/facts.json"
shiki luxe >"${target}/shiki-luxe.json"
@@ -211,7 +193,8 @@ print(','.join(['luxe'] + names))
# One release build up front. Every generator is a separate `cargo run`, and letting each discover
# that for itself turns a five-second job into a minute of cargo deciding it has nothing to do.
cargo build --quiet --release -p luxe-tui --features fixture \
- --example fixture_svg --example wordmark_svg --example theme_css --example shiki_theme
+ --example fixture_svg --example wordmark_svg --example wordmark_gif --example theme_css \
+ --example shiki_theme
if [[ "${check}" == true ]]; then
scratch="$(mktemp -d)"
diff --git a/web/src/assets/generated/wordmark-banner.svg b/web/src/assets/generated/wordmark-banner.svg
deleted file mode 100644
index f933d70..0000000
--- a/web/src/assets/generated/wordmark-banner.svg
+++ /dev/null
@@ -1,9 +0,0 @@
-
diff --git a/web/src/assets/generated/wordmark-dark.gif b/web/src/assets/generated/wordmark-dark.gif
new file mode 100644
index 0000000..00504a9
Binary files /dev/null and b/web/src/assets/generated/wordmark-dark.gif differ
diff --git a/web/src/assets/generated/wordmark-light.gif b/web/src/assets/generated/wordmark-light.gif
new file mode 100644
index 0000000..703d3a1
Binary files /dev/null and b/web/src/assets/generated/wordmark-light.gif differ