𝕷𝖔ï𝖈 🎮✨

卧槽，这个厉害了啊，真是万物皆可HTML HeyGen开源了HyperFrames框架，可以通过Claude Code 构建视频。 开源、代理原生框架。HTML 到 MP4。 如何安装👇 npx skills add heygen-com/hyperframes

Zelda Phantom Hourglass Collisions Visualized

Graphics Programming Conference 2025 presentation recordings are now online: youtube.com/watch?v=iRVLKi…

😮😮😮😮😮

Built an online MSDF Font Generator! Generate your MSDF font data (bitmap font + atlas texture) out of your ttf/otf files with full control over resolution and precision. Preview your text mesh in a WebGL scene to make sure every glyph is perfectly sharp.

The Claude C Compiler is the first AI-generated compiler that builds complex C code, built by @AnthropicAI. Reactions ranged from dismissal as "AI nonsense" to "SW is over": both takes miss the point. As a compiler🐉 expert and experienced SW leader, I see a lot to learn: 👇

The Adolescence of Technology: an essay on the risks posed by powerful AI to national security, economies and democracy—and how we can defend against them: darioamodei.com/essay/the-adol…

From the hundreds of books in game programming I read, these are still *the* best. “Game Coding Complete” especially. It’s incredibly practical and has taught me so much, I still use many concepts/patterns from it to this day.

I just released my video about the engine (and game) I've been working on. The engine is based on dynamic SDFs, and the video describes how it works and what it makes possible. Link in the reply! This is my first YouTube video and it took forever - please repost!

Yet another amazing #opensource project by @selimanac - a beautiful water shader for #Defold! 💙🌊

Why the character movement in my custom game engine felt janky and how I fixed it. In a game engine, most often, a character moves using the physics engine. Meaning, the player is not just a coordinate in space but a physical body. It has velocity, it handles collisions, and it interacts with the world. Now, as you might know, physics engines need stability. If you run them at variable framerates, things start breaking. Objects phase through walls or fly off into space because the math becomes unpredictable. This is why most game engines lock their physics loop to a 60Hz fixed rate. But here’s the problem: If you have a high-end system, you don't want to limit it at 60 FPS. That's a waste of good hardware. Now, that said, if the GPU is rendering at 144 FPS but the player's position (physics driven) only updates 60 times a second, it creates a micro-stutter that ruins the "smooth" feel of the game. A good way to fix this is to treat the character as two separate things: 1. The Physics Body (Invisible part): This is the "real" character. It lives in the 60Hz physics world, it moves the player and handles collisions. 2. The Visual Model and Camera (Visible part): This is what the player actually sees. It doesn't care about collisions, its only job is to look nice and smooth at whatever framerate the GPU is pushing. Once you have this separation, you can use interpolation to keep them in sync. Every time the physics clock ticks, you save the previous position of the invisible body before moving it to the new one. Between those ticks, calculate how far we are between the last physics update and the next one. By using this to drive the visible parts of the game, the stutters disappear. The physics loop stays fixed behind the scenes, while the visuals slide smoothly between the snapshots. Example: - Right after a tick: blend_weight= 0.0 (The visual model stays at the old physics position). - Halfway to the next: blend_weight= 0.5 (The visual model slides to the middle point). - Just before the next: blend_weight= 0.9 (The visual model is almost at the new physics position). Pro-Tip A critical mistake I made initially, and one many devs make, is parenting the camera and visible parts directly to the player body. If you do this, the camera inherits the discrete 60Hz physics movement by default. In that setup, interpolation won't work because the camera is "stuck" to the physics clock. For this fix to work you must decouple the camera and visuals from the body and move them separately. Player movement processing in Detis Engine: - fixed_process: Physics runs at 60Hz. Handles collisions and raw movement. - process: Variable rate. Mainly used for player input caching in the player case. - late_process: Variable rate. Handles interpolated camera movement after physics and everything else is done being processed. - render. Submits the final interpolated transforms to the GPU. The test environment in the video is running on an old 2070-based laptop. Hopefully the video compression won't introduce any stutter... I’m sharing this in hopes it helps a fellow dev. Cheers.

I have to add my voice to the chorus: there is nothing more insulting, disempowering, or a surer sign that you’re working with hacks (& there are many, wedged into middle management in AAA) than receiving an AI moodboard as a concept artist, and I need to talk about it

some debug for walking the boulder. big red arrow is user input, big white arrow is the force i'm applying to the boulder, black circle is where i want emmer to walk toward, and the series of smaller arrows are lower level controller stuff (cyan is just terrain normal, black is direction she should face, magenta is velocity, and the positions are the target positions stretched out 1 second into the future).

this is why I love gamedev btw no other industry you hear stories like this

Advanced usage of the Bake Animation Texture system: all geometries are batch-rendered in a single draw call using IndirectBatchedMesh, animated in the GPU, while still benefiting from culling via indirect draws and compute shaders. All code will be available in the examples!

s&box is now open source — we're pleased to share our .NET 10 game engine source under the MIT license. Our goal with the play fund, royalty free game exporting and open source are all about giving back to the community so everyone wins. 👉github.com/Facepunch/sbox…

People are definitely starting to see the value in GPU-side hash tables for graphics: interplayoflight.wordpress.com/2025/11/23/spa…

So managed to find this INSANE 1-LINE hack for shadow mapping that almost eliminates the need for bias and solves Peter Panning completely. This is with contact shadows off and a very small "0.0005" bias to avoid acne. Idea from Avelina9X on Reddit. reddit.com/r/GraphicsProg…

Sharing an interesting recent conversation on AI's impact on the economy. AI has been compared to various historical precedents: electricity, industrial revolution, etc., I think the strongest analogy is that of AI as a new computing paradigm (Software 2.0) because both are fundamentally about the automation of digital information processing. If you were to forecast the impact of computing on the job market in ~1980s, the most predictive feature of a task/job you'd look at is to what extent the algorithm of it is fixed, i.e. are you just mechanically transforming information according to rote, easy to specify rules (e.g. typing, bookkeeping, human calculators, etc.)? Back then, this was the class of programs that the computing capability of that era allowed us to write (by hand, manually). With AI now, we are able to write new programs that we could never hope to write by hand before. We do it by specifying objectives (e.g. classification accuracy, reward functions), and we search the program space via gradient descent to find neural networks that work well against that objective. This is my Software 2.0 blog post from a while ago. In this new programming paradigm then, the new most predictive feature to look at is verifiability. If a task/job is verifiable, then it is optimizable directly or via reinforcement learning, and a neural net can be trained to work extremely well. It's about to what extent an AI can "practice" something. The environment has to be resettable (you can start a new attempt), efficient (a lot attempts can be made), and rewardable (there is some automated process to reward any specific attempt that was made). The more a task/job is verifiable, the more amenable it is to automation in the new programming paradigm. If it is not verifiable, it has to fall out from neural net magic of generalization fingers crossed, or via weaker means like imitation. This is what's driving the "jagged" frontier of progress in LLMs. Tasks that are verifiable progress rapidly, including possibly beyond the ability of top experts (e.g. math, code, amount of time spent watching videos, anything that looks like puzzles with correct answers), while many others lag by comparison (creative, strategic, tasks that combine real-world knowledge, state, context and common sense). Software 1.0 easily automates what you can specify. Software 2.0 easily automates what you can verify.

did you know: i have a page on my website breaking down a bunch of the shader techniques that i use almost daily