Huginn Daily

Saturday, April 18, 2026

ffbf3889-066f-49ee-aed3-7dcf7244435d

Weather

Summary	⛅️ Light rain until evening.
Temperature Range	16°C to 20°C (61°F to 67°F)
Feels Like	Low: 59°F | High: 72°F
Humidity	85%
Wind	14 km/h (9 mph), Direction: 124°
Precipitation	Probability: 100%, Type: rain
Sunrise / Sunset	🌅 06:12 AM / 🌇 07:22 PM
Moon Phase	Waxing Crescent (4%)
Cloud Cover	68%
Pressure	1003.6 hPa
Dew Point	59.46°F
Visibility	5.98 miles

XKCD

Other

• Self-Host Weekly (17 April 2026)
  Become a paid subscriber to access the newsletter’s full-text RSS feed or continue reading on selfh.st.

Reddit

r/rust

• Farben, my terminal coloring library using markup, now on 0.17!

  Initial post, please read:https://www.reddit.com/r/rust/comments/1sje980/farben_terminal_coloring_library_using_markup/

  Since the initial post, Farben has shipped several updates! The biggest addition is expand!(), a diagnostic macro that shows exactly what a markup expression resolves to, addressing feedback from the first post.

  Also added: five new SGR emphasis tags, comprehensive docstrings across the workspace, and a correctness fix for strings containing raw ANSI sequences.

  Wanted to highlight certain features that was unmentioned but is on the repo:

  • The v0.15 benchmark shows 1.099 microsecond time for the full formatting pipeline. More on v0.15's GitHub Release
  • Use try_color() to return a Result instead of printing
  • color_fmt!(), not cformat!()
  • Regular c* calls appends an ANSI reset at the end, use c*b* macros/functions if you don't want that
  • Lossy color degrading exists by default, but it doesn't use CIELAB. I am working on this
  • Ansi256 and RGB is supported via [ansi(n)] and [rgb(r,g,b)] (no spaces supported atm)
  • Added bugs so carefully hidden even I don't know where they are
  • Background coloring uses [bg:red]
  • Dependency tree is very minimal

  Please read the docs for more information: https://razkar-studio.github.io/farben

  And the changelog: https://razkar-studio.github.io/farben/changelog (or the one at the repo)

  I'm planning on having built-in styles, an opt-in feature flag that registers styles. Just thinking about how that would work...

  Thank you all for the stars, checking out my project, or even just viewing this post! It means a lot to me. I'll try my best to stabilize and ship more features to Farben and create a clean, ergonomic coloring crate for you all. I would love some feedback!

  submitted by /u/razkarstudio
  [link] [comments]
• Is there a cleaner way to resolve paths for a CLI with clap?

  Was wondering because this is my first time creating a CLI. I’m trying to automatically resolve the file path from the command, including cases like `.` or `..` and I seem to be getting stuck.

  Here’s an example of what I’m currently doing:

  ```

  pub fn resolve_base_config(user_input: Option<&str>) -> ConfigStatus {

  let path = if let Some(input) = user_input {

  let expanded = shellexpand::tilde(input).to_string();

  PathBuf::from(expanded)

  } else {

  let expanded = shellexpand::tilde(defaults::BASE_CONFIG_DEFAULT_LOCATION).to_string();

  PathBuf::from(expanded)

  };

  let final_path = if path.is_dir() {

  path.join(defaults::BASE_CONFIG_DEFAULT_FILE_NAME)

  } else {

  path

  };

  if !final_path.exists() {

  return ConfigStatus::Missing(final_path);

  }

  ConfigStatus::Exists(final_path)

  }

  ```

  It’s able to resolve absolute paths and using the tilde, but I’m not doing so well with other cases. For this CLI the files that I need to parse could really be anywhere so I don’t want to force the user to have their files in a specific location. However I’m also noticing the default fallback seems not to be working as well.

  submitted by /u/Ashken
  [link] [comments]
• DNS Sinkhole Filter suggestions

  For a high-QPS DNS threat-enforcement service (target 1M+ QPS per node, p99 <1ms), we’ve chosen a three-tier filter: fastbloom for negative pre-filter, fast_radix_trie for exact/suffix match, aho-corasick for complex patterns. Lock-free cache via crossbeam-epoch, singleflight via tokio::sync::Notify. Thoughts?

  submitted by /u/Capable_Estimate6492
  [link] [comments]
• Is there a way to output arbitrary unicode text to a user clicked text input?

  Ok, so I have a project where I need to output arbitrary unicode to an arbitrary text input that a user has clicked on. I have tried using enigo to do this, but can't output capital letters unless I manually press shift, either in the program or irl, and I can't do other arbitrary values such as ∝. Do I need to use a clipboard crate to do this, or am I just missing something with enigo?

  EDIT: Here is a bit more info, I am on linux (fedora specifically, but ideally this would work on all distros), I am okay using linux specific methods, as part of my program already only works on linux afaik. I want the user to be able to select a textbox or text input in any application, and the program insert text into there. Ideally it will eventually be so that you invoke it with a keyboard shortcut, and it inserts the text

  EDIT, ok, I seem to have a solution. So what I do is use arboard to copy the text to the clipboard, and then use enigo to paste it. Unfortunately this does clear clipboard contents

  submitted by /u/SmoothTurtle872
  [link] [comments]
• Building ezli.me, a link shortener in Rust
  submitted by /u/Extrawurst-Games
  [link] [comments]
• skerry: Experimenting with per function errors with easy conversions, replacing monolithic error enums and opaque errors.

  Crate: https://crates.io/crates/skerry

  I started this project because while I love error handling in rust the fact that I either have to match against 200 errors when only 2 are actually possible or manually write one billion enums and the conversions between them is incredibly annoying. Of course opaque errors like anyhow kind of work but then handling errors becomes extremely annoying.

  The goal of skerry is to allow those fine grained enum matching with as little boilerplate as possible, I even plan on the future to add a module wide macro that would remove the need for all the #[] annotations.

  Pros:

  • Your match statements only ever contain the variants that the function can actually return.
  • You instantly get an error through analyzer if the type you're converting from is not a subset to your function error.
  • The * prefix can flatten errors for you so matching is extremely easy

  • You don't really need to generate one error per function, if 2 functions return the exact same error you can do the following and it won't add any new types:

    define_error!(ManualDefine, [ErrorA, ErrorB]);

    [skerry_fn] fn my_fn1() -> Result<(), ManualDefine> { //... } [skerry_fn] fn my_fn2() -> Result<(), ManualDefine> { //... }

  Cons:

  • It really polutes the namespace with a bunch of error types, and at least in it's current state they're not contained inside a separate module, there are plans to at least mitigate this.
  • It can get pretty annoying if your lib uses skerry as the end users would have to first convert to the global error type generated that contains all variants to only then return, otherwise they would need to write a From to their errors for every single function. There are plans to add a optional feature that would automatically convert all errors into one global huge enum, you could then add this feature as an optional feature on your project and allow end users to choose.
  • Currently the generated types don't handle Clone, Debug or anything else than error conversion, you can manually implement them if you want though.

  Overall if you're curious please check the docs, I've only been working on this project for short time so expect problems. Can't talk about build times, but all these macros do is implement 2 impl From blocks and a bunch of of marker traits (1 per error type your error doesn't use, if we had negative traits this would be the opposite, 1 per error type you use).

  submitted by /u/Zkojin
  [link] [comments]
• Published push based single threaded reactive programming library

  Hello,

  https://crates.io/crates/rx-rs

  My motivation for creating this library, was to use it for developing UI inside Godot + Rust. From start I was looking at which FRP library I should use, but most of them were missing features I needed or most of them are ASync and it does not work well with Godot.

  This is heavily inspired by my previous workplace at gamedev company in-house Rx library, since I worked with it for over 5 years, those patterns really attached to me and I do see that they bring many benefits and reduce coupling of the systems, which I prefer over immidiate mode for doing UI in a game engine.

  This is my first time attempting to implement it inside rust (I'm no expert in rust). Maybe I'm doing something wrong or redundant and it can be done in a better way? Also hope that this might be useful to someone else!

  Thank you!

  submitted by /u/optical002
  [link] [comments]
• Building a Multi-Tenant Auth API using Rust, Traefik, and Ory Kratos

  Hey

  I recently published a technical breakdown of an architecture I designed for Gate Identity, an Auth-as-a-Service tailored for B2B SaaS multi-tenancy. I thought the community here might find the stack interesting.

  The Architecture: I wanted to build a robust identity layer without rolling my own crypto. I chose Ory Kratos (Go) for the core identity engine and PostgreSQL for storage. However, Kratos is designed for single-tenant or consumer apps out of the box.

  To solve the multi-tenancy isolation problem, I built a custom Edge Gateway entirely in Rust.

  Here is how the Rust layer fits in:

  1. Traffic Routing: Traefik terminates SSL and passes everything to the Rust gateway.
  2. State Isolation: When a user starts a login flow, the Rust API maps the Kratos flow ID to a specific tenant_id in Redis.
  3. Tenant-Ownership Validation: The Rust bouncer parses all access tokens and verifies against Redis/Postgres that the user making the request actually belongs to the workspace they are trying to access, effectively preventing cross-tenant data leaks.

  Rust was the perfect choice here because the gateway sits in front of every single auth request — it needed to be highly concurrent, memory-safe, and add virtually zero latency before proxying down to Kratos.

  I wrote a detailed post on DEV Community covering the setup, how the data isolation works, and the API design.

  submitted by /u/Zhuk-Max
  [link] [comments]
• TIL: Even with the new if let guards, match arms still need a fallback. Can someone help me understand the compiler's logic here?

  I was experimenting with the newly added support for if-let guards inside match arms in Rust 1.95.

  https://blog.rust-lang.org/2026/04/16/Rust-1.95.0/

  I created a (perhaps slightly over-complicated) scenario to understand how it works:

  ```rust

  [derive(Debug)]

  enum ErrorCodes { NotComputable, }

  fn compute(x: i32) -> Result<i32, ErrorCodes> { println!("compute invoked with {}", x);

  if x == 5 { Ok(x + 5) } else { Err(ErrorCodes::NotComputable) } 

  }

  fn get_value(x: i32) -> Option<i32> { if x < 10 { Some(5) } else if x < 20 { Some(10) } else { None } }

  fn test_value(input: i32, value: Option<i32>) { match value { Some(x) if let Err(y) = compute(x) => { println!("{} -> produced {} -> compute produced {:?}", input, x, y); } Some(x) if let Ok(y) = compute(x) => { println!("{} -> produced {} -> compute produced {}", input, x, y); } None => { println!("No match!"); } } }

  fn main() { let input = 0; let value = get_value(input); test_value(input, value);

  let input = 10; let value = get_value(input); test_value(input, value); let input = 20; let value = get_value(input); test_value(input, value); 

  } ```

  When I try to compile this code, I get the following error:

  `` cargo build Compiling new-features v0.1.0 (S:\projects\git\new-features) error[E0004]: non-exhaustive patterns:Some()not covered --> src\main.rs:27:11 | 27 | match value { | ^^^^^ patternSome()not covered | note:Option<i32>defined here --> C:\Users\fhaddad\.rustup\toolchains\stable-x86_64-pc-windows-msvc\lib/rustlib/src/rust\library\core\src\option.rs:600:1 | 600 | pub enum Option<T> { | ^^^^^^^^^^^^^^^^^^ ... 608 | Some(#[stable(feature = "rust1", since = "1.0.0")] T), | ---- not covered = note: the matched value is of typeOption<i32>` help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown | 36 ~ }, 37 + Some(_) => todo!() |

  For more information about this error, try rustc --explain E0004. error: could not compile new-features (bin "new-features") due to 1 previous error ```

  I understand what the compiler is saying, but I don't understand why. compute must return Ok or Err because it's return type is Result. So, from my perspective all cases are covered.

  Clearly, that's not true from the compiler's perspective though as it wants me to add the additional match arm.

  Does this mean that even if compute is deterministic, the compiler assumes that between the first guard and the second guard, the state could change (e.g., the first compute returned Ok and the second compute suddenly returned Err)?

  I know this isn't the best example, but the purpose of the exercise was just to understand if-let guards inside match arms.

  submitted by /u/freddiehaddad
  [link] [comments]
• Official /r/rust "Who's Hiring" thread for job-seekers and job-offerers [Rust 1.95]

  Welcome once again to the official r/rust Who's Hiring thread!

  Before we begin, job-seekers should also remember to peruse the prior thread.

  This thread will be periodically stickied to the top of r/rust for improved visibility.

  You can also find it again via the "Latest Megathreads" list, which is a dropdown at the top of the page on new Reddit, and a section in the sidebar under "Useful Links" on old Reddit.

  The thread will be refreshed and posted anew when the next version of Rust releases in six weeks.

  Please adhere to the following rules when posting: Rules for individuals:

  • Don't create top-level comments; those are for employers.

  • Feel free to reply to top-level comments with on-topic questions.

  • Anyone seeking work should reply to my stickied top-level comment.

  • Meta-discussion should be reserved for the distinguished comment at the very bottom.

  Rules for employers:

  • The ordering of fields in the template has been revised to make postings easier to read. If you are reusing a previous posting, please update the ordering as shown below.

  • Remote positions: see bolded text for new requirement.

  • To find individuals seeking work, see the replies to the stickied top-level comment; you will need to click the "more comments" link at the bottom of the top-level comment in order to make these replies visible.

  • To make a top-level comment you must be hiring directly; no third-party recruiters.

  • One top-level comment per employer. If you have multiple job openings, please consolidate their descriptions or mention them in replies to your own top-level comment.

  • Proofread your comment after posting it and edit it if necessary to correct mistakes.

  • To share the space fairly with other postings and keep the thread pleasant to browse, we ask that you try to limit your posting to either 50 lines or 500 words, whichever comes first.
    We reserve the right to remove egregiously long postings. However, this only applies to the content of this thread; you can link to a job page elsewhere with more detail if you like.

  • Please base your comment on the following template:

  COMPANY: [Company name; optionally link to your company's website or careers page.]

  TYPE: [Full time, part time, internship, contract, etc.]

  LOCATION: [Where are your office or offices located? If your workplace language isn't English-speaking, please specify it.]

  REMOTE: [Do you offer the option of working remotely? Please state clearly if remote work is restricted to certain regions or time zones, or if availability within a certain time of day is expected or required.]

  VISA: [Does your company sponsor visas?]

  DESCRIPTION: [What does your company do, and what are you using Rust for? How much experience are you seeking and what seniority levels are you hiring for? The more details the better.]

  ESTIMATED COMPENSATION: [Be courteous to your potential future colleagues by attempting to provide at least a rough expectation of wages/salary.
  If you are listing several positions in the "Description" field above, then feel free to include this information inline above, and put "See above" in this field.
  If compensation is negotiable, please attempt to provide at least a base estimate from which to begin negotiations. If compensation is highly variable, then feel free to provide a range.
  If compensation is expected to be offset by other benefits, then please include that information here as well. If you don't have firm numbers but do have relative expectations of candidate expertise (e.g. entry-level, senior), then you may include that here. If you truly have no information, then put "Uncertain" here.
  Note that many jurisdictions (including several U.S. states) require salary ranges on job postings by law.
  If your company is based in one of these locations or you plan to hire employees who reside in any of these locations, you are likely subject to these laws. Other jurisdictions may require salary information to be available upon request or be provided after the first interview.
  To avoid issues, we recommend all postings provide salary information.
  You must state clearly in your posting if you are planning to compensate employees partially or fully in something other than fiat currency (e.g. cryptocurrency, stock options, equity, etc).
  Do not put just "Uncertain" in this case as the default assumption is that the compensation will be 100% fiat. Postings that fail to comply with this addendum will be removed. Thank you.]

  CONTACT: [How can someone get in touch with you?]

  submitted by /u/DroidLogician
  [link] [comments]
• ndatafusion: linear algebra and ML for DataFusion, powered by nabled

  Hello r/rust! I just released ndatafusion 🪐

  The goal is to make Apache DataFusion a much more natural place for linear algebra and ML-style workloads.

  ndatafusion brings numerical capabilities into DataFusion through explicit Arrow/DataFusion contracts, powered under the hood by nabled, my other Rust crate for linalg/ML workloads.

  I built it because I wanted a cleaner answer to a pretty basic problem: if you’re already using Arrow and DataFusion, you shouldn’t have to leave that ecosystem the moment you need vector or matrix-oriented computation.

  As far as I know, there still isn’t much in the Rust/DataFusion ecosystem aimed directly at this layer, which is part of why I wanted to get it out.

  Links:

  • Crates.io: https://crates.io/crates/ndatafusion
  • Docs.rs: https://docs.rs/ndatafusion
  • GitHub: https://github.com/georgeleepatterson/ndatafusion

  Would especially appreciate feedback from people working on Rust query engines, Arrow-native systems, SQL extensions, or ML/data infra.

  submitted by /u/moneymachinegoesbing
  [link] [comments]
• Meet roxy a cli tool I made as a learning project

  I just finished up one of my rust projects "roxy". Its a minimal proxy manager i built because i found myself dealing with proxies and stuff, so i thought why not build a manager. It was a really nice learning project, and today i released v0.1.0 with more features to come

  https://github.com/Yonatan-Ethiopia/roxy

  submitted by /u/shad0_w2
  [link] [comments]
• Eclipse Zenoh 1.9
  submitted by /u/FuzzyPixelz
  [link] [comments]
• I just released CrabbyQ, a Rust framework for message-driven microservices

  Hi all,

  My collegue is finally publishing the first public version of CrabbyQ, an async Rust framework for building message-driven microservices.

  It is heavily inspired by axum in terms of ergonomics, but targets message brokers instead of HTTP. The goal is to provide an “axum-like” experience for broker-driven services: routing, extractors, state, publishers, request/reply RPC, middleware, graceful shutdown, and error routing (including DLQ-style handling).

  At the moment, it includes:

  - a broker-agnostic core router and publisher API

  - NATS support with JetStream-specific routing and publishing

  - basic Redis pub/sub support

  - basic MQTT support

  - examples, integration tests, and feature-gated broker backends

  The project is now available on https://crates.io/crates/crabbyq , and I’d really appreciate feedback on the API and overall design direction.

  GitHub: https://github.com/LamantinAI/crabbyq

  submitted by /u/IllustriousPeanut403
  [link] [comments]
• Taguar - Desktop app for audio tagging

  I tried out numerous audio tagging apps (Kid3, Picard, …) and wasn't happy with any of them. They all try to work with some kind of library system of have a really bad UX (single line input for Lyrics???).

  Therefore I decided to build one that is simple, fast, with great defaults: https://github.com/ad-si/Taguar

  It's built with Iced and lofty.

  Looking forward to your feedback! 😊

  submitted by /u/adwolesi
  [link] [comments]
• Rust Koans
  submitted by /u/iamstonecharioteer
  [link] [comments]
• Experimenting with a DX-focused Rust ORM (Personal Project)

  So I've been tinkering with a small ORM on the side. Not trying to make it fast or lightweight or anything like that - the whole point was just to make relational queries less annoying to write.

  My biggest gripe was always manually wiring up IDs for relations. So I made nested writes just... work in one shot:

  let user = user() .create("demo@example.com".to_string()) .data(|d| { d.posts(|p| { p.create("post 1".to_string(), |_| {}); p.create("post 2".to_string(), |_| {}); }); d.profile(|p| { p.create("fullstack dev".to_string(), |_| {}); }); }) .include(|u| u.posts()) .include(|u| u.profile()) .exec(&client) .await?; 

  For filtering, I wanted where clauses to actually read like logic instead of some deeply nested config blob:

  let users = user() .find_many() .where_clause(|w| { w.posts().some(|p| { p.title().contains("awesome"); }); w.or(|w| { w.email().contains("example.com"); w.role().eq(Role::USER); }); }) .exec(&client) .await?; 

  But honestly the thing I keep reaching for the most is type-safe selections without needing a bunch of intermediate structs - works for nested relations too:

  let data = user() .find_unique() .select_as(select_as!({ email: String, posts: { title: String, comments: { id: String, text: String, }[] }[] })) .where_clause(|w| { w.email("demo@example.com".to_string()); }) .exec(&client) .await?; 

  Under the hood it's just wrapping a solid query engine, so execution isn't something I really had to worry about - most of my time went into figuring out what the API should feel like to use.

  Just to be clear: this is very much a personal experiment. Not trying to compete with Diesel or SQLx, just wanted to see if I could make the day-to-day querying stuff feel a bit less tedious for side projects.

  submitted by /u/Illustrious-Mail-587
  [link] [comments]
• Rust Language Milano is back! New organizer & looking for speakers 🦀🇮🇹

  I’m excited to announce that I’ve officially taken over as the new organiser for Rust Language Milan.

  Milan has a great tech ecosystem, and I want to make sure our local Rust community is a core part of it.

  Our goals for 2026:

  • In-person meetups: Getting back to face-to-face networking and technical talks.
  • Knowledge sharing: Deep dives into the borrow checker, async, embedded, and more.
  • Building the ecosystem: Connecting local companies using Rust with the developers who love it.

  To get the gears turning, I’m looking for:

  1. Members: Join the Meetup group to get notified of our first event: meetup.com/rust-language-milan
  2. Speakers: If you have a project, a crate you love, or a "Rust in production" story, please reach out! (Lightning talks are also very welcome.
  3. Venues: If your company is based in Milan and would like to host us, let’s chat.

  Let’s make Milan the Rust capital of Italy 🦀!

  P.S. If you have ideas for what you’d like to see in the first meetup, drop a comment below!

  submitted by /u/dariocurr
  [link] [comments]
• Rust Analyzer is using half of my memory

  While building LEA - Law Enforcement Agency based desktop application in Tauri, I found that Rust Analyzer used a large amount of system RAM (the majority of my memory)

  Rust Anlyzer

  Does anyone else with a large Rust/Tauri project have this type of experience? What are some settings that seem to reduce the amount of memory consumed, or improve performance, with Rust Analyzer?

  submitted by /u/Somspace
  [link] [comments]

r/golang

• Automated Go test coverage production

  This blog is a tutorial on how to collect unit and integration test coverage information in GitHub actions and combine them into a single coverage report. It includes a simple Go tool that produces a more functional and prettier version of the built-in HTML coverage viewer. submitted by /u/zachm [link] [comments]

• go tool task

  submitted by /u/andrey-nering [link] [comments]

• Frames encoding

  I need for an application to be able to encode frames a FullHD/4K a 30/60 fps.

  Is there a lib for H264, H265 bindings or native Go ?

  submitted by /u/Agent-Nemo
  [link] [comments]
• Why `goproxy`, `oxy`, and `Martian` were not the right fit for our app, and what we built differently

  I recently open-sourced proxykit, but the reason it exists is not that Go lacked proxy libraries.

  It does not.

  goproxy, oxy, and Martian are all solid projects.

  What did not fit for our case was the architectural shape.

  We were building a real Flutter + Go product:

  • flutter_network_debugger

  Its backend needed one reusable foundation for:

  • reverse HTTP
  • forward HTTP
  • CONNECT
  • WebSocket
  • listener/runtime management
  • neutral observation hooks

  The problem was that we did not want the public Go module to own product concerns like:

  • REST routes
  • storage
  • frontend DTOs
  • monitor delivery protocol
  • app-specific /httpproxy or /_api/v1/... contracts

  That is where the mismatch with existing options showed up.

  For our case:

  • goproxy felt closer to a larger programmable proxy object than the smaller package boundaries we wanted
  • oxy is strong for reverse-proxy-centric HTTP composition, but our backend was not only reverse HTTP
  • Martian is strong for modifier-driven HTTP mutation, but we were not trying to publish a modifier framework

  So what we built differently was not "more features" or "a better version of those libraries".

  We built a narrower transport foundation with explicit package boundaries:

  • reverse
  • forward
  • connect
  • wsproxy
  • proxyruntime
  • observe

  and kept app-specific API, storage, realtime delivery, and UI compatibility outside the public module.

  So the claim is not:

  proxykit is better than goproxy, oxy, or Martian

  The claim is:

  for applications that need reverse + forward + CONNECT + WebSocket under one clean adapter-friendly foundation, those shapes were not the right fit for us

  If that is also your problem, proxykit may be useful.

  Links:

  • repo: https://github.com/777genius/proxykit
  • docs: https://777genius.github.io/proxykit/

  submitted by /u/IlyaZelen
  [link] [comments]
• Validating data in Go
  submitted by /u/elementarteilchen
  [link] [comments]
• I built a full SMB server with NTLM hash capture in Go – here's what I learned

  While working on goshs (my SimpleHTTPServer replacement written in Go) I wanted to add an SMB server that goes beyond just file serving — specifically one that captures and cracks NTLM hashes, which is a common technique in penetration testing.

  Turns out implementing this in Go from scratch was quite a journey. The SMB protocol is notoriously complex and the NTLM authentication handshake even more so. I couldn't find any existing Go implementation that covered this use case end to end.

  The result is now part of goshs — a single binary that spins up an SMB server, captures NTLM hashes from connecting clients and attempts to crack them on the fly. It works with native Windows 10 and 11 SMB clients and all? linux clients out of the box, no extra software needed on the target side.

  If you're curious about the implementation or want to look at how SMB and NTLM are handled in Go I'd love to hear your feedback.

  Disclaimer: I used claude code extensively to develop this feature and it still has minor bugs.

  GitHub: https://github.com/patrickhener/goshs

  submitted by /u/JohnnyTheSmith
  [link] [comments]

r/rust_gamedev

• Published push based single threaded reactive programming library

  Hello,

  https://crates.io/crates/rx-rs

  My motivation for creating this library, was to use it for developing UI inside Godot + Rust. From start I was looking at which FRP library I should use, but most of them were missing features I needed or most of them are ASync and it does not work well with Godot.

  This is heavily inspired by my previous workplace at gamedev company in-house Rx library, since I worked with it for over 5 years, those patterns really attached to me and I do see that they bring many benefits and reduce coupling of the systems, which I prefer over immidiate mode for doing UI in a game engine.

  This is my first time attempting to implement it inside rust (I'm no expert in rust). Maybe I'm doing something wrong or redundant and it can be done in a better way? Also hope that this might be useful to someone else!

  Thank you!

  submitted by /u/optical002
  [link] [comments]
• Progress update: my Rust game is now in public playtest

  A couple of months ago I shared progress on my game here. Since then, the project has reached a major milestone - the first public playtest is now live! The game is a sandbox about building ships tile by tile and docking them together into functioning structures. Instead of a fixed base, you have grids interconnecting and interacting. And the flight dynamic obey real physics - you can't just put a thruster anywhere and fly in any directions, real forces get applied to off-center points. From a technical standpoint, the stack is: Rust for the core game, as well as for the WASM based scripting SDL3 using OpenGL 3.3 Custom rendered UI via Taffy with full controller support Renet networking for multiplayer via a deterministic lockstep simulation. Previously I used a server authority based approach, but the sheer scale of the universe made it harder and harder to justify. Lockstep results in a flat <5kB/s network speed use. Highly modular content system, with a Wasmtime based scripting system (that I still haven't published the documentation for, because the API is evolving rapidly and I constantly introduce breaking changes - which are fine due to my own scripts being in lockstep with the game release) There were so many challenges involved, and so many things you'd pull from a library - I had to implement myself to ensure the 100% portable determinism for lockstep multiplayer. Sometimes I wonder "how did it take up a year and a half of my free time", but then I noticed the 130k SLoC of code alone, besides all the other efforts involved. Here's a link to the Steam page, if you'd like to test it out. It's a free, open, playtest. Also you can join the discord if you'd like to follow along on the development. The game won't be open-source, before you ask, but the scripting, once it's public one day, will give you incredible power to build any mod you want using Rust. I'm happy to answer any technical questions! submitted by /u/adnanclyde [link] [comments]

Movie Trailers

• Tom and Jerry: Forbidden Compass Movie Trailer
• Billie Eilish: Hit Me Hard and Soft - The Tour Movie Trailer
• The Hunger Games: Sunrise on the Reaping Movie Trailer
• Street Fighter Movie Trailer
• Insidious: Out of the Further Movie Trailer
• Passenger Movie Trailer
• The Wizard of the Kremlin Movie Trailer
• The Dog Stars Movie Trailer