Huginn Daily

Thursday, April 2, 2026

04fc3b8b-f205-40b1-8c31-eaddfd3f6f3e

Weather

Summary	⛅️ Light rain in the morning and breezy in the afternoon.
Temperature Range	15°C to 21°C (58°F to 70°F)
Feels Like	Low: 54°F | High: 70°F
Humidity	83%
Wind	17 km/h (11 mph), Direction: 142°
Precipitation	Probability: 100%, Type: rain
Sunrise / Sunset	🌅 06:34 AM / 🌇 07:09 PM
Moon Phase	Waning Gibbous (52%)
Cloud Cover	69%
Pressure	1008.05 hPa
Dew Point	58.6°F
Visibility	6.31 miles

XKCD

Reddit

r/gamedev

• Is “not enough players to properly test multiplayer” a real problem, or just part of the game?

  One thing I keep wondering about with multiplayer games is how teams deal with the stage where there just aren’t enough players yet.

  Not enough real users means:

  • hard to test onboarding realistically
  • hard to see if matches actually flow well
  • hard to evaluate balance under real-ish conditions
  • low-player lobbies can feel dead
  • bad bots often seem worse than no bots

  For devs who’ve been through this:

  • how much of a real pain point is this?
  • what do you actually do about it?
  • are simple bots good enough?
  • does off-hour / low-concurrency match feel matter a lot for retention?
  • what’s the least-janky way to make early multiplayer testing useful?

  I’m mainly trying to understand whether this is a genuinely painful gap for smaller teams or just something people accept and work around.

  submitted by /u/imgscrpr
  [link] [comments]
• Why exactly did Rec Room shut down? What makes the business 'unsustainable' ?

  The game had an audience and surely some revenue. Could they not simply lower expenses to keep the business afloat? Or did they take on too much venture capital investment that required them to "grow or die"? This is what I'm assuming but I'd love to hear more from someone with more context.

  As this is the game dev sub, I'm also curious in a general sense, why games get shutdown. Of course the obvious answer is "not enough revenue" but again - could they not simply lower expenses? Isn't that a viable business strategy?

  submitted by /u/Frolicks
  [link] [comments]
• Free spin expectation deviation in slots and defense against statistical margin leakage

  A free spin entry pattern exceeding the expected RTP of the designed mathematical model is being observed in certain games. This is interpreted as a sophisticated margin leakage phenomenon in which sessions outside the volatility threshold accumulate, causing the house edge to fall below its intended design level. It is generally common to respond systematically by building a correlation analysis model that reflects volatility weighting through the Lumix solution. In a high-volatility environment, what practical threshold criteria are used to precisely distinguish between a simply lucky user and an abuser?

  submitted by /u/sandiego-art
  [link] [comments]
• Begun drafting my first ever game design document. Looking for some advice.

  I am beginning to work on designing a draft for a game design document for an untitled PvP Real-Time Strategy game inspired by They Are Billions, Starcraft 2, and Armor Games’ Colony.

  I have also never written a proper game design document before (let alone know how to make a game). I am looking for advice from anyone who might be willing to look at my not very organized notes to help me. Not looking for any kind of actual collaboration or developers, just directions to resources that might help me get my ideas straightened out and into slightly presentable format.

  submitted by /u/TheBoobyDragon
  [link] [comments]
• Fog‑of‑War System , Let me know what you think of it.

  Hey everyone! I’ve been working on a fog‑of‑war system for my game Nemorsys, and I wanted to share the approach to get some feedback from other devs both on the technique itself and on the final visual result. Here’s the current setup: An animated fog texture gives the fog a natural, shifting look The player’s line of sight is sampled with ~180 raycasts Those raycasts update a mesh texture that represents visibility Ablur pass softens the edges of the revealed areas on a camera texture with a special shadder The fog mesh lerps between states to avoid harsh popping And I use a stencil buffer on the mesh texture so everything underneath disappears cleanly It’s definitely on the heavy side, but it works fine in practice — it costs around 40 FPS out of 240 FPS on my current setup. Not ideal, but still playable. I’m really curious what other devs think of this approach. Do you like the result? Would you handle fog‑of‑war differently? Any tricks or optimizations you’d recommend? Always interested in seeing how others tackle this kind of system submitted by /u/Brilliant_Count_4480 [link] [comments]

• What to do over the summer?

  My parents are actually pretty supportive of the game dev dream only while I'm in school so I'm wondering if taking Summer game dev courses at my university is the best use of my time over the summer or are there any "official" organizations or education sources that could be a better use of my time?

  submitted by /u/g1ngertew
  [link] [comments]
• US patent office revokes Nintendo’s patent on summoning characters to make them battle

  The USPTO has revoked several of Nintendo's patents after re-examination, determining they should not have been granted to begin with due to instances of prior art. Nintendo can appeal the decision, but it is likely several of their patent claims will be invalidated. submitted by /u/SadisNecros [link] [comments]

• How do you research about a specific target audience for a specific genre?

  After watching an anime long time ago, I recently came up on a wild idea of creating a game.
  The genre of the game is Horror and Monster collecting. Think of like pokemon and horror.
  The thing is, I see lots of growth in the indie horror games, so I know for a fact that there can be a target audience for the horror part, but I'm afraid that the monster collection might be a disappointment.

  I'm really curious on how to identify and research on such target audiences especially when combining multiple genres that idk might be rare (I am not so sure if it's rare or not in my case, ig that's my first step) .

  How do you guys tackle these stuff?

  Edit 1:
  So far I've gathered these links that might be relevant:
  https://games-stats.com/
  https://gamalytic.com/
  https://steamdb.info/
  https://app.sensortower.com/vgi/ ( I don't know yet how this works, we might probably need an account for this)

  submitted by /u/Starbolt-Studios
  [link] [comments]
• Started a game in 2024... got burnt out. Started on the project again at the beginning of 2026 and released my DEMO on Steam today.

  I've been making small, unfinished games all my life. I started out by using AMOS on my Amiga in the 90s and made a huge number of little... tech demos, I suppose you'd call them. They were the outline of games, but I didn't get much beyond that.

  I messed with Unity a few times over the years, and got some small demos up and running, but nothing much happened there either.

  Then I picked up Gamemaker on a sale and thought I'd turn my 44-year-old brain towards game development again to see if the noggin still worked. I was immediately hooked and spent most of my spare time working on it (and also thinking about working on it while at my day job!).

  I spent so much time on it that I eventually simply burnt myself out on the project - I could only see the flaws, and thought I was wasting my time. My ambition for it was low, but in my head, the game didn't even reach allowing more than a handful of people to even try it.

  I know I'm not alone here.

  Then, at the beginning of this year, I fired it up again to take a look. This time, the flaws were still there, but so were the good things! Inspiration took hold once again.

  I've been working on it pretty solidly since January, and finally felt comfortable enough to release it on Steam (after some playtesting from friends of course).

  It's a hand-drawn platform game where you play through the drawings and paintings of a man who grew up in the 80s and 90s, and longed to make a game... not sure where that idea came from!

  I guess getting to this point just made me want to share it somewhere with like-minded folk. I can't wait to carry on making the full game now, and the ideas are flooding in - a total opposite of how I felt at the end of 2024.

  Sometimes revisiting old projects might be worth doing.

  I won't post a link due to promotion rules etc, but DM me if you're interested.

  submitted by /u/ImmersedRobot
  [link] [comments]
• They told us to kill our game. Then it got millions of players.

  We're a 2-person indie team (I do code, my spouse does art). I want to share our story because I think there are some useful takeaways.

  The rejection

  In 2023 we were under an exclusive contract with a mobile publisher testing a ragdoll sandbox idle game. The test numbers weren't terrible, but the publisher told us to kill it, not profitable enough/not hitting their KPIs. Under the contract terms, even if we kept working on it ourselves, they'd own 50% of the revenue. So we put it away and waited out the contract.

  What happened next

  Once the contract ended, one year later, we self-published the game. At first, basically nothing. Then a few streamers discovered it organically, we had zero marketing budget, zero outreach and it kinda snowballed. Now it’s sitting at 450k+ organic downloads on mobile. Millions of plays across web platforms. All from a game a publisher said wasn't worth making.

  Why we put it on Steam (and why we kept expectations low)

  We'd been wanting to move to Steam for a while, but our next project (an incremental game we've been building for months) is our real bet. So we decided to use No Pain No Gain as our "learn Steam" project, figure out the store page, the build upload process, the review pipeline, Next Fest mechanics, and these kind of things... We added quality-of-life features, made the experience a bit smoother, and polished things up, but we were honest with ourselves: this was primarily about learning the platform with a game that already had proven appeal on web and mobile.

  What we actually learned

  • Your players know better than any single gatekeeper. A publisher looked at numbers and said kill it. Millions of actual players disagreed. That doesn't mean ignore all feedback, but a publisher optimizing for their portfolio's ROI has different interests than you do. If players are having fun with your game, that signal matters more than one guy's rejection.
  • Platform matters more than most people realize. Our game underperformed by publisher standards on mobile, mainly because they tested for marketability on Facebook. Then it kinda “exploded” on YouTube and web platforms. Now we're testing Steam. Same core game but wildly different outcomes depending on where and how people find it. If your game isn't landing on one platform, consider that the platform might be wrong before you conclude the game is wrong.
  • Do a "throwaway" Steam launch before your main game. This is probably our biggest practical takeaway. Steam has its own ecosystem with store page optimization, tag strategy, wishlist dynamics, review timing, build branches and you don't want to learn all of that while simultaneously trying to nail the launch of the game you've put your heart into or spent years on. Publishing NPNG first meant every mistake we made or will make is “ok” to make. Now when we launch our next game, we'll know exactly what we're doing, hopefully lol.
  • Streamers can be your entire marketing department. We spent $0 on marketing. And did no outreach. Every single download came from organic streamer coverage and word of mouth. We got lucky, sure. But "luck" was partly that we made something that was fun to watch someone else play. We literally made this game with the idea that Streamers will play it. Our working title was “streamer ragdoll game”. If you're designing a game,it is also good to think about whether it creates moments that are entertaining for a viewer, not just the player.

  What's next

  We're now deep in development on our next title, an incremental game.

  Everything we learned from this journey is going directly into that project. If you're interested, the Steam page is up, but honestly, I mainly wanted to share this because three years ago we were sitting there being told our game was dead, and now here we are…

  Happy to answer any questions about the publishing process, the mobile/web-to-Steam transition, or working as a two-person team.

  submitted by /u/BlobKingGame
  [link] [comments]
• Sharing my experience from 9 years of professional boardgame developer and >1m sold copies

  Hey everyone,

  recently I gave a talk at a small fair, since I did the work anyways, why not share it here. Maybe it helps :)

  My background:

  Studied Game Design at Games Academy in Germany for 1 year (Thats the standard time) back in 2014.
  Then worked as a Editor for Hans im Glück and eventually became the Head/Lead of Development.
  I worked on over 25 different projects that sold over 1 million copies in total.
  We even won Kennerspiel des Jahres (game of the year) for Paleo.

  Then after 9 years I decided to switch to video games, which resulted in founding my own studio. We work on boardgame related video games.

  How is a boardgame made:

  1. Everything starts with an idea. Which is most commonly by a non professional. Its just a random person that starts creating a boardgame prototype.
     
  2. Usually its then shown to a publisher (I was sitting on the publisher side thousands of times, pitching only once).
     Side note: Of course a small fraction of games is published self or with crowdfunding, but this is much
     harder in boardgames, because you also have huge production costs.

  Reaching out to boardgame publishers is also super easy, you just write them a mail and they answer. Different story with video games in my experience.
  3. The publisher works on illustrations, develops the game further (that really depends, but we did that) and works on production.
  4. Game is released. A network of distributors make sure that the box is where it can actually be sold. The boxes are relativley big and heavy, this makes it quite hard.

  Actual learnings that can be transfered to video games:

  1. Prototyping
  Prototype either physically at a table or digitally (e.g. Tabletopia) to remove friction and iterate fast. In board games, you can build and test ideas within hours since there’s no programming blocking you. Start by modifying existing games to make it easier. Even for video games, you can abstract systems and test them this way. Most importantly: get it on the table early and test as much as possible.

  • No engine needed → focus purely on mechanics and player interaction
  • Modify existing games instead of starting from scratch
  • Test early, test often—especially new systems
  • Forces clear communication and exposes design flaws fast
  • Makes later implementation and ticket writing much easier

  2. Mechanics First

  In board games, gameplay is almost entirely systems—mechanics alone already carry the experience. Visuals can enhance it, but they’re not the focus. You can’t hide weak design behind polish, so decisions are driven purely by playability. This is especially valuable for small studios that need to create strong gameplay with minimal content.

  • Mechanics must stand on their own
  • No hiding behind visuals or production quality
  • Design decisions are driven by gameplay, not presentation
  • Strong systems > large amounts of content
  • Great mindset for small teams with limited resources

  3. System Design

  Board games heavily focus on systems like economy, progression, and leveling—often enough to carry the entire experience. While video games can introduce completely new systems, board games show how far you can go by combining and refining existing ones. These systems must always stay understandable, transparent, and fair, enabling clear and meaningful decisions for players.

  • Strong focus on economy, progression, and interconnected systems
  • Systems must be easy to understand and fully explainable
  • Transparency and fairness are critical
  • Clear, meaningful player decisions are key

  4. Elegance & Emergence

  Great board games rely on elegant systems—simple rules that create deep gameplay. The challenge isn’t adding features, but cutting them down to the minimum that still produces meaningful depth. Emergence comes from systems interacting with each other, creating outcomes that aren’t explicitly designed but naturally arise through play.

  • Elegance: simple systems that generate depth
  • Cutting features is harder (and more important) than adding them
  • Emergence: systems interacting to create unexpected gameplay
  • Achieve more with less—key principle for indie development

  5. Interaction

  Board games thrive on player interaction—sitting across from each other already creates tension. With very little, you can generate a lot of gameplay through deduction, negotiation, and scarcity. Players discuss, bluff, trade, and compete, creating a “meta game” of politics on top of the actual rules.

  • Deduction: players lie, argue, and read each other
  • Free trade and open decisions create dynamic interactions
  • Scarcity forces meaningful engagement between players
  • “Everyone vs everyone” creates a social meta game

  6. Balancing

  Balancing in board games is harder due to limited data and slower testing cycles. Even if something is mathematically fair, it doesn’t matter if it feels frustrating—player perception beats numbers. This is very different from competitive video games, where win rates and data matter more. Since you can’t patch a board game, balance decisions need to be much more deliberate.

  • Limited data → testing is slower and less precise
  • Player feeling > mathematical fairness
  • Different approach than competitive, data-driven games
  • Lessons still apply well to singleplayer digital games
  • You can’t patch—e.g. Carcassonne only had minimal rule changes over decades

  7. Digital & Analog Adaptations

  The learnings aren’t separate—there’s strong overlap between board games and video games in both directions. Adapting a game becomes especially interesting once it’s already successful in one medium, as you can transfer the fanbase and reach new audiences. Today, many successful board games get digital versions, and vice versa.

  • Strong crossover: systems and design translate both ways
  • Existing success → easier audience transfer and discovery
  • Common in board games going digital (also great work-for-hire opportunity)
  • Digital → analog works especially well for system-heavy games
  • Examples: Slay the Spire, Dorfromantik, Baldur's Gate, League of Legends

  Conclusion

  There’s something to learn everywhere—especially from board games. They offer a different perspective on systems, clarity, and player interaction that translates well into video games. Most importantly: test early and often, and don’t hesitate to use paper prototypes.

  • Look beyond your own medium for inspiration
  • Board games are great teachers for systems and clarity
  • Use simple paper prototypes to iterate fast

  If there is anything you want to know, or if you need feedback / first steps into that industry, just let me know, always happy to help!

  submitted by /u/dev_w_grillz
  [link] [comments]
• Just hit 5 trillion wishlists with 0 marketing! Here's what I learned:

  If you need proof you have trust issues.

  1) Work on your game for at least 5 YEARS before showing anyone so you can make it good first.

  2) Don't show ANYBODY your game without them signing an NDA.

  3) If you combine 10 different genres, you get 10 TIMES as many wishlists.

  4) Don't share the game in public. People love secrets.

  5) If you follow EXACTLY what I did (successful game) then your game will be 100% just as successful.

  submitted by /u/CAGE_Studios
  [link] [comments]
• Permadeath felt like the right call until playtesters started rage quitting

  So I've been working on a survival RPG with permadeath as a core mechanic. The whole point of the game is that death matters -- you lose your character, your gear, your progress. That tension is what makes every encounter feel meaningful instead of just another respawn.

  At least that's what I kept telling myself.

  When I started getting playtester feedback, a pattern showed up pretty fast. People loved the tension during gameplay. The careful decision making, the "do I risk this fight or sneak past" moments. But when they actually died after like 45 minutes of a run, most of them didn't start over. They just stopped playing.

  The ones who did come back said stuff like "I loved it but I need a break after that." Which... is not great for retention.

  I tried a few things to soften the blow without removing permadeath entirely:

  - Making early game progression faster so getting back to "the good part" doesn't feel like a slog

  - Adding a meta-progression layer where certain unlocks carry over between runs

  - Keeping runs shorter so a death doesn't wipe out an entire evening of progress

  The meta-progression helped the most honestly. Once people felt like dying still moved them forward in SOME way, the rage quits dropped off. But I keep going back and forth on whether I've diluted the original vision too much.

  For those of you who've shipped games with permadeath or roguelike elements -- where did you land on this? Pure permadeath, or some kind of compromise? And did you feel like the compromise actually made it better or just less punishing?

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

r/rust

• Built Something. Break It. (Open Source) Seeking feedback on the projects I have been working on.

  Quantalang is a systems programming language with algebraic effects, designed for game engines and GPU shaders. One language for your engine code and your shaders: write a function once, compile it to CPU for testing and GPU for rendering.

  My initial idea began out of curiosity - I was hoping to improve performance on DirectX11 games that rely entirely on a single-thread, such as heavily modified versions of Skyrim. My goal was to write a compiling language that allows for the reduction of both CPU and GPU overhead (hopefully) by only writing and compiling the code once to both simultaneously. This language speaks to the CPU and the GPU simultaneously and translates between the two seamlessly.

  The other projects are either to support and expand both Quantalang and Quanta Universe - which will be dedicated to rendering, mathematics, color, and shaders. Calibrate Pro is a monitor calibration tool that is eventually going to replace (hopefully) DisplayCAL, ArgyllCMS, and override all windows color profile management to function across all applications without issue. The tool also generates every form of Lookup Table you may need for your intended skill, tool, or task. I am still testing system wide 3D LUT support. It also supports instrument based calibration in SDR and HDR color spaces

  I did rely on an LLM to help me program these tools, and I recognize the risks, and ethical concerns that come with AI from many fields and specializations. I also want to be clear that this was not an evening or weekend project. This is close to 2 and a half months of time spent working on the project - however, I do encourage taking a look.

  https://github.com/HarperZ9/quantalang

  100% of this was done by claude code with verbal guidance

  ||| QuantaLang — The Effects Language. Multi-backend compiler for graphics, shaders, and systems programming. |||

  https://github.com/HarperZ9/quanta-universe

  100% of this was done by claude code with verbal guidance

  ||| Physics-inspired software ecosystem: 43 modules spanning rendering, trading, AI, color science, and developer tools — powered by QuantaLang |||

  https://github.com/HarperZ9/quanta-color

  100% of this was done with claude code using verbal guidance

  ||| Professional color science library — 15 color spaces, 12 tone mappers, CIECAM02/CAM16, spectral rendering, PyQt6 GUI |||

  https://github.com/HarperZ9/calibrate-pro

  and last but not least, 100% of this was done by claude code using verbal guidance.

  ||| Professional sensorless display calibration (sensorless calibration is perhaps not happening, however a system wide color management, and calibration tool. — 58-panel database, DDC/CI, 3D LUT, ICC profiles, PyQt6 GUI |||

  submitted by /u/MeAndClaudeMakeHeat
  [link] [comments]
• This Week in Rust #645
  submitted by /u/seino_chan
  [link] [comments]
• Sketch: lightweight ephemeral, disposable machine sessions

  Hi all,

  I've started working on a new project in Rust that I’ve wanted to create for a while. It solves a personal need, but maybe others will find it useful too.

  It’s called Sketch, and it provides a lightweight, disposable machine session. Sketch uses OverlayFS to create an (almost) complete copy of the host filesystem. However, all modifications are completely discarded when you leave a Sketch session.

  For example, you can run something like:

  $ sketch (sketch) $ apt install experimental-package (sketch) $ # Try it out... (sketch) $ exit 

  The package (including any created files such as configs) will not be saved on the host. There’s no need to remember which package manager you used if you only need a package temporarily.

  As an anecdote, I recently had to use MongoDB to connect to a server. However, after I was done, I had no business keeping it on my machine. So I just used Sketch.

  One of the features Sketch supports is selective saving of files to the host. More features are planned.

  Finally, unlike a container, Sketch (a) does not require any images and (b) works as a copy of your host filesystem, with any changes on the host propagating instantly to Sketch.

  Would like to hear everyone's thoughts and any feedback you might have.

  submitted by /u/lollipopsweetie
  [link] [comments]
• Weird Option<&'a dyn Any> behavior

  Today I've started working on a voxel based game simular to Minecraft. My intention is to create a client that is able to be more easily modded without a big overhead. A mod should just be a crate, that is compiled into the modpack binary to increase performance. Because of this design goal I can't have a static Block Enum but must use a trait:

  pub trait Block { fn tick(&mut self) {}; fn is_solid(&self) -> bool; } 

  There are more functions, but I don't want to bloat this post.

  I want to store Blocks in 16x16x16 chunks for quicker access times:

  pub struct Chunk<'a> { pub blocks: [[[&'a dyn Block; 16]; 16]; 16], block_storage: bumpalo:Bump, pub chunk_coordinates: (i32, i32, i32), } 

  The problem I ran into is, that some blocks have zero sized structs. However they still implement the functions, that the Block trait specified. I have already tested, that bumpalo:Bump doesn't panic when trying to allocate a zero sized struct. Each block should should be stored on the bump and only a reference to it in the array. I consulted multiple AI Tools with this solution and they all wanted to wrap &'a dyn Block in an Option in order to handle zero sized Blocks, which doesn't really make sense. At least I didn't manage to run into undefined behavior the AI was frightened of.

  However, while trying out different solutions, I noticed, that there isn't a size difference between Option<&'a dyn Block> and <&'a dyn Block>. According to a short research a Null ptr is seen as None while any other pointer is seen as Some. If I however try to wrap a Null Pointer in Some() unwrapping it doesn't produce a panic.

  As I'm not that experienced with rust, I now am unsure if my approach is really safe or if I'm overlooking something.

  I know, that this post is unusually long and I want to thank all that made it that far, for reading it.

  submitted by /u/Large_Difficulty_891
  [link] [comments]
• Saving my old university project with Rust

  Hello Rustaceans!

  Jon Gjengset's livestreams have and continue to be a great inspiration for me.

  Inspired by "impl Rust", I am now doing a little video series where I port my old (shitty) emulator (written in Python) to Rust.

  Some context:

  As part of a university course with FPGAs, my group created a custom processor in VHDL and invented our own assembly language.

  To speed up development, not having to upload code to the FPGA all the time, I coded an emulator in Python, but looking back at it now, it's soo inefficient (using regex every. single. render. frame. 💀).

  The goal is to rewrite that emulator in Rust AND have it run in WASM context for browser viewing.

  In this first video, I explore how to parse our custom assembly language, eventually settling on pest.

  Rest assured, this series will contain ZERO usage of LLM/AI/vibe-slop. The focus is NOT to move fast, but to have fun and explore.

  I hope you like it!

  https://youtu.be/jc1ZMBn_G7M

  submitted by /u/Sermuns
  [link] [comments]
• Want to start a framework to make portable apps with wasm/wasmtime and wgpu

  I’m new in learning rust and wasm and i want to start a new project to make a framework/library “similar” to Flutter or React but using wasm/wasmtime and wgpu as backend for rendering a portable/multiplatform app but i know nothing about frameworks architecture or where to start. I need your help guys to find books, text, courses or any material to start this personal project. Tank u.

  submitted by /u/Objective-Diver-2887
  [link] [comments]
• Adding WASM Plugins to Your App - Using Wasmi as a runtime and Zola as an example.

  Hello everyone,

  This is something I have been thinking about for a while: a simple get started guide to extend your binary with wasm-plugins.

  submitted by /u/M1M1R0N
  [link] [comments]
• Rust Clippy announces that it will require age verification software for users residing in California
  submitted by /u/NothusID
  [link] [comments]
• Egui: How to get windows position.

  First of all i am new to rust,

  So apparantly i was making this widget with eframe and i had to set decorations off for the widget look (no icon on taskbar, no title bar, etc). and it backfired on me by not remembering where the window was closed lastly, and it opens on a particular location all the time.

  what i need is a way to get windows current position on the screen.

  submitted by /u/Firefly_SL
  [link] [comments]
• Does everybody really use pin-project or do you just use unsafe?

  It's so cumbersome.

  fn project_pin<'a,C,F>(Pin<&'a C>, fn(&'a C)->&'a F) -> Pin<&'a F>

  would be so much simpler and safe enough.

  submitted by /u/mtimmermans
  [link] [comments]
• autoschematic v0.14.8: manage infrastructure as code with Rust or Python plugins

  Auto-import existing infra with `autoschematic import`, plan changes, compare your code with the live state, and apply to modify or provision new infra.

  Includes language server and editor tooling.

  Homepage & docs:

  https://autoschematic.sh

  Github:

  https://github.com/autoschematic-sh/autoschematic

  submitted by /u/pfnsec
  [link] [comments]
• Interactive blog post: Low energy transfers - getting to the Moon using Lagrange points! Numerical simulations in Rust

  I made this a while ago but never shared it before. Figured some of you might find this interesting.

  This is based on a presentation that I gave a while ago and then re-adapted into the current format. Full source code for the simulations and animations is available here: https://github.com/lukechu10/interplanetary-transport-network

  Simulations were written in Rust and animations were created in Python using the great Manim library!

  The website itself is also written in Rust using the Sycamore web framework (disclaimer: I am the maintainer of Sycamore).

  submitted by /u/lukewchu
  [link] [comments]
• Rust on Windows: random crashes turned out to be the default stack size

  Today, I encountered interesting detail when developing cross-platform program ( GitComet ) written fully in Rust.

  Most development happened on Linux, and the app worked fine there. But after using the Windows build for a while, I started seeing what looked like random crashes.

  Stackoverflow exception program exit, panic handlers dont run, no stacktrace.

  In debug mode on Windows, the crashes became much easier to reproduce.

  Increasing the Windows linker stack size to 8Mb fixed the issue:
  Reference: https://github.com/Auto-Explore/GitComet/pull/99/changes#diff-519337722c958a057bccc24eada91aeccfc76cd22e0aab01a18a6529a007b8d6

  I thought this was interesting learning experiment and wanted to share it with you guys

  submitted by /u/Havunenreddit
  [link] [comments]
• vk-video 0.3.0: a bag of new features

  Hello,

  Don't really know if many people are interested in this, but the posts seem to get a decent number of upvotes, so...

  I'm very glad to announce the release of vk-video version 0.3! vk-video is a library for hardware-accelerated video decoding and encoding that integrates with wgpu. This release is meant to add all features we wanted to work on before turning to codec support. As such, there are a few quality of life improvements and a some new things:

  • One-to-many zerocopy transcoders, including a few interpolation methods for changing the video resolution (all running on the GPU, of course). These transcoders allow you to e.g. provide a 4k video and produce videos in 480p, 720p and 1080p (or any resolution combinations), and all of it will be calculated close to optimally.
  • Built-in color converters, for easy conversion from YCbCr (the colorspace that is used for storing videos) to RGBA and from RGBA to YCbCr, also implemented as shaders. The converters make it even simpler to dump decoded video straight to a wgpu pipeline, or to put the result of a rendering pipeline into an encoder to save the rendered content as a video.
  • A new, more advanced method of driving the decoder for scenarios where lower-level latency control is necessary.
  • Due to popular demand (one person on reddit), wgpu is an optional dependency now, which can save quite a lot of compilation time when you don't need the integration.
  • Updated wgpu to the newly released version 29.

  As for future plans, we're actively working on the H.265 (HEVC) encoder. I hope for it to be merged and released in april if things go smooth, but contact with the eldritch horror that is the H.265 spec is causing me to become less and less sane every day of development, so the release date can change, I guess.

  After that, I want to work on an H.265 decoder, which will be much harder. I expect it to take a lot more time. Writing a decoder is fundamentally more difficult than an encoder. While it is fine for the encoder to just ignore features of a codec that are not useful/rarely used (since the only thing that matters is for it to produce spec-compliant output), a decoder should be able to process any bitstream you throw at it (including ones that use the more cursed parts of the spec).

  Thanks for reading this post and I hope you find the things we work on useful for something!

  I also wanted to shout out noituri, the other developer working on this library. It's a lot of fun to work on this with you!

  submitted by /u/xXx_J_E_R_Z_Y_xXx
  [link] [comments]
• SparrowDB: embedded Cypher-native graph database in Rust

  Built this because every graph database assumes you want to run a server. Neo4j needs a JVM. DGraph needs a cluster. If you want to query connected data inside an application, the embedded option didn't exist for graphs.

  PyO3 bindings release the GIL on every call. napi-rs for Node.js, Magnus for Ruby. All three open the same WAL-durable on-disk format. XChaCha20-Poly1305 at-rest encryption, SWMR concurrency, external merge sort for large ORDER BY, per-query timeout cancellation without killing the process.

  Benchmarks against Neo4j 5.x (SNAP Facebook dataset, 4k nodes, 88k edges):

  - Point lookup: 133µs vs 321µs (2.4x faster)

  - Top-10 degree: 441µs vs 17,588µs (40x faster, pre-computed cache)

  - 1-hop traversal: 76x slower

  - Mutual friends: 476x slower

  The traversal gap is structural. Single-threaded execution, not exploiting CSR layout for in-memory walks. It's in the README. It's the thing I'm working on.

  submitted by /u/Ryaker
  [link] [comments]
• Build error with oqs-sys
  submitted by /u/Odd-Flow2646
  [link] [comments]
• Current state of Rust writing CUDA kernel?

  What's the current state of CUDA support in Rust? There's Burn-rs prevailing but it's more like a high-level framework. In most time I find it hard to completely switch to Rust in my projects, but much more feasible to adopt some Rust implementations of low-level functions, like CUDA kernels, and call them with PyTorch. Rust CUDA seems to be for this purpose, but its latest release is still in 2022, and it seems lack of inter-ops with PyTorch.

  submitted by /u/dest1n1s
  [link] [comments]
• thinking about writing a detailed rust contribution walkthrough

  whats up everyone

  been diving deep into rust internals lately and wondering if anyone would be interested in a super detailed writeup about getting started with contributing to the language itself

  basically i was thinking of grabbing some random issue from the repo and documenting the entire process from start to finish - like how i approach the problem, where i get completely lost, what resources i dig through when im stuck, and eventually how i stumble my way to a solution. all the messy trial and error stuff that usually gets cleaned up before anyone sees it

  ive been spending way too much time on this stuff recently and figured it might help other people who want to jump in but dont know where to start. the whole process can be pretty intimidating at first

  would that kind of thing be useful or am i overthinking it? seems like there might be more people interested in contributing but just need to see the actual workflow mapped out step by step

  also been working on some language features recently and its wild how much you learn about rust just by trying to break it in new and creative ways. definitely recommend it if youve got the time to burn

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

r/golang

• How much of your Go work actually touches the OS layer, signals, TCP, file systems?

  Most Go content lives comfortably in the application zone, HTTP handlers, REST APIs, goroutine patterns. Useful stuff, well covered. But there's a whole layer underneath that gets much less attention: handling UNIX signals correctly in a long-running daemon, building TCP/IP services from scratch, working directly with file systems, writing lexers and parsers, processing time-series data at scale. The kind of work that shows up when you're building infrastructure tooling, monitoring agents, or anything that has to sit close to the OS.

  Curious how many Go developers here actually work at this layer regularly — and where the gaps are.

  1. What systems-level Go topic has taken you the longest to figure out?

  2. When the standard library docs aren't enough, where do you go?

  3. Is there learning material for this layer you wish existed?

  I am from Packt and we publish technical books and we're asking partly because we just released Practical Systems Programming in Go by Mihalis Tsoukalos, which covers exactly this territory. But the questions are genuine and we'd love to hear where people actually feel under-equipped.How much of your Go work actually touches the OS layer, signals, TCP, file systems?

  submitted by /u/Legitimate_Manner870
  [link] [comments]
• Go tests and Gtk

  Is it possible to use Go's testing capability to write unit tests for graphical gtk applications? I use gotk3 and gotk4 packages and I haven't seen much information about testing online.

  Is it possible? How is it done?

  submitted by /u/DontFreeMe
  [link] [comments]
• Natural language deterministic automation runner (agent)

  I've been writing Atkins, a CI/automation runner that you can run locally. Since it is april first and a little bit of whimsy is welcome, I added a rudimentary agentic interface where you can run skills, jobs, or shell commands and create aliases for your pipelines.

  After starting "atkins --agent" an agentic interface to the defined CI/CD pipelines is available. It seems a bit much but `gimme go test` will find a 'go:test' pipeline and invoke it. It gives rudimentary deterministic tool invocation. Atkins skills can be discovered from the local filesystem, extending the matching to the available environment.

  https://github.com/titpetric/atkins/tree/main/agent

  The code is not a pretty sight for an initial version of the agent, mostly impacting display and prompt edge cases with some whitespace issues or incorrect resolution to the default CI task (rather than an IDK). You can use this gh issue for feedback or leave a comment here on reddit.

  The attached diagram shows how prompt input is processed. The REPL responds to greeting, thanks, and "give me a fortune" (invokes fortune from env if you have it, ideally the BOFH collection).

  Edit: this is as of yet unreleased / untagged, use '@main' with go install for the repository to evaluate if you want to play with the newly added --agent flag.

  submitted by /u/titpetric
  [link] [comments]
• xem.go – an open-source Go backend for email campaign management (campaigns, automation, multi-SMTP, webhooks)

  Hey r/golang 👋

  I've been building xem.go — an open-source Go backend service for email campaign management. It's the engine behind Xem, and I wanted to share it here since it has some Go patterns that might be interesting to the community.

  What it does:
  - 📧 Campaign & template management with scheduling and automation workflows
  - 🔐 JWT auth (24h access / 7d refresh) + Google OAuth via Firebase + role-based permissions with wildcard support (e.g. `campaigns:*`)
  - 📬 Multi-SMTP provider support with per-provider send rate control
  - 🌐 Domain verification + DNS record management
  - 🪝 Webhooks with event triggers and delivery tracking
  - 👥 Multi-team support with invite flows
  - 📊 Analytics + contact import/export with tagging

  Some Go-specific bits I enjoyed building:

  The event bus uses a simple pub/sub pattern with panic recovery so a failing handler won't crash other subscribers:

  events.On("email.sent", func(data interface{}) {
// handle event
})
events.Emit("email.sent", emailData)

  The permission system is resource-scoped and role-seeded at startup — no manual DB migrations needed for adding new roles.

  Stack: Go 1.21+, PostgreSQL 14+, Redis, Docker, optional Kubernetes manifests (Terraform too)

  🔗 https://github.com/mailxem/xem.go

  Would love feedback on the event bus design or the permission system architecture — always looking to make it more idiomatic Go. ⭐ if you find it useful!

  submitted by /u/Modders_Arena
  [link] [comments]
• A series of articles about Clean Architecture in go
  submitted by /u/TheBusBoy12369
  [link] [comments]
• I couldn't compare storage topologies without forking 3 codebases, so I built this

  Just posted on HN. Built a distributed file system in Go where the storage topology is a swappable interface.

  Hyperconverged is working today. GFS-style disaggregated is next. The goal is to benchmark both under identical workloads without touching separate codebases.

  HN thread: https://news.ycombinator.com/item?id=47600639

  GitHub: https://github.com/AnishMulay/sandstore

  submitted by /u/Friendly-Curve-3454
  [link] [comments]
• Who's Hiring

  This is a monthly recurring post. Clicking the flair will allow you to see all previous posts.

  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.
  • Meta-discussion should be reserved for the distinguished mod comment.

  Rules for employers:

  • To make a top-level comment you must be hiring directly, or a focused third party recruiter with specific jobs with named companies in hand. No recruiter fishing for contacts please.
  • The job must be currently open. It is permitted to post in multiple months if the position is still open, especially if you posted towards the end of the previous month.
  • The job must involve working with Go on a regular basis, even if not 100% of the time.
  • 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.
  • Please base your comment on the following template:

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

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

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

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

  ESTIMATED COMPENSATION: [Please attempt to provide at least a rough expectation of wages/salary.If you can't state a number for compensation, omit this field. Do not just say "competitive". Everyone says their compensation is "competitive".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 expected to be offset by other benefits, then please include that information here as well.]

  REMOTE: [Do you offer the option of working remotely? If so, do you require employees to live in certain areas or time zones?]

  VISA: [Does your company sponsor visas?]

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

  submitted by /u/jerf
  [link] [comments]
• New Go Library for creating language servers

  Not the first library out there for streamlining language server development, but I'm pretty pleased with it. Its interface based so you just use the interfaces you want for the capabilities you want to support. The killer!?! feature, and reason I rolled my own, is the debug UI so you can see the traffic going back and forward to help debug. Any comments/suggestions/criticism(I guess) is welcome! submitted by /u/rumbo0 [link] [comments]

• Chose 3 elements from a slice inside a range randomly

  Hello guys I am building a cards game. I made a slice with the 78 cards the game has.

  And I'm creating a funtion to deal the cards and create the hand, and the way the game works is that the cards have to be distributed 3 cards each player for 5 turns. That's the national rules.

  I created 5 txt files to simulate the players easier to debug in individual files than having 75 cards printed out in the terminal. And so I have a list with those files names and I wanted to write a function that puts 3 cards per each player on their deck.

  And so I thought about creating 5 different arrays and build them until reaching 15 cards and at the end distribute them trhought the 5 players by just writting them or appending them to the files. But I'm having troubles to do that, I'm a bit confused on how to do so. And also those cards have to be random not just the first 3 elements everytime, and the cards can't be cloned.

  func DealCards(Cards []models.Card, Players []string) { Cards = models.NewDeck() Players = GeneratePlayers() for _, hand := range Cards { } } 

  So this is the function to deal the cards and the hand would basically be the cards of each player.

  func GeneratePlayers() []string { playersList := []string{ "player1.txt", "player2.txt", "player3.txt", "player4.txt", "player5.txt", } for _, p := range playersList { file, err := os.OpenFile(p, os.O_APPEND|os.O_CREATE, 0666) if err != nil { log.Fatal(err) } file.Close() } return playersList } 

  This is the function to generate players and it has the list of players that is no more than the file names. And I think that's all.

  THank you guys for the help, I'm heading to physics class, but if I wasn't clear enough about the goals please let me know and uhm I guess that's it.

  I know it probably isn't very easy what i'm asking to you, but big thanks to whoever can help me because I'm genuinly stuck on this function and it's the start at of the game.

  submitted by /u/brocamoLOL
  [link] [comments]
• What are historical reasons for multiple return values instead of tuples?

  I'm interested in quesiton why Go language does not have native tuple type from its beginning. I don't want to discuss community conjectures that structures are more readable and etc. It could be cool to explore it from historical perspective, with some language contributors' / developers' GitHub comments, notes, emails or explanations.

  I see that multiple return values were mentioned in Go snapshots from 2010. But... I do not understand the reason, why they are better than tuples. My supposition is that multiple return values were workaround in period of missing generics in language, just in order to pass errors only. But I want some evidences :)

  UPD. I asked about some references to developers discussions, comments, RFCs, messages (like this in case of Python and Guido Van Rossum), because when I was searching, I didn't find any. But found others. I didn't ask for community opinion on whether something is more suitable for language, more convenient, your IMHO. I asked about artifacts. But majority of Go Reddit community doesn't understand it.

  submitted by /u/m0t9_
  [link] [comments]
• COMMAND.COM in Go

  When you want to bring the best OS Microsoft ever made to a bunch of Unix-like platforms, Go makes it pretty damn easy. Plus making a parser - even one this weird - is a cinch in Go.

  Anyway, if you ever wish you could experience DOS on a real operating system, this has you covered.

  https://codeberg.org/lyda/command-com

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

r/rust_gamedev

• How not to map bones from blender

  I was scrolling through my phone looking through progress updates for my 3d mobile game client and found these old images I had saved when I was implementing animations and thought it would be cool showing off these ABOMINATIONS. One looks strait out of a horror film with its long sharp fingers. anyways, these were born out of bad mapping of the bones to the blender model causing the default pose to look like this >_> If your wondering why they are yellow the default human models I purchased off the blender store didn't come with a texture so I found some free model of a duck and used its texture submitted by /u/Patient_Confection25 [link] [comments]