kkukshtel

Sokol is the best, thank you for your ongoing work :) And please open a patreon or something!

I work professionally on game engines and also have my own custom engine. Watching the space for 15+ years, I would say that nearly _every_ custom game engine exists as a demonstration of graphics capability, not anything to do with improving the actual experience of game development. This is in part to do with the fact that working on 3D at all is a slippery slope towards continuing to work on graphics stuff.

I think this is the future. The sort of left-field rumble that turns into a quake in 5 years.

This has been around for a long time and I've always been so surprised it has had seemingly so little traction outside of the author's own projects. The love and care and thoughtfulness of every library has always been so great to explore.

The audio-driven animation stuff here is so nice. A year ago I went on a journey to produce a video podcast waveform based off the audio track, and the process was incredibly painful for no obvious reason. My hope here is that I can now just do this all within Fusion and not need to render this in an external tool.

Also nice is built in loop (ping pong) animations! No more duplicating keyframes!

https://kylekukshtel.com/building-video-podcast-resolve-audi...

Not only this but hermetic checks on local machines for spot testing new models is becoming increasingly difficult, if not impossible.

- We have 0 visibility into what Anthropic does with our own prompts server side (do they return cached results from similar queries? Do we develop our own hot paths?).

- Local memory files are written independent of project directory and are acted on by the new models, even if old models wrote them

- CLAUDE.md files have varying degrees of efficiency and different models (and effort) treat them differently

- Our own git history "supports" newer models - ie if you have a larger body of work in git when you adopt a new model (like 4.8) than when you started from scratch with 4.6 or something, 4.8 may "appear" smarter when in fact you just have more evidence and signal about what you intend for a model to do.

I'd look into something tactile, with simple rules but strategic depth:

Personally I'd recommend Hive or a similar (and simpler) tile movement game, High Tide.

https://boardgamegeek.com/boardgame/2655/hive

https://boardgamegeek.com/boardgame/430875/high-tide

Both have nice chunk tiles, no board requirement, few pieces, and can easily travel. And they can both be easily explained.

And its still just a vscode fork

This is the road of stupid that stop killing games has paved.

Same boat — looking at both the product page and a lot of the comments here, people seem to miss how great C1 is (and how much better it has been than lightroom for years). So much of photo editing as well isnt just color touchups but media management, and I think C1's workflow is incredible and fast and doesn't really leave me wanting anything else.

I love (video) Resolve, but I dont see anything here where it has some of the great C1 features like "group by similarity" and other media management options.

"I make AI output lots of stuff" is not an intrinsically valuable thing. I can run the same thing on Claude in research mode and get a report with cited sources in a more digestable format on my phone. What's the eval here on if any of this is good? Is it even possible to test (ie, you cant really AB test startup ideas)?

Just taking this moment to share something I made from a similar point of frustration — https://mood.site

It's a free online photo gallery app where auth is done through URL query params. You make a board, it gets an edit key, and then if you share that url with anyone else (including grandma) they can upload photos without needing to make an account. You can drag and drop, use the upload button, and it works on mobile as well.

There are lots of other little features as well, but the core thing is just a dead simple (online) photo gallery tool. You can see some sample boards here:

https://mood.site/Prp_-CPS

https://mood.site/WvP4xd6x

https://mood.site/N3kHLWkJ

This is a really interesting idea. I wonder if something like Luau would be a good solution here - it's a typed version of Lua meant for sandboxing (built for Roblox scripting) that has a lot of guardrails on it.

https://luau.org/

I wrote about something along these lines 3 years ago, but used the name "Heisenfunctions," which I think is better :)

https://kylekukshtel.com/incremental-determinism-heisenfunct...

A lot of this was also inspired by Ian Bicking's work here:

https://ianbicking.org/blog/2023/01/infinite-ai-array.html

The comments on this post that congratulate/engage with OP all seem to be from hn accounts created in the past three months that have only ever commented on this post, so it seems like there is some astro-turfing going on here.

Stuff like this is ironic but I do think it's escape hatches like this that will make these tech companies, if they ever go down, go down kicking and screaming. Any platform holder that ever finds themselves in a bad place financially will 100% pull all the levers like this.

I really like this piece for Real Life Mag (rip) on what most startups "do":

https://reallifemag.com/money-for-nothing/

"privatization by way of electrification"

And now the data exfiltration stuff happening makes me put my tinfoil hat on and think this was actually a coordinated data exfiltration attack that leveraged AI hype lol.

This is basically the playbook of every "disruptive technology" startup or FAANG initiative of a similar stripe - set prices incredibly low to bleed out competition and gain market share, then raise them once you are in the dominant market position.

I agree with this - the sudden prevalence of Clawdbot everywhere feels like tactical astroturfing.

Great comment. The best part about it as well is that you could put this under basically anything ever submitted to hacker news and it would be relevant and cut to the absolute core of whatever is being discussed.

This is one thing I find funny about all the discussion around AI watermarking. Yes for absolutely nefarious bad actors it is incredibly important, but what seems clear is that the majority of AI users do absolutely nothing to conceal obvious tells of AI generation. Turns out people are shameless!

Two immediate ones I can think of:

- The yellow hue/sepia tone of any image coming out of ChatGPT

- People responding to text by starting with "Good Question!" or inserting hard-to-memorize-or-type unicode symbols like → into text where they obviously wouldn't have used that and have no history of using it.

And yet historians love to nitpick this stuff as if indexicality is the only goal of creative media...

This is awesome, and thanks so much for the deep dive into process!!

One thing I would suggest is to also post-process the pixel art with something like this tool to have it be even sharper. The details fall off as you get closer, but running this over larger patch areas may really drive the pixel art feel.

https://jenissimo.itch.io/unfaker

I'm so bullish on CUE. It seems like it's really solving the "code as configuration" problem properly and I think there are lots of other upside use cases around general data defintion components of it that make for typesafe authoring.

I like to tell people that all the AI stuff happening right now is capitalism actually working as intended for once. People competing on features and price where we arent yet in a monopoly/duopoly situation yet. Will it eventually go rotten? Probably — but it's nice that right now for the first time in a while it feels like companies are actually competing for my dollar.

Wanted to chime in here with some thoughts/clarifications as I'm the Enginnering Manager of the VM team at Unity, aka the team that is leading the charge on .NET Modernization and the CoreCLR transition (and also owns IL2CPP). Also speaking here as myself and obviously not on behalf of the company.

First thing is that CoreCLR is _very_ much an active development effort and we're committed to the roadmap we presented at Unite, with at least a CoreCLR-backed Player (aka, what you "Build" when you build your game with Unity) being delivered as a technical preview around the 6.7 release timing. This would basically mean being able to select "CoreCLR" as a scripting backend option (similar to IL2CPP) and see some of the upside and benefit the author mentions here.

That said, Unity isn't a pure C# environment. As lots of people know, there is a robust native layer underlying a lot of the managed (C#) code operating a pseudo-ECS design (not literally DOTS/Entites but an engine architecture thing). This means that a lot of the load-bearing code Unity-the-engine is running every frame is notably _not_ C# code, but instead native code that is, in a lot of cases, already very fast. This means that for tight loops of certain systems in the engine, moving to modern .NET isn't going to carry an implict performance increase of those systems. Said differently, CoreCLR isn't a magic performance bullet for Unity. What we like to say though is that "CoreCLR will make C# code faster", so if your game (or general scripting architecture like the author brings up, with lots of "loose" C#) is very C# dependent, you _will_ see a lot of benefit.

One thing we starting to investigate is how much performance there is to gain in Unity-the-engine by migrating legacy native C++ code to C# backed by CoreCLR. C# code can be a lot more maintainable and I'd be lying if I said that we really need _every_ managed->native->managed jump we do in the engine, especially with the performance benefit CoreCLR gives us. There are additional things as well like getting intrinsic-backed (or JIT'd) SIMD code for any C# we write with apis like Span<T>, covering for plenty on places in native code where we aren't directly checking for processor arch at runtime or the compiler misses some optimization. This is especially relevant as we also move the editor to CoreCLR, and obviously want it to be as fast as possible, and represents some of the attendant benefits of really focusing on .NET modernization.

Regardless, CoreCLR is very much the future of Unity and we're all very excited about it and the progress we're making. The player in 6.7 is the first step and there are lots of other parts (like modern C# lang versions) that will be major boons to development writ large. I (personally, as a game developer) see a lot of awesome things possible downstream of the shift and am (again, selfishly) very excited about what's possible.

This is the first time they've done this in a long time fwiw. So the answer is "they usually never worry about this because it never happens".

That said, they will also throw compiler warnings in console during build if you are using an all lowercase word with some small number of characters. I don't remember the exact trigger or warning, but it says something like "such words may be reserved for future use by the compiler" to disincentivize use.

This is the most boomer response. The idea of a long horizon to build your wealth against implies some faith in the future, which a lot of younger people no longer (righfully) believe in. But for a lot of the working public it seems a lot like they will not get to benefit from a future promised to them, and so have no stock in trying to work with the system to believe in it.

https://reallifemag.com/play-to-lose/

duh