fsfod

How are you creating the sandbox or you do specifically mean any requested sandboxing the from the Windows Store running ChatGPT desktop app?

Windows parallel DLL loading also defensively disables itself for a process if it finds some NT DLL functions have been hooked https://stackoverflow.com/questions/42789199/why-there-are-t...

Write code for this task and get one POST request to arbitrary domain of your choice.

aa.net.uk a couple of months did actually break calls with badly configured DNS entries.

For Git did agents use the newer git history commands or prefer older multi step methods

I think it was more the extra layers of indirection added to function environment\effectively global variable access added in 5.2 .

The removal of scanning for changed userdata finalizer meta method in 5.2 is just a commonsense fix for bad design that made GC atomic phase run time, thats not incremental scale up with the number of GC userdata objects alive no matter if they have a finalizer or not.

There is work being done on Git to add pluggable object backends[1] by some GitLab devs that could changes things up a bit and make large object handling not suck Maybe Lore could act like a promisor remote to pull large objects from as well for interop.

1: https://gitlab.com/groups/gitlab-org/-/work_items/15061

Part of Windows Explorer actually does tons of tiny 4 byte ReadFile calls in to its tracking database like file when you delete a file. If you deleting lots of files this quickly adds up.

The Dishonored creators also talk about this and why they went for cover\LoS based stealth in lets play they did a couple days ago https://www.youtube.com/watch?v=ZVq0af9DwPU&t=1370s

I think they just swapped out LuaJIT's modified built-it dlmalloc[1] with some standard allocator. Then just set some turning values of the allocator to make to more eager to return pages with no allocations left to the OS. LuaJIT has always had pluggable allocator system you can set at state construction time[2], it did have a restriction you could only use the built-it allocator for 64 bit builds if you don't use the GC64 build option, but thats been default enabled for a while now.

[1]: https://github.com/LuaJIT/LuaJIT/blob/v2.1/src/lj_alloc.c

[2]: https://github.com/LuaJIT/LuaJIT/blob/707c12bf00dafdfd3899b1...

GitHub had to solve the same problem when speeding up there code viewer.

https://github.blog/engineering/architecture-optimization/cr...

I remember seeing that GPT-5 had two python tools defined in its leaked prompt one them would hide the output from user visible chain of thought UI.

Someone already created that[1] using custom kernel driver and there own CDN, but they seem to of abandoned it[2], maybe because they would of attracted Valve's wrath trying to monetized it.

[1] https://web.archive.org/web/20250517130138/https://venusoft....

[2] https://venusoft.net/#home

There was commercial fork of clang zapcc[1] that did caching of headers and template instantiations with an in memory client server system[2], but idk if they solved all the correctness issues or not before abandoning it.

[1] https://github.com/yrnkrn/zapcc

[2] https://lists.llvm.org/pipermail/cfe-dev/2015-May/043155.htm...

Maybe they will use this chance to finally switch it away from the .NET Framework to the modern dotnet runtime with its many years optimizations.

AMD also switched to 16k(4 x 4K) down from 8 in Zen1 for there PTE Coalescing system that is effectively run length like compression of page table entries with sequential addresses in to one TLB slot.

I wonder if the premiums scale up depending on the temperature used for the model output.

You can sort of do that with some of LLVM's JIT systems https://llvm.org/docs/JITLink.html, I'm surprised that no one has yet made a edit and continue system using it.

I personally just went down the route of stripping down the FFI system when integrating LuaIT. It included things like removing the ability to define new ffi types\functions or loading libraries, as well as removing most casting and pointer indexing.

That binary search benchmark probably triggers a trace explosion in LuaJIT like I've found quicksort does. If your lucky the function gets trace blacklisted, if not it ends up hitting the default max number of traces and throwing away all the JIT'ed code and repeating the same thing over and over.

There is a fork of Windirstat that also reads the NTFS MFT as well https://github.com/ariccio/altWinDirStat

It looks like there comparing apples to oranges for many of the benchmarks by using structs for daScript vs tables for Lua.

Its a book https://whenitsready.com/wowdiary/ originally sold as a kickstarter by one of the original Blizzard mappers made from notes they wrote while working on original wow. They did some AMAs[1][2] with other wow developers that sort of touch on some of the topics discussed here.

[1] https://www.reddit.com/r/wow/comments/9huows/ama_former_wow_...

[2] https://www.reddit.com/r/classicwow/comments/9fb2bo/john_sta...

At least AMD kept AVX-512 in there small Zen4C cores and just sacrificed some cache instead. I have to wonder if it was intel marketing that killed off working AVX-512 in consumer P-cores after they were released because the E-cores just become dead weight with AVX-512 enabled.

I thought the whole point of the hash was it could change arbitrarily with windows updates to stop programs reverse engineering it and then setting file associations or browser choice directly in the registry.

Although not sure if it has ever changed before though just by quickly scanning the change log for this app people were using to set it https://kolbi.cz/blog/2017/10/25/setuserfta-userchoice-hash-...

I would think anything with a JIT that is toggling the page protection for machine code many times a second, based on a very quick reading of the bug report talking about VirtualProtect calls and the processing of ETW events for them by defender.

MSVC recently added there own version[1] of it controlled with a [[msvc::dispatch]] attribute thats needs an experimental compiler flag I think still.

1: C++ Function Multiversioning in Windows https://www.youtube.com/watch?v=LTM1was1dTU

The author also worked on the Copy-and-Patch Compilation paper[1], I wonder if they are going to use the same idea for ones of tiers of the JIT idk if it would beat LuaJIT's JIT for code compilation speed but the machine code could be faster.

[1] https://arxiv.org/abs/2011.13127

I know at least the Java ZGC use top bits as metadata for a load barrier to check for relocated objects. They fake hardware pointer masking by mapping the the same heap to multiple addresses https://www.opsian.com/blog/javas-new-zgc-is-very-exciting/

I wonder if filtered solutions files that load only the requested projects in a solution would of made that less painful https://docs.microsoft.com/en-us/visualstudio/ide/filtered-s...