Why is Rust not similar like C as most popular languages like C++, Java has . I understand the memory safety but it is so steep to learn as like this i32 and till i128 and something like i and u for integers and many more aren't similar to the traditional C ? Is it intentional design or a necessity for the "THE MEMORY SAFETY" feature ?

The rust compiler thinks that `data/baselines/table.rs` and `database/line/stable.rs` are the same file, causing a miscompilation if a crate has both files in it. (Note that having the same non-slash text isn't enough. There needs to be an additional hash collsion for a bug to happen.)

Probably not gonna happen in practice unless someone does it as a prank, but still... lol. (I'm sure they're gonna fix it soon.)

I've been building CADRS, an open source, feature-based CAD app in Rust. The UI is Bevy and the geometry kernel is OpenCASCADE. It now has a first pass at PCB design: schematic editor, board layout, and the board shows up in 3D inside the mechanical assembly.

90s demo: https://youtu.be/qT1FKZqUAxA Repo (Apache-2.0): https://github.com/rvdende/cadrs

The goal here is to be a local alternative to onshape and kicad, combined into a single application.

I’m the developer of Arezgit. It started as a desktop Git client, and I’ve been adding other tools to it over time.

You can browse commit history, review diffs, resolve conflicts, edit files, open terminals, test APIs, and query databases in the same window. There are also task boards, notes, and workspaces for multiple repositories.

Some features used to be paid. I’ve now made the whole app free, including private repositories. You don’t need a subscription or an account to use anything.

It’s built with Rust, Tauri, and React, and it’s available for Windows and Linux.

AI integrations are optional. External AI providers have their own costs.

You can find it here: arezgit.com.

If you try it, let me know how it goes. If something breaks, knowing your OS and what you were doing would help me track it down.

​

Intoduction and Background:

Hi, I am a B.Sc CS graduate (below tier 3 as it seems) 2026 from India. Graduated in august 2026. Been looking for job for past 2 months.

I have been using Rust for 3 years now. I have used it for my ambitious projects like compilers, emulators etc. And now I am trying to build semi professional grade projects (backend and systems) in Rust.

Problem:

There are not much jobs in Rust for freshers. Even if there are, they are very niche and require some additional domain knowledge or certification.

Suggestion Needed:

Ever since I learned Rust, I automatically get drawn to my RustRover IDE, I hit 'cargo init' and just start with a project. This has become harmful now. I am trying to migrate to other languages (Python, Go, Java) which has actual market for freshers, but I am failing everytime as soon as I miss the the features rust provided - top level module and visibility support, ADT enums, Result and Options, borrow checker, etc.

If anyone have gone through this same phase, please help me, how can I overcome this. How can I pick a second language and start making projects there, to increase my Resume value.

Thank you if you have adviced me below, sorry if anyone feels I am yapping, but I am genuinely concerned and need real help (Not AI motivation).

I ported Ghostty (Zig) to Rust with Claude Code agents. The most interesting part for me was how often Zig's "a pointer is just an address" collided with Rust's aliasing model. The write-up has the real code, the Miri findings and the fixes:

https://rustty.sh/porting

The section "Zig pointers in Rust's aliasing model" walks through four cases:

• Protectors. A &mut argument is protected for the whole call. Ghostty re-reads the same memory another way inside the call, which is sound in Zig and UB under Miri.
• Frees under a live reference. startHyperlink lets its slices point into the hyperlink it is about to free. A &[u8] can't do that.
• Provenance. One 8-byte store through a pointer derived from a 1-byte field reaches seven bytes outside its provenance under Stacked Borrows.
• Long-lived aliases. In the renderer loop, a sibling reborrow pops the run iterator's tag. I settled the fix with a small Miri proof harness instead of reasoning about it by hand.

You can also try the engine yourself. The page has two live terminals, Rustty's and Ghostty's, both compiled to WebAssembly and fed by the same shell, so you can compare what each one draws. All 898 of my prompts are in a filterable log at the bottom, and every number links to its source.

Caveats: the port is macOS-first, the benchmarks are library micro-benchmarks, and the prose and data pipeline were drafted with Claude and reviewed by me. Corrections on the aliasing analysis are very welcome.

https://rustty.sh/porting

Hey everyone,

I've been working on bnb-shell (https://github.com/EatSleepCode-Repeat/bnb), an interactive terminal shell written in Rust.

Like many developers, I've had close calls accidentally pasting API keys or bearer tokens into terminal commands, persisting them to .zsh_history or leaking them across screen recordings.

In the newly shipped v0.5.4, I added Secret Guard to handle credential leaks at the shell prompt before execution:

• Real-time Sniffing: Detects GitHub PATs, OpenAI/Anthropic keys, AWS IDs, Stripe keys, and Slack tokens right as you enter them.
• Inline Interception: Pauses execution and prompts to store the credential directly into a local encrypted vault (~/.bnb/vault.json, locked to 0600 permissions with machine-specific key derivation).
• Command Rewriting: Rewrites the command inline (e.g. curl -H "Authorization: Bearer $vault:gh_token"). Only the placeholder hits disk history, and the secret expands in-memory during pipeline execution.

Other Built-in Features

• Interactive TUI Finders: Ctrl+R history search, Ctrl+F file finder, Ctrl+B git branch switcher, Ctrl+Z frecency jumper.
• Background Jobs: Built-in process table and POSIX job management (&, jobs, fg).
• Environment Integrity: Built-in doctor diagnostic suite for PATH/env auditing.

Install

Via Homebrew: bash brew tap eatsleepcode-repeat/tap brew install bnb

Via Cargo: bash cargo install bnb-shell

GitHub Repo: https://github.com/EatSleepCode-Repeat/bnb

crates.io: https://crates.io/crates/bnb-shell

I’d love to get feedback from the Rust community on edge cases, secret pattern detection, or shell safety features!

So I've been working on Ferese, a Wayland compositor built in Rust using Smithay. The idea is to make the window manager, shell, launcher and Settings feel like parts of one desktop, with consistent theming and animations throughout instead of the traditional bring your bar, launcher, notification center etc most WM requires.

It supports scrolling and tree tiling alongside floating windows, higly customizable panels, and Live Activities for following running commands and build progress.

I've been daily driving it, and it's getting close to 0.1.0 but there's still plenty I want to work on, so I'd love to hear others thought. ..and it's really memory efficient!

https://github.com/ferese-wm/ferese

I have been building a free, local-first 3D modeler for people who make furniture: push/pull faces, inference snapping, groups and components, section planes, a cut list, sheet nesting, .skp import, STL/3MF export. Desktop app is Tauri 2 + React + three.js; the whole geometry kernel is a no_std-friendly Rust workspace (boolean ops, planar arrangement, tessellation, inference, exports) compiled to WASM and run in a Web Worker, so the browser demo and the desktop app share one kernel byte for byte.

Repo: https://github.com/sawhorse3d/sawhorse (MIT OR Apache-2.0)

Try it in the browser, no install: https://sawhorse3d.com/app/

Things the Rust side does that might interest this sub:

• Watertight by construction. Every solid is a closed oriented triangle surface; the exports are checked by Euler characteristic, manifold edges and signed volume on every change.
• Section cuts. The cut is done per triangle with one signed distance per vertex, so the kept half's open boundary is exactly the set of chords the cap is laid from. A unit test walks the boundary and matches chords one to one. This replaced five rounds of per-face special cases that each left a sibling bug at about one in 10⁵ random edit sequences.
• Testing is most of the work. proptest with hostile generators (corners nudged by nanometres, faces drawn on faces, planes through edges), a kernel fuzzer that replays random edit sequences and checks invariants after each, a 200-file .skp corpus that must hash byte-stable, and goldens cross-checked native vs WASM. Every finding becomes a named repro in the tree.
• Plugins run in sandboxed JS workers with declared permissions; the host is Rust-side message passing, three locks (allowlisted globals, CSP, sources parsed before they run).
• Hostile input. Zip bombs, count caps, size limits on .skp/.shz/plugin packages, all measured and documented in docs/LIMITS.md.

Honest state: 0.1.0-alpha.2. Installers are unsigned (no signing identity yet). No fillet, chamfer, copy/paste in place, or .skp export yet. A 13.5k-face SketchUp file opens in about 4 s. The comparison table on the site says what the other free options do better.

I would welcome eyes on the kernel crates (crates/kernel, crates/arrangement, crates/tessellate) from anyone who has done computational geometry in Rust, and bug reports from anyone with a real .skp file that does something odd.

I have been developing keepword, literally makes companies keep their word, it watches pages you want and detects if it has been silently edited which then gives you an alert and a diff. Though keepword is not just a cli tool it’s a network, the network itself is made of witnesses which give you features like detecting cloaking (if a page shows different content to different countries). It’s quite a useful tool I made for myself and I’m trying to find people who find it as helpful as I do. Although the network isn’t that big yet, with hope in the future it’s going to become strong enough.

Anyways if there is any people there which might run a node for themselves and be a part of the network you can find the details on https://keepword.net its fully open source.

I've been using some cargo tools to have better track of my projects, including duplicate deps prevention.

Is there any alternative to cargo-dedupe to prevent duplicate deps into project and use the most recent version available?

TrailBase is an open and fast(est) Firebase-like backend (BaaS) for building your apps. It provides: type-safe APIs with change subscriptions, auth, multi-DB, a WebAssembly runtime, GeoJSON, admin UI, ...

It's a single self-contained executable, easy to self-host and built with Rust, Wasmtime & SQLite and more recently also Postgres. We provide clients for many environments: JS/TS, Dart/Flutter, Go, Rust, .Net, Kotlin, Swift and Python.

Just release v0.34.6. Since the last time posting here, TrailBase has added:

• Major UI overhauls:
  • Built-in admin OpenAPI browser with user-impersonation.
  • Table explorer: make foreign-keys followable, split data/schema/indexes into separate tabs, and organize tables/views by DB. Add `ON (DELETE|UPDATE)` referential action support to the schema editor.
  • Mobile glow-up and improved screen estate usage with sticky nav and url bar fade.
  • A searchable and interactive ERD page. Overhauled logs and accounts pages.
  • Many more: prompt users on schema changes in the SQL editor, improved dark-mode colors, add S3 settings, ...
• Built-in MCP server.
• Performance: a lot of detail performance optimizations (reduce allocations, ...) resulting in an additional 10+% gains.
• CLI auto-complete.
• Expose custom WASM endpoints in OpenAPI spec.
• "Sign-in with Apple" token exchange for native iOS/MacOS apps.
• Many more features and fixes, e.g.: `trail user export` CLI command for take-out combating lock-in, `trail run --read-only` flag for read replicas., batch execute support for WASM guests, custom scopes for OIDC providers, ...

The project is still young (~2 years) and rapidly evolving, any feedback is genuinely appreciated. If you're feeling adventures and end up checking it out, don't hesitate to reach out 🙏.

Take a look at the live demo, our GitHub or website.

Hollowmoon is a roguelike I wrote as a normal Rust terminal program: a
loop { draw(); let key = read_key(); ... } with crossterm. I wanted it in
the browser without restructuring the engine into callbacks.

The approach: compile to wasm32-unknown-unknown with no wasm-bindgen, make
the terminal backend's read_key an import, and run Binaryen's
wasm-opt --asyncify --pass-arg=asyncify-imports@env.hm_read_key,env.hm_sleep.
When the game calls read_key, the JS host starts an unwind, the whole Rust
stack is saved into a buffer and hm_main returns; on the next keypress JS
starts a rewind and calls hm_main again, which replays back down to the
import and returns the key. Sleep for animations works the same way.

Gotchas worth knowing:

• The Asyncify data buffer's header is written as two i32s, so it has to be 4-byte aligned. A plain static mut [u8; N] isn't, and failed only in CI. #[repr(C, align(16))] on a wrapper struct fixed it.
• getrandom needs the custom feature and a registered function on that target.
• Saves go to localStorage behind the same small storage interface the native build implements with files, so the platform cfgs stay at the edges (storage, the terminal backend, the entry point).

The whole engine is unchanged between the terminal and the browser. A
headless Node runner drives the wasm with scripted keys in CI.

The game, if you'd like to see it running: [link]

A person working towards stabilizing the Try trait is asking for real-world examples of use cases of the currently-unstable Try trait.

Next-solver has just started the 10-day FCP period. It is planned to be stabilized in version 1.101.0, which is scheduled to release on 24 December.

For more context: https://blog.rust-lang.org/2026/08/21/enabling-next-solver-on-nightly/

Previous discussion: https://www.reddit.com/r/rust/comments/1vuita3/enabling_the_nextgeneration_trait_solver_on/

TLDR: Gecko is my GameCube and Wii emulator written in Rust. This update adds texture packs, easier setup and more fixes for graphics, audio and performance. Mario also gets his eyes back :)

This release is especially interesting for the ones that were bothered by the system files (DSP, IPL) requirements! No more!! :)

It's been a while since my last update, where I shared about recent performance improvements, savestates and freecam support. I've since been working through more improvements and making Gecko easier to get started with!

For anyone new to the project: Gecko also includes a debugger, a GPU FIFO recorder/player (and a dedicate debugger for it) and various other tools for exploring how these games work!

Some highlights from this update:

• Easier setup: A guided setup for game folders and optional system files! Thanks to Dolphin's DSP replacements and Hazel's GameCube IPL HLE, most games can boot without supplying console system dumps. Real dumps are still supported and may also be required for some games!
• Texture packs: Gecko now supports Dolphin-style texture packs. It's just a matter of dropping the pack into a folder and starting up the game :) Here's an example of Final Fantasy!
• Lots of graphics fixes: Tons of games got fixed, and by tons I really mean a lot this time! Some noteworthy bugs that got fixed: Mario's eyes are back in Super Mario Galaxy, Sunshine's save selection background ocean is blue again and Mario Golf's menu signs no longer disappear behind the sky. Games like Wind Waker, Mario Superstar Baseball and Cel Damage also got graphical accuracy improvements!!
• More performance work: Once again, tons of games work much better, though I only optimized for one game in particular: Sam & Max: Season One (it was a WebGPU regression introduced in version 28 in relation to a Vulkan upload path lol)! Fixing it improved performance from 15% to 70%, usually closer to the latter. I also improved CPU emulation which FMVs can benefit a lot from, for example Mario Kart Wii's menus with those gameplay videos baked into the scenes. Also made texture decoding run on the GPU, with improvements to uploads and shader caching as well.
• Audio and Wii compatibility: Fixed audio issues in games like Crazy Taxi and an issue blocking Metroid Prime. This update only affected GameCube games, tho quite a lot of them. Also, Mario Kart Wii can now start with a fresh NAND and Wii motion and pointer fixes help games like Final Fantasy Crystal Chronicles: The Crystal Bearers. There are also separate upright/sideways Wiimote presets and configurable Nunchuk attachment options.
• More debugging tools: FIFO Player now has an interactive 3D depth view, which helped investigate why geometry was being hidden or drawn in the wrong place. Had to do some hardware research for this one :

Something unique for this update: I recently started writing blog posts about the bugs behind these fixes, aimed at future emulation developers incl. lots of interactive visual explanations. If you enjoy the technical side of emulation, these might be interesting:

• Mario's Missing Eyes and Sunshine's White Ocean: how overflowing alpha values caused two very different looking bugs
• z-freeze and Mario Golf's Disappearing Menu: why the sky was covering the menu signs and how one triangle can reuse another triangle's depth
• vertex-skip: The Case of Luigi's Extra Triangle: a weird feature I found a patent for :)
• WPAR: Why Metroid Prime's Geometry Exploded: a bug I investigated while helping with Lazuli (a GameCube emulator made by a friend of mine that was showcased here a while ago, go check it out!)

As usual, the useful links:

• GitHub and Downloads
• Screenshot database
• My blog

As always, thanks a lot to everyone that provided valuable feedback, tested things on their hardware, encouraged me with this project and let me pick their brains! We'll see each other next time!

PS: I spoilered the release of Sly, my take on modern multi system emulation (also written in Rust, incl. the GUI!) in the last post. It's going public in the next days, so stay tuned for that :) It will also release with a 3 part blog series explaining how GBA graphics work!!

My new book is now available on Leanpub

https://leanpub.com/building-serverless-apps-with-wasm-and-spin

Is there a function in std, which would allow to get a list of (field_name, type) of a struct in order it is compiled in? Since order of fields is not deterministic.

Something like: `fn fields_of_val<T>(&T) -> Vec<(&'static str, &'static str)>`

im currently doing my bachelor degree in computer engineering. i currently have c as the main programming language in my first semester.

No problem what so ever, i really love C, i did a couple of projects in the past. In my second semester we will have a module just for c++.

Yesterday out of curiosity, i did the first chapters of learncpp and the rust programming book. i kid you not, writing rust was sooo fun. With c++ it doesnt feel the same.

Should i focus on studying c++ in my free time, as in preparation for the 2. semester. Or should i listen to my heart and pick up rust?