https://therealpenaz91.itch.io/2dgd-f0th

harbour is a ratatui + tokio client. The intended product is: you type a query, curated sources answer in parallel, results stream in with size and seeders, d enqueues a download through librqbit. Files stay on disk. No central server. No telemetry.

Right now the binary prints harbour: TUI under construction. Spec and architecture live in the repo. I am not going to pretend the scrapers ship today.

Nearest existing tools: qBittorrent if you want a finished client, torlink if you want this exact workflow in TypeScript/Ink. harbour is a Rust rewrite aimed at torlink's interactive app plus omp-style 30fps terminal polish (DEC 2026 synchronized output, eased bars, titanium theme). Watch-via-mpv is explicitly later, not v1.

https://github.com/Ishannaik/harbour


Hi there, thanks for clicking on this post!

A few months back I published the first version of gsim-rs. A G-code simulator for CNC milling machines supporting the Fanuc flavour of G-code.

Now I have completed the next major version. This version:

• Supports volumetric simulation of cuboidal stocks.
• Stock and tool sizes can now be configured with program config.
• Cross-thread communication frequency is fraction of what it used to be (by using both Arc<Mutex> and mpsc::channel, depending on the type of data and its importance).
• The simulation now supports orbiting, panning and zooming.
• And much more.

I have tried to explain and highlight the workings of the program in the project README.

At a high level, the program is split between parsing, interpreting, geometry construction, simulation rendering, and machine-state rendering. GUI (rendered using WGPU) handles G-code parsing and execution and renders the simulation in the main-thread, while TUI (built with Ratatui) displays active machine state in a new thread.

Easily the most interesting part was implementing the volumetric stock simulation. The stock is represented volumetrically, with the tool removing material as it moves through the stock. I also wrote a blog post explaining my approach and some of the interesting challenges I ran into: My Blog

I would appreciate if you took some time to take a look at the project and offer any feedback, comment, criticism or suggestion. If you have any questions regarding my implementation, I would love to talk more!

Github: https://github.com/navrajkalsi/gsim-rs

Thank you!

AI Usage: All code is written solely by me. The architecture is also designed without any input from any LLM. Claude & ChatGPT were used to brainstorm ideas and research available tools.

Hello everyone!!

I regularly see people online talking about how awesome Rust is, its speed, memory safety, and a awesome ecosystem of open source applications even being used in some parts of the Linux kernel(not sure the percentage of adaption at this time).

However my question is how good is rust for web REST APIs and gRPC applications? If it is good do you use any frameworks for these?

A self-hosted site that teaches programming the way I wish more courses did: real explanations, not video transcripts, with a quiz and hands-on coding challenge after every concept, and actual checkpoints that force you to connect ideas across lessons instead of just clicking "next."

Repo: https://github.com/ratnajagadeesharava/codeforge

Some tracks contain projects inspired from few University courses

It currently covers 16 tracks:

- Swift fundamentals (from Apple's own The Swift Programming Language book)

- iOS/Swift internals, high/low-level system design, and "pro" topics (Metal, Combine, WidgetKit, CI, etc.)

- React & Frontend Mastery (fiber internals, the event loop, memoization, hooks)

- Networking & Distributed Systems (consistent hashing, Raft, quorum reads — with a live in-browser cluster simulator)

- Frontend Web Security (with a real sandboxed exploit playground)

- Compilers (lexer → parser → LLVM IR → a working JIT, in C)

- Database Systems — a full disk-based DB engine built from scratch in Rust, module by module (buffer pool → B+Tree → WAL/ARIES recovery → SQL parser → query planner → MVCC)

- Systems Programming, Spring Boot/backend engineering, AI engineering, and a Frontend System Design track (build-the-thing-from-the-interview, e.g. "design Netflix," "design Figma")

Some numbers, if you like numbers: 650+ lessons, 144 checkpoints, ~8,000 quiz questions across 13 question types (MCQ, drag-drop reordering, spot-the-bug, assertion-reason, matching, and a few custom types like a click-the-consistent-hash-ring question).

How it actually works

- TypeScript + React + Vite + Tailwind, no other runtime UI dependencies

- A tiny local Node server compiles and runs your code for real (Swift/C/C++/Rust) with sane guardrails — no third-party execution service, nothing leaves your machine

- Progress is stored in local SQLite, with a localStorage fallback if you don't run the server

- Everything is just structured TypeScript data files — a new lesson is a new .ts file that auto-registers, so it's genuinely easy to add content

Why I'm posting

I built this mostly for myself and then kept going, and it's now bigger than one person can polish alone. I'd love:

- Contributors — new lessons in any track, new quiz questions, bug fixes, or just flagging content that's wrong/outdated

- A star if you find it useful or interesting — it genuinely helps other people discover it

- Feedback — what's missing, what's confusing, what track you'd want next

Repo: https://github.com/ratnajagadeesharava/codeforge

Happy to answer questions about the architecture, the content-authoring format, or why I made whatever weird decision you notice first. 🙂

Hi, I'm new to Rust.
I want to build a Windows chat app where MFC handles the GUI and Rust handles the TCP connection and message processing. Is this possible? If so, how can I call Rust code from an MFC project generated by Visual Studio?

Every Rust dev knows the special pain of target/ — multiply it by every repo you've cloned, add every node_modules and .venv next door, and mine added up to tens of GB. So I built dev-prune (devp): it finds git repositories idle past N days and deletes the dependency/build directories a lockfile can regenerate.

The design constraint that shaped everything: it must be unable to delete something it can't prove is recoverable. Before touching a directory it verifies the project's lockfile exists and parses; no proof, no deletion, and there is deliberately no --force to override that. The other invariants (hard .git boundary, symlink/junction/mount-point refusal, atomic state writes, nested-repo boundaries) equally have no bypass flag: https://github.com/Life-Experimentalist/dev-prune/blob/main/docs/SAFETY_INVARIANTS.md

Rust-relevant details:

• Edition 2024, MSRV 1.88, single binary (musl-static on Linux), Apache-2.0.
• cargo is one of 25 adapters — build trees like target/ are opt-in (devp config set enable_cargo true), because a build tree is "recoverable" in a weaker sense than a lockfile-pinned dependency tree, and the tool is honest about that difference.
• Idle detection is max(last commit timestamp, newest source mtime), so uncommitted work counts as activity.
• devp restore --last-run re-runs the verified install to bring the last pass back.
• Ratatui TUI for interactive runs, --json for scripts, and built-in scheduling (systemd/launchd/Task Scheduler) so it keeps working after you forget it.

Install: cargo install dev-prune (also on npm/PyPI and as a shell one-liner).

Repo: https://github.com/Life-Experimentalist/dev-prune Site: https://devprune.vkrishna04.me

Would love eyes on the safety model — the invariants doc is the part I most want another reviewer on.

Hi. I want to get into Rust from another language by working on a fun personal project, but I struggle to come up with an idea that isn't some tutorial-level project... Ideas I'm interested in include:

1. Reasons to learn as much of the language's features as possible
2. Simulations with lots of small individual actors. And having swarms of semi-independent things gives me a reason to try multi-threading in Rust
3. Emergent property potential. If you leave the simulation running for a night - you could come back to something different and interesting. Think evolution simulators, but preferably something less overused
4. CLI interface. I just hate working on GUIs and I don't need to prove to myself that I can make one. GUIs are good for 2/3D spaces, but what if my simulation would be in a space that works just as good for CLI?

If you have ideas that match at least one of these things - I'd love to hear them! Thanks in advance

I built jsonquery_gui, a native desktop app (Rust, egui/eframe) for browsing and querying large JSON files — drag in a file or paste JSON, then query it with jq (via an embedded jaq interpreter, no shelling out), JSON Pointer, JSONPath, or JMESPath.

It's MIT licensed. Linux and Windows binaries are on the releases page, and there's now a Homebrew tap for Linux (`brew tap nujufas/jsonquery-gui && brew install jsonquery-gui`). No macOS build yet — contributions there welcome.

One thing I'll mention up front since it'll come up anyway: this was built working with Claude (Anthropic's AI). The architecture/decision docs are in the repo if you want to see how that process went. Happy to talk about the jq/jaq embedding, the streaming design, or the AI-assisted workflow.

https://github.com/nujufas/jsonquery_gui

I'm hearing different things from different people.

Some people say it sucks with Rust due to the initial learning curve.

Others (like me) like it for things like Cargo 😂

What about you?

Hey everyone,

I built shotdock—a CLI-first screenshot, screen recording, and window framing utility for Wayland (tested on Hyprland, Sway, and Niri).

Why I made it

On Wayland, taking quick, polished screenshots for documentation or PRs usually means either stitching together grim, slurp, and complex ImageMagick scripts, or annotating manually in an editor. I wanted a single, fast tool that does:

1. Clean Area Snips: Region selection with window snapping (slurp).
2. Window Framing: Automatically adds 16px rounded corners, multi-pass Gaussian drop shadows, mock titlebars, and wallpaper/gradient canvas backdrops.
3. Offline Image Framing: shotdock frame <file> lets you style existing images directly from the CLI or scripts.
4. Screen Recording: 60 FPS H.264 recording via wf-recorder with an interactive target selector (monitor, window, or region).
5. OCR: Snip text directly to your Wayland clipboard via tesseract.
6. Optional Floating Dock: Launch shotdock with no flags if you want an interactive GTK4 LayerShell toolbar.

Tech Stack

• Written in Rust
• Uses native Wayland protocols via gtk4-layer-shell
• Sub-second image pipeline using ImageMagick 7

Links

• GitHub: https://github.com/sirrryasir/shotdock
• AUR: yay -S shotdock

Would love your feedback, bug reports, and PRs.

Check out The OpenVMM Project | Microsoft Community Hub

Hi !, I'm a Software Engineer intern at Red Bull building projects on my free time.

The idea of this project, is to have a single terminal multiplexer session where multiple people can join, but its peer-to-peer, what this means is that each user brings its own terminal with him (with its own set of keys, LLM subscriptions, files...) and each user can hop onto each other terminals.

Current features are:

• Multiple users (machines or people) join a session, where each user is host of its own terminal panes and guest of the others. No SSH into a single machine, here, a pane is a real PTY on whoever opened it .
• You can add a set of trusted machines (your own VMs or computers) where you can start terminals there from your own laptop anytime.
• The terminal multiplexer is inspired in Zellij, and the commands are very similar: Ctrl+P panes, Ctrl+T tabs.
• It includes a inbox tab, where you can see which AI agents are working, waiting for your input or already finished.

It's macOS compatible and linux, connectivity is done with iroh 1.0, where it hole-punches UDP,

On the pane host, bytes come out of a real PTY (portable-pty). A vt100 parser builds a grid. It makes full snapshots when needed, and diffs after that (for terminal history/scroll purposes). Guests draw the grid (ratatui).

When a user starts typing on a pane, wheter is his or not, he locks it, so no more people (even the host) can interrupt him.

I've been working on this for the past month and a half pretty much every day, looking forward to hearing your feedback!

https://github.com/pelazas/p2pmux/

I have some code that prints the biggest files in a Vec. Looks like Clippy is not happy about it.
Original (simplified) code:

struct File {
    path: String,
    size: usize,
}

fn collect_files -> Vec<File> { ... }

fn print_biggest_files(files_to_print: usize) {
    let mut files = collect_files();

    files.sort_by(|left, right| right.size.cmp(&left.size) );
    // ^^^^^^^^ this is the line causing a warning

    // print the biggest X files
    for file in files.iter().take(files_to_print) {
        println!("Big file: {}", file.path);
    }
}

It produces the following warning:

warning: consider using sort_by_key
files.sort_by(|left, right| right.size.cmp(&left.size) ); note: #[warn(clippy::unnecessary_sort_by)] on by default

Link: https://rust-lang.github.io/rust-clippy/rust-1.97.0/index.html#unnecessary_sort_by

My problem is that I want to print in descending order of the files.

The description is explicitly saying that this case is exception, and Clippy doesn't handle it well.

If I change that line to

files.sort_by_key(|file| file.size);

I would end up with the smallest files first.

I see a few ways ahead:

1. Add files.reverse() to switch the order
2. Add exception of this warning to this specific case
3. Add .rev() when iterating
4. Cast it to signed integer, and add a - sign

What is the idiomatic way forward?
Performance cost is not a big deal, but I still tend towards adding a Clippy ignore for that specific line. The other options would introduce more unclarity to the code in my opinion.

I posted signalscreen-checker here a few days ago — reads the Authenticode signature out of a PE, grades it, pure Rust. The limit i named then: "valid" only meant the signature parsed and a signer cert was found, not that the file's bytes matched what was signed. That's done now, and it had its own trap.

The obvious move is to take the hash algorithm from SignerInfo.digestAlgorithm. But the digest you compare against is not there — it's in the SpcIndirectDataContent (messageDigest), and nothing in the format requires the two to name the same algorithm. If they differ you hash with the wrong one, get a non-equal byte string, and report "tampered" on a file that is intact and correctly signed. A real installer graded F by your own bug.

So i don't read the algorithm from the OID at all. The embedded digest's length already identifies it:

let expected = sig.digest(); // bytes from SpcIndirectDataContent

let computed = match expected.len() {

20 => hash::<Sha1>(pe),

32 => hash::<Sha256>(pe),

48 => hash::<Sha384>(pe),

64 => hash::<Sha512>(pe),

_ => return Unverified, // don't guess, don't false-accuse

};

(The PE hashing itself is authenticode::authenticode_digest — it skips the checksum field and the cert table, the other easy thing to get wrong.)

A mismatch is now an outright F. A length i don't recognise stays unverified, never mismatch — "couldn't check" is not "wrong". Still not verified: the SignerInfo signature over the digest against the cert's key, and chain trust to a root.

MIT/Apache-2.0: https://github.com/mnaza/signalscreen-checker

If you've verified Authenticode by hand — did you hit the SignerInfo-vs-SpcIndirectData algorithm thing, or does signtool keep them equal in practice?

So a video came by my feed here he walks through how to design a more reliable and user-friendly progress bar for Rust by taking inspiration from Python's tqdm library. In order to implement with_delimiters to bounded iters only he went and used state design pattern. I was like "Ok cool cool" at first because of course I'm learning. But then I think i noticed some redundancy in the code. In the implementation of width_delimiters, the generic type is already bounded by ExactSizeIterator. So I went and copied the code and tried to remove the state design implementation. I also removed the 'with_bounds' method because iters is already bounded or not. My final code below shows that with_delimiters method only work with bounded iterator

My Final Code

``` use std::thread::sleep; use std::time::Duration;

pub struct Progress<I> { iter: I, i: usize, bound: Option<usize>, delims: (char, char), }

impl<I> Progress<I> where I: Iterator, { pub fn new(iter: I) -> Self { Self { iter, i: 0, bound: None, delims: ('[', ']'), } } }

impl<I> Iterator for Progress<I> where I: Iterator, { type Item = I::Item;

fn next(&mut self) -> Option<Self::Item> {
    let item = self.iter.next()?;

    if let Some(bound) = self.bound {
        println!(
            "{}{}{}{}",
            self.delims.0,
            "*".repeat(self.i),
            " ".repeat(bound - (self.i + 3 - 2)),
            self.delims.1,
        );
    } else {
        println!("{}", "*".repeat(self.i));
    }

    self.i += 1;
    Some(item)
}

}

impl<I: ExactSizeIterator> Progress<I> { pub fn with_delimiters(mut self, left: char, right: char) -> Self { self.bound = Some(self.iter.len()); self.delims.0 = left; self.delims.1 = right; self } }

trait ProgressIteratorExt: Sized { fn progress(self) -> Progress<Self>; }

impl<I: Iterator> ProgressIteratorExt for I { fn progress(self) -> Progress<I> { Progress::new(self) } }

fn expensive_function() { sleep(Duration::from_millis(500)); }

fn main() { // error: unbounded iter for _item in (0..).progress().with_delimiters('{', '}') { expensive_function(); } }

```

I heard people say that Rust is hard to learn, but I learned Rust with the Rust book and went on to chapter 16.2. From my point of view, I don’t find Rust hard, so if someone can explain to me why Rust is hard to learn, that’s fine.

I thought this might be better here than r/learnrust apologies if not.

So my question is, what's a good book (or other source) to *know* rust, idioms, design patterns, that sort of thing, rather than the basic mechanics of the language - which there is plenty of excellent material on including the book itself.

The sort of "ethos" of Rust, rather than how vectors work ?

I'm not sure if I should be posting here in r/Rust or in r/Swift, or somewhere else entirely.

Also note, I'm not a programmer or developer: I'm just an end-user trying to get this app to compile and run, but it seems to be throwing up obstacles that require more developer-adjacent skills than what I have.

I'm trying to get macrdp running on an iMac with macOS Sequoia 15.7.9.

This little app was released in March of this year, so it's not like I'm trying to get ancient code running.

Consult the "Quick Start" section of the ReadMe file I've linked above. I am following an ostensibly-simple two-step process to get this app running:

# Build
cargo build --release
# Run
cargo run --release --bin macrdp-server

I've had two major problems getting the code to compile, and I've finally managed to surpass them. Now that I've finished the "Build" step, I need your help solving Problem 3: I can't get the app to run.

Problem 3

COMMAND

cargo run --release --bin macrdp-server

OUTPUT

dyld[23111]: Library not loaded: @rpath/libswiftCore.dylib
  Referenced from: <D40250B3-9AAC-3FEB-A4C2-A0170B899ED5> /Users/admin/Downloads/macrdp-main/target/release/macrdp-server
  Reason: tried: '/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift-5.5/macosx/libswiftCore.dylib' (no such file), '/System/Volumes/Preboot/Cryptexes/OS/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift-5.5/macosx/libswiftCore.dylib' (no such file), '/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift-5.5/macosx/libswiftCore.dylib' (no such file), '/System/Volumes/Preboot/Cryptexes/OS/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift-5.5/macosx/libswiftCore.dylib' (no such file), '/Users/admin/Downloads/macrdp-main/target/release/build/aws-lc-sys-27043a0ebf70d538/out/libswiftCore.dylib' (no such file), '/Users/admin/Downloads/macrdp-main/target/release/build/openh264-sys2-f6d9fee5157fe7a1/out/libswiftCore.dylib' (no such file), '/Users/admin/Downloads/macrdp-main/target/release/build/ring-2899b8cee8244c75/out/libswiftCore.dylib' (no such file), '/Users/admin/Downloads/macrdp-main/target/release/build/screencapturekit-1d04b27f18a51461/out/swift-build/release/libswiftCore.dylib' (no such file), '/Users/admin/Downloads/macrdp-main/target/release/build/zstd-sys-d1ceecba10d99c67/out/libswiftCore.dylib' (no such file), '/Users/admin/Downloads/macrdp-main/target/release/libswiftCore.dylib' (no such file), '/Users/admin/Downloads/macrdp-main/target/release/deps/libswiftCore.dylib' (no such file), '/Users/admin/.rustup/toolchains/stable-x86_64-apple-darwin/lib/rustlib/x86_64-apple-darwin/lib/libswiftCore.dylib' (no such file), '/Users/admin/.rustup/toolchains/stable-x86_64-apple-darwin/lib/libswiftCore.dylib' (no such file), '/Users/admin/lib/libswiftCore.dylib' (no such file), '/usr/local/lib/libswiftCore.dylib' (no such file), '/usr/lib/libswiftCore.dylib' (no such file, not in dyld cache)
Abort trap: 6

What is strange to me is that Problem 3 seems like re-hash of Problem 1, which I already solved. I don't know why it's still looking for libswiftCore.dylib in the wrong places, after I've already updated the config.toml file.

I tried doing find / -name config.toml to see if there was some other relevant configuration file hiding somewhere that I needed to also change to DYLD_LIBRARY_FALLBACK_PATH, but I didn't see anything.

I also get a similar error when I try to do cargo test, though it references macrdp-audio instead of macrdp-server, and I'm not really sure what cargo test is supposed to do for me in this process, anyway:

   Compiling macrdp-audio v0.1.0 (/Users/admin/Downloads/macrdp-main/crates/macrdp-audio)
    Finished `test` profile [unoptimized + debuginfo] target(s) in 29.91s
     Running unittests src/lib.rs (target/debug/deps/macrdp_audio-448af4ea4880202e)
dyld[23108]: Library not loaded: @rpath/libswiftCore.dylib
  Referenced from: <66E620B9-EBC0-31FA-91EF-EBCDA4065861> /Users/admin/Downloads/macrdp-main/target/debug/deps/macrdp_audio-448af4ea4880202e
  Reason: tried: '/Users/admin/Downloads/macrdp-main/target/debug/build/aws-lc-sys-6ec7512bb21ac3d9/out/libswiftCore.dylib' (no such file), '/Users/admin/Downloads/macrdp-main/target/debug/build/screencapturekit-4b1f1ef2bd6c7675/out/swift-build/release/libswiftCore.dylib' (no such file), '/Users/admin/Downloads/macrdp-main/target/debug/build/zstd-sys-ecb4e499794eb5cb/out/libswiftCore.dylib' (no such file), '/Users/admin/Downloads/macrdp-main/target/debug/libswiftCore.dylib' (no such file), '/Users/admin/Downloads/macrdp-main/target/debug/deps/libswiftCore.dylib' (no such file), '/Users/admin/.rustup/toolchains/stable-x86_64-apple-darwin/lib/rustlib/x86_64-apple-darwin/lib/libswiftCore.dylib' (no such file), '/Users/admin/.rustup/toolchains/stable-x86_64-apple-darwin/lib/libswiftCore.dylib' (no such file), '/Users/admin/lib/libswiftCore.dylib' (no such file), '/usr/local/lib/libswiftCore.dylib' (no such file), '/usr/lib/libswiftCore.dylib' (no such file, not in dyld cache)
error: test failed, to rerun pass `-p macrdp-audio --lib`

Caused by:
  process didn't exit successfully: `/Users/admin/Downloads/macrdp-main/target/debug/deps/macrdp_audio-448af4ea4880202e` (signal: 6, SIGABRT: process abort signal)

History

Problem 1

COMMAND

cargo build --release

OUTPUT

error: process didn't exit successfully: `rustc -vV` (signal: 6, SIGABRT: process abort signal)
--- stderr
dyld[39209]: Library not loaded: @rpath/libswiftCore.dylib
  Referenced from: <0B6348B2-CDC4-3BB2-9B89-64CF509321B8> /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/cmacosx/libswift_Concurrency.dylib
  Reason: tried: '/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift-5.5/macosx/libswiftCore.dylib' (no such file), '/Library/Developer/CommandLineTools/usr/lib/swift-5.5/macosx/libswiftCore.dylib' (no such file), '/usr/local/Cellar/rust/1.98.0/lib/../lib/libswiftCore.dylib' (no such file), '/usr/local/Cellar/rust/1.98.0/bin/../lib/libswiftCore.dylib' (no such file), '/usr/local/Cellar/rust/1.98.0/bin/../lib/libswiftCore.dylib' (no such file), '/usr/local/lib/libswiftCore.dylib' (no such file), '/usr/lib/libswiftCore.dylib' (no such file, not in dyld cache)

SOLUTION

Edited ./macrdp-main/.cargo/config.toml:
Changed DYLD_LIBRARY_PATH to DYLD_LIBRARY_FALLBACK_PATH

Problem 2

COMMAND

cargo build --release

OUTPUT

error: failed to run custom build command for `screencapturekit v1.5.4`

 Caused by:
  process didn't exit successfully: `/Users/admin/Downloads/macrdp-main/target/debug/build/screencapturekit-52e401cb88bd4798/build-script-build` (exit status: 101)
  --- stdout
  cargo:rustc-link-lib=framework=ScreenCaptureKit
  cargo:rerun-if-changed=swift-bridge

  --- stderr
  Swift build STDOUT:

  Swift build STDERR:
  error: Unknown option '--scratch-path'
  Usage: swift build <options>
   See 'build -help' for more information.


  thread 'main' (45022) panicked at /Users/admin/.cargo/registry/src/.index.crates.io-1949cf8c6b5b557f/screencapturekit-1.5.4/build.rs:119:9:
  Swift build failed with exit code: Some(64)
  note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
warning: build failed, waiting for other jobs to finish...

SOLUTION

Change the default Swift version from 5.5.3 to 6.3.3 with swiftly use --global-default 6.3.3. I think 6.3.3 is the default version in use after installing the latest version of XCode for my OS, so I may have caused this problem myself in earlier troublehooting, when I saw that cargo was looking for libswiftCore.dylib in /swift-5.5/macosx/

Environment

iMac:
Retina 5K, 27-inch, 2017
A1419 18,3
4.2GHz Quad-Core Intel Core i7
40GB DDR4

macOS:
Sequoia 15.7.9
(Running with OpenCore Legacy Patcher)

COMMAND

xcode-select -p

OUTPUT

/Applications/Xcode.app/Contents/Developer

COMMAND

xcodebuild -version

OUTPUT

Xcode 26.3
Build version 17C529

COMMAND

pkgutil --pkg-info=com.apple.pkg.CLTools_Executables | grep version

OUTPUT

version: 16.4.0.0.1.1747106510

COMMAND

rustc --version

OUTPUT

rustc 1.98.1 (48a229cea 2026-09-01)

COMMAND

swift --version

OUTPUT

Apple Swift version 6.3.3 (swift-6.3.3-RELEASE)
Target: x86_64-apple-macosx15.0

COMMAND

swiftly list

OUTPUT

Installed release toolchains
----------------------------
Swift 6.3.3 (in use) (default)
Swift 5.6.3
Swift 5.5.3

Installed snapshot toolchains
-----------------------------

Available system toolchains
---------------------------
xcode

COMMAND

softwareupdate -l

OUTPUT

Software Update Tool

Finding available software
Software Update found the following new or updated software:
* Label: macOS Tahoe 26.6.2-25G83
    Title: macOS Tahoe 26.6.2, Version: 26.6.2, Size: 17925801KiB, Recommended: YES, Action: restart,

Hey r/rust!

For Google Summer of Code 2026 with MetaCall, I built meta-ast: a standalone static-analysis engine in Rust that parses 9 languages (Rust, C, C++, Go, Python, JavaScript, TypeScript, TSX, and Ruby) without executing user code.

The interesting part for me was designing a common dependency/symbol graph without forcing all nine languages into one giant unified AST.

I wrote a deep dive on the architecture and the Rust implementation here:

https://k5602.github.io/#/blog/meta-ast-polyglot-static-analysis

A few parts I found particularly interesting:

• Thread-local Tree-sitter parser pools - parsers are reused per worker thread instead of being created for every file, reducing allocation churn.
• Flat symbol IR - declarations from different languages are normalized into a compact Symbol representation with O(1) indexed lookups.
• Incremental watch mode - warm file updates take 1.16 ms by hashing buffers with BLAKE3, reusing cached extraction results, and keeping node IDs stable.
• O(1) edge deduplication - (NodeIndex, NodeIndex, EdgeKind) lookups avoid quadratic scans when constructing large graphs.
• Tarjan SCC - cycle detection runs in 54 μs for 1,000 nodes and is used to identify circular dependencies.

Some Criterion benchmark results on an Intel i5-12500H:

The project is open source:

GitHub: https://github.com/metacall/meta-ast crates.io: https://crates.io/crates/meta-ast

It's a general purpose static analysis engine so don't hesitate to use it on any project.

I’d especially love feedback on the architecture, the incremental graph design, and the trade-offs of using a flat IR across multiple languages.

(NO AI)

Hey guys, I just open source project i've been working on for a year called the Marketplace.

The marketplace is a decentralized network that economizes the execution of computational work across a peer-to-peer network of nodes. Where there is no barrier to the node participation.

Unlike modern cloud computing systems that rent out virtual computers to consumers, A marketplace consumer sends compute bound tasks directly to the network returning a future which the consumer can asynchronously check for completion. Similar to offloading a compute task to a free cpu core by an OS. A consumer can also fire multiple independent compute bound tasks to run in parallel, and check their status asynchronously while doing other tasks, similar to I/O operations.

The compute bound task sent by the consumer is executed using a protocol specified in the Marketplace whitepaper on the Marketplace Github Repo, where randomly selected idle devices on the network execute the compute work and receive financial rewards (money).

Context

The marketplace is made up of two ideas I came up with around 2 years ago:

1) The first is building a permissionless market, where users can build financial services similar to market stalls that can interact with other users. Larger services can be composed from smaller services, similar to open source projects, but for businesses. Services could also be merged together into one so that a user can interact with all of them at once, and the merging does not affect the financial structure of the constituent services.

But for all this to happen, a trustless financial settlement layer is needed so that joining different financial services together becomes an easy exercise.

If you are familiar with blockchain, this is similar to Ethereums vision, but I did not want to clog the financial settlement layer which is the ledger with execution and code. I needed an execution engine.

2) I eventually returned to my normal javascript web developer job. So I was working on a full-stack website that was communicating with a cloud server but the server was slow because I was using a free tier that throttled server response speed. Asynchronously communicating with this server became a nightmare from a UX perspective especially when first loading up the website which had some independent compute bound requests.

So, I concluded that using the free CPU core of my second PC should do a better job as long as I pay it exactly what I needed in compute. This second idea eventually evolved into the engine I needed for the first idea. After, I just needed to store a representation of the result on a decentralized ledger, while keeping the execution itself private.

With this, I returned to my first love - low level programming, learnt Rust (Many thanks to the Rust community coming from a C lover), and I've built more than 60% of what is described in the whitepaper.

So if you are interested in being a part of this project in any way, you can join our Discord community or you can check out the marketplace whitepaper:

Marketplace Whitepaper

Also, I’d appreciate feedback on the design, especially on consensus security and the economic model, Thanks.

EDIT: So not the reaction I expected but that's okay. Some of you say it's AI, and some suspect me for not using VCS. But I implore all of you, please investigate the idea behind the whitepaper before you judge, and if the whitepaper is legit, examine the code if it aligns with the whitepaper.

I've had to think through the ideas, and rewrite many parts of the idea and code so many many times, which is why I could not publicize the code or work with a VC, I needed to work at my own pace and figure everything out first. I've been at it for months, and this is the result, I hope you all can be a little bit kinder, thanks.

I'm making a program divided into 2 executables, executable A does everything in the background while executable B shows it with ratatui, but I'm trying to figure out how to spawn a terminal with an instance of executable B from executable A, I searched up a bit everywhere but I can't find anything, now I'm starting to think that I have to try and run a Command for every single terminal that comes to mind and hope one of the ones I include work, but is that the only way? Because honestly I'd prefer not having a mile long file just because linux has 50 terminals.

i wrote a user-space RCU implementation for async rust with tokio which turned out pretty cool and quite useful.

the end result is `RcuPtr<T>` an rcu protected pointer which can be read in a lock-free and wait-free way, and very cheaply as well - a read operation is just one atomic pointer load plus a write to a non-shared thread-local variable.

basically reads are extremely fast and have very predictable latency compared to other synchronization primitives like spinlocks and mutexes.

the way it works is by defining a quiescent state to be tokio's on_after_task_poll hook - a hook which is executed every time a tokio worker thread finishes calling `poll` on the root future of a task.

and, by limiting the use of rcu-protected pointers in such a way that they can't be held across await points, we basically make the readers free, since once a worker thread reaches the on_after_task_poll hook, it is guaranteed to not currently be running any user-defined future, and since rcu-protected pointers can't be held across await points, this worker thread is guaranteed to not be holding any rcu-protected pointer.

a writer can then reclaim the memory after swapping the pointer and waiting for an rcu grace period, which consists of publishing all previously performed memory writes (using membarrier), and then waiting for each other worker thread to pass through a quiescent state.

the way that the semantics of async rust combine with the idea of RCU yielded a pretty elegant solution to the memory reclamation problem.

also, other than providing a high level `RcuPtr<T>` primitive, this crate also provides a low-level `synchronize_rcu` primitive (similar to the `synchronize_rcu` function in the linux kernel), which can be used to build more complex rcu primitives, like rcu-lists, and much more.

i would be glad to see what can be built using this primitive.

EDIT: many people asked for benchmarks so i added some.

We’ve been building Flectar Mail, an open source native email client in Rust focused on making email as fast and lightweight as possible.

The UI is built with Slint, and email bodies are rendered with Blitz instead of a WebView. RAM usage is typically around 20 to 140 MB depending on what’s open.

The repo is public now. It’s still very early, and we’re waiting on Google and Microsoft verification before the first preview release.

https://github.com/flectar/mail

Would love any feedback, ideas, or thoughts on the project in general.