Hello! Been working on ghcitty. Figured there might be some cross-pollination on this sub)) It uses reedline quite heavily, and would love to trade notes w/ nushell, and PTY-esque style app hackers in general.

This is not a serious project; I just wanted to experiment with Bevy. 😄 It's the first game I've ever created, so I'm interested in learning about the aspects I could improve.
https://github.com/NiiightmareXD/golab

Charton is a columnar-native plotting library designed to keep memory layouts as close to Apache Arrow as possible, allowing for near-zero-copy integration.

Here’s the core of how it handles data:

pub enum ColumnVector {
    Boolean { data: Vec<bool>, validity: Option<Vec<u8>> },
    Int8 { data: Vec<i8>, validity: Option<Vec<u8>> },
    // ... handles all int/float types
    String { data: Vec<String>, validity: Option<Vec<u8>> },
    Categorical { keys: Vec<u32>, values: Vec<String>, validity: Option<Vec<u8>> },
    Datetime { data: Vec<i64>, validity: Option<Vec<u8>>, timezone: Option<String> },
}
    // ... other types

And the Dataset structure ensures alignment:

pub struct Dataset {
    schema: AHashMap<String, usize>,
    columns: Vec<Arc<ColumnVector>>,
    row_count: usize,
}

The load_polars_df! macro is ready to use, and the Altair-style declarative API makes building layered charts intuitively.

The roadmap is to go full native Arrow and eventually integrate DataFusion for a "SQL-to-chart" workflow. It’s still early days, so if you’re doing data analysis in Rust, I’d love to get your thoughts or feedback on the API.

I've spent the last few months building RMUX, a terminal multiplexer written from scratch in Rust.

What it is

A tmux-compatible multiplexer with about 90 command snapshots covered in the docs, plus a second surface: a typed async Rust SDK talking to the same local daemon. Many tmux-style workflows, keybindings, and scripts should feel familiar, but RMUX also exposes structured automation primitives instead of only terminal text scraping.

Architecture

• One local daemon and one wire protocol behind the public surfaces: a tmux-style CLI, a typed SDK, and a ratatui integration crate.
• Native PTY/runtime handling per platform: Unix PTYs + Unix domain sockets on Linux/macOS, real ConPTY + Named Pipes on Windows. No WSL required. Getting ConPTY to behave was one of the hardest parts. And Tokio for async ofc
• The SDK exposes typed handles for `Session` / `Window` / `Pane`, with stable pane IDs, structured snapshots, output streams, and locator-style waits.

Example:

pane.get_by_text("Ready").wait_for().await?;
pane.keyboard().type_text("hello").await?;
pane.wait_for_load_state(TerminalLoadState::Quiet).await?;
pane.expect_visible_text().to_contain("hello").await?;

The public SDK/protocol/render crates use `#![forbid(unsafe_code)]`; unsafe code is isolated in the low-level platform crates that need OS/PTY/IPC FFI.

Why I built it

I've been using tmux for a long time and grew tired of having to do grep every now and since. I then thought that adding playwright capabilities and rewriting everything in Rust would be a game changer. I hope you will like it :) You can do so much: ci, agents orchestration, testing TUIs, building custom dashboards... and it includes natively ratatui.

Repo: https://github.com/Helvesec/rmux

Docs + demos: https://rmux.io

Install: cargo install rmux --locked

 It's a v0.2 preview. Very open to feedback on the architecture, the async API design, or how I'm handling ConPTY. Happy to answer anything.

When I need to review a lot of ai generated code or code in general, I either open a browser tab and lose my context, or pipe it through git diff and scroll through a wall of red and green that forgets everything the moment I close it. No way to leave notes, no way to jump between files, no way to come back later and pick up where I left off.

So I built lazydiff. The core idea was simple, a diff reviewer that lives in the terminal, remembers state, and actually understands code structure.

The first decision was rendering. I went with ratatui and virtualized scrolling, only the visible rows get drawn each frame. This matters because agent-generated diffs can be massive. The benchmark fixture I test against is an 11k-line Node.js PR diff, and it renders at 60fps with sub-2ms frame times. I didn't want to build something that felt sluggish on real-world diffs.

For syntax highlighting I use tree-sitter(a thing I have been loving for so long now), but the tricky part with diffs is that deleted code needs to be highlighted in its original language context, not just painted red. So lazydiff reconstructs both sides of the file independently and maps highlights back through the diff. Inline diffs tokenize each changed line pair and run LCS to show exactly which words changed, you immediately see the meaningful difference without scanning the whole line.

The part I'm most excited about is semantic diffs. lazydiff uses https://github.com/Ataraxy-Labs/sem, which I open-sourced separately and got a lot of love from the Rust community. Instead of just showing line by line level diffs, it parses changes into semantically meaningful entity graphs for functions added, methods modified, classes moved. You see the structure of your changes and how they connect to each other. This is the same engine behind https://github.com/Ataraxy-Labs/weave, the semantic merge driver I built

The agent workflow is what motivated the whole project. You can leave threaded comments anchored to exact lines questions, instructions, notes and review quite fast, which was the utmost desire of the community. Agents also read them via lazydiff agent list and reply via CLI. The whole review session persists to SQLite locally, so you can close the terminal, come back the next day, and everything is exactly where you left it.

License:MIT Licensed

Open Source Repo: https://github.com/Ataraxy-Labs/lazydiff

This is a project to visualise and evaluate matrix transformations / expressions involving 2x2 matrices, 2D vectors, and floats, such as multiplication, inversing, scaling, addition, determinant, dot product and more.

I've had intuition for this kind of thing for a long time, but never really got the chance to share it with people, so I thought as one of my first bigger rust projects, why not give it a go? And then I realised I could put it on a website and share it with everyone else without them having to download an executable, so I compiled it for WASM.

I'd love to see what others think of this and what they might want to add, so contributions, issues and any feedback is completely welcome!

Github

Website (www.fullw.me)

I've been using mpv-paper on Hyprland for a couple months but ran into really high CPU usage, so I decided to write my own solution.

Phonto uses GStreamer and EGL to keep the entire decoding and rendering pipeline on the GPU, making much better use of resources compared to CPU-based approaches.

A friend also jumped in and added MacOS support, including playing live wallpapers on the lock screen which was a nice bonus.

Still missing a few things like multi-monitor support but that's coming soon. Other feature requests and contributions are welcome!

GitHub: https://github.com/museslabs/phonto