kkukshtel's comments

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

sounds awesome but too bad it is impossible to figure out how to actually use these models and what I have to pay for/where

You've needed to have a project file in the past to compile .cs files, and this gets rid of that need. There are things that are part of more esoteric corners of Roslyn like .csx files that have allowed similar behavior in the past, but this fronts .cs directly as a scripting solution.

Scraping main() has been a thing for a while in dotnet — so called "Top-level programs" have be in since C# 9/.NET 5, aka about 5 years ago.

https://learn.microsoft.com/en-us/dotnet/csharp/fundamentals...