All Activity

It does. Sorry. Typo. It is burNmem. https://github.com/Baron-von-Riedesel/XMSTools There are different internal results for Windows Memory Manager. And using DOS tools has much more strict effect in memory limiting.

@reboot12 Make some tests with disable and enable the Microsoft UAA drivers in System Devices. I remember, that I had the same problem and the admin @Dave-H here also with Baytrail Flex 10 and XP and sound Dietmar

I would a piece of to put into my autunattend.xml and unattend.xml to search through all drives except a,b and c. This code will set a variable to %Drive and then run a batch file called apps,utils and batches then run z.cmd inside a folder on app,utils and batches. how is done? Show in code!

Can you read with understanding? I do not have a dedicated card, both are integrated - one of the Realtek motherboard and the other with the Intel processor and both work OK in Win7, Win10. The point is that in WinXP they are not visible in the device manager so I can't install the drivers. And no, in the bios it is impossible to disable the Intel card integrated with the processor, you can only disable the Realtek card integrated with the motherboard but I do not want to disable because I have drivers to it and I would like to use it in WinXP:

You are right. You need version 138 or above to get the patch. If folks don't want to update, the patch is unavailable to them. For those folks, the only safe option is to turn off the V8 optimizer as described previously. I suppose, in theory, someone skilled in building Chromium could apply the patch to earlier versions, but I can't imagine anyone would do so, unless there were a very popular old version that many folks were reluctant to update from.

https://adamdemasi.com/2025/07/04/windows-7-microsoft-update-issue.html

this should be reported to upstream. maybe related but the patch there doesn't help: https://bugzilla.mozilla.org/show_bug.cgi?id=1296410

When one has a dedicated card, the onboard needs to be disabled in BIOS.

That was clear, but from what they tell, looks like the patch is intended to be applied only to 138+. Who would write a patch for the old 132, while we are at 140+ already?

i was referring to group of people they selected even more ironic they taped it and showed to public you can still find it, bunch of brainless people who never used pc...

Hello again roytam1, is there any possible chance getting this website below, to work ? i need to access it, but It always crashes when i try to load it, the page doesnt even show up or load at all...just instantly crashes when i try to visit it. https://spectrumsurveys.com I dont know exactly how long it's been happening before but the last version i had of Basilik was from April 2025 and it crashed then... and still does on your latest July 4th build.

Microsoft Update seems to be no longer working for me. It had been fine, although I hadn't tried it for a long time. Now getting error 0x80248015 as soon as the scan starts.

Version 138 is required for the fix; the bug goes back earlier though: Good catch. Google is being tight-lipped on exactly when this vulnerability crept in. I doubt it goes all the way back to 2008, though. Today's V8 looks nothing like the original. I believe (and should have said) versions prior to the V8 optimizer are not vulnerable. I suspect 360EE (and Kafan MiniBrowser) aren't vulnerable because the option to turn off the optimizer isn't there (presumably because there's nothing to turn off), but I can't be sure with the limited info we have.

@Dietmar What double ??? I don't use CSMWrap because the motherboard has native CSM These are two completely different sound cards - one is a Realtek 10EC 0887 integrated with the motherboard and the other Intel integrated with the CPU 8086 2882

I do hope that remark was a generalisation referring to the software, and not aimed at anyone on this forum personally.

@reboot12 This can be a problem with a driver, that appears double. Make a try to disable really all. And then install your wished sound card and look what happens. With csmwrap I had the problem, that some parts of memory are occupied twice Dietmar

BIOS UEFI 64-bit but CSM available. Hi. I installed WinXP (Legacy) but in the Device Manager I can't see any (?) Unknown device or (?) Multimedia device for sound card (Realtek or Intel). On Win7 and Win10 there is no problem with that and both sound cards available:

Well, more than at an OS level, I was thinking more about this being implemented at the router level. Currently there's NAT64 / DNS64 implemented in routers that is generally used to perform the opposite of what you wanna do (i.e allowing IPV6 clients to access public IPV4 only resources), however I wonder if it could technically be used to map public IPV6 addresses to internal private IPV4 addresses for older clients... I'm not a networking expert and even though I have an OpenWRT router, I don't really have a public IPV6 address from my ISP, so I can't really test / experiment with it as I'm behind CGNAT (IPV4), but if someone is more experienced and/or wants to test, please shout. This is definitely an interesting topic.

Isn't the minimum requirement chromium 138? https://www.securityweek.com/chrome-138-update-patches-zero-day-vulnerability/

brought back manifest v2 extension support. Cool! https://github.com/e3kskoy7wqk/Chromium-for-windows-7/releases/tag/140.0.7275.1

im not certain, it would requie to read out all the stuff that has been done related to this patches the /3GB is known to have some problems too, i dont know the problems with it j7n maybe has some knowledge here ? if its a problem with the /3GB switch there would be also the /USERVA switch to set a different value (between 2048 and 3072 (3 gb)) https://learn.microsoft.com/en-us/windows/win32/memory/4-gigabyte-tuning the one from dibya only use a small patch - maybe that would be worth a shot daniel k.´s patch use more of changes, maybe static offsets - that would be a reason why they dont work together also the method daniel k. described could trigger a crash not certain what "the russian patch" do to solve this problem is at the moment to much things around, i might can tell the norm´s, talks, idea´s a debug analize for example would take some time but if it comes to new work im busy at the moment sorry i also dont have the function test for dibya´s patch (aka if it passes the 4 gb limit) there should be someone to try these patches with the method j7n did to do so is simple just disabling the pagefile, then starting up app´s/executables that eat up more then 4 GB of ram if that is possible that patch is likely to work

Thank you so much, but I'm afraid that is pretty much all completely over my head! Do you know why the /3GB switch cannot be used with the RAM patch applied?

got a sn850x but it doesn't work on any m.2 slots in my B450 steel legend. with m.2 to PCIe x1 convertor it works, just too slow. EDIT: after reading https://www.reddit.com/r/ASRock/comments/1gjwx3h/working_gen4_nvme_ssd_that_does_not_have_a_pin/ , I think I need to get another one using Phison E18 controller.

Unfortunately, after a few days of testing, there is still a problem with the lag on Haswell machine. I changed OS to my favorite - WinXP 64-bit - everything works ok and I have full access to RAM P.S. I wanted to add a RAM patch to my project on MDL - WinXP 32-bit on a modern PC (ISO boot.wim + install.wim) but since it works unstable, I will probably give up Maybe I will add as an alternative in the boot.ini and BCD file but not as default.

hmmm in the past we had often a discussion about "32 bit is the 4 gb limit" or = 32 wires 32 bits can form 2^32 bits therefore 4´294´967´296 what represents 4 GB the problem with that is that even in 8 or 16 bit´s there are so called selectors those do actually still exits in 32 bit too also very important is that these 4 GB of possible "addresses" are not converted into that rather the representing PTE´s and PDE´s represent to a 4 KB page (in old normal 32 bit style) so going with that if you have 4 GB/ 4 k pages you end up in only using 20 bits ! (20 bits * 4k = 4 GB) a idea (very similiar to the discussion about 4 k sectors and 4 MB sectors with the harddrive(hdd/ssd)) would be just to increase the 4 K pages to 4 MB pages that would be 1024 times as much RAM the discussion about this are elder thats why that bit (PSE (page size extension)) was 1 candidate to pass that 32 bit limit the other candidate was the PAE bit (physical address extension) here is 1 catch PSE can extend the 4 GB by increasing the page size (even with a 32 bit PDE´s and PTE´s) in PAE mode PDE´s and PDE´s are 64 bit (yes even in 32 bit mode), that´s one of the reasons why PAE can address more then 4 GB of ram (to be more precise paging are mechanism´s there also some more things they play a role the CR3 register (also called the page directory base register) or the GDT, it would be to long to explain all but lets stay like this for now) so let us take the next important step in the old 32 bit system without PSE,PAE or "concrete use of segments", an app/executable had to use up the 4 GB ram because there was a user-mode (ring3) and a kernel-mode (ring0) there had to be a part in kernel mode and a other part in user-mode offsets are not a problem (as you can map a address like 0xFFFFFFFF to page 0 if you wanted) deviding the kernel mode and user mode is important, if that would not be the case every crash on a normal app/execuble would be a entire OS crash (BSOD or wrose) so the solution was simple usermode 0x00000000 - 0x7FFFFFFF - kernelmode 0x80000000 - 0xFFFFFFFF thats how the eldest 32 bit norms work it is not to bad to have kernel mode ram because many modules actually need space in memory (its not like an app is just made out of the app itself the app consits of many modules that also use ram internal) - also the video frame buffer often has a kernel mode area that takes memory for example so here we finally have our split 0x00000000 - 0x7FFFFFFF (2 gb) + 0x80000000 - 0xFFFFFFFF (2 gb) = 4 GB the app/executable now has the problem that it cant directly use the kernel mode offsets (it certainly use them but rather passiv (its some memory you need less in your app)) for this microsoft then made the /3 GB option in this one usermode has 3 GB and kernelmode 1 Gb (0x00000000-0xBFFFFFFF) + (0xC0000000-0xFFFFFFFF) = 4 GB but now the important part those offsets are not physical addresses ! actually you can map every of that "offset´s" to different places in memory (including the ones above 4 GB RAM) so thats why multiple applications/executables can use up the entire 64 GB of RAM (in j7n example he had 20 GB of 64 GB possible) thats more then 4 GB of ram and the proofes XP 32 bit can do it that way now we also have to mention the ramdisc solution, if you have like 20 GB of data and map then into the physical ram then the ramdisc use a chuck-wise solution it then maps for example 1 GB of that 20 GB data into an offset (that goes like fast) (when it wants the next part it just maps the next part - but it is chuckwise) now we have to mention the pagefile, in the pagefile windows stores memory data on the harddrive (HDD/SSD) when windows wants it use exactly that trick (it loads the data from the harddrive into that virtual offset) but this time there is an important differenz - the data is not from a RAM memory - it has to load that from the harddrive (and that is slow) for a SSD its faster - but still not as fast as it would be in memory so i guess some have reconized the increase in speed with SSD`s ? now you have a little more precision why this is the case so now to the part why a "normal app/executable" actually dont pass that 4 GB ram ram limit i already explained why it is rather like 2-3 GB ram + some kernel mode memory that is rather used like passiv but now the reason why it actually dont go beyond the 4 GB ram in "just one application/executable" here you have to know that all compilers form the past-now dont use segment selectors to pass that 4 GB ram i never seen a compiler that would be able to do so. probaly windows xp (even up to win10) dont have code for this either. but here is the thing normally in a code flow of a debugger you see a offset (or better called vitual offset this time) for the code flow it use a register called EIP (instruction pointer) - the E stands for 32 bits - for example only IP for 16 bit and REIP for 64 bit (R means 64bit) but here is the next catch ... the most common debuggers dont show the selector but for the code flow the CPU use a combination of a segment selector + virtual offset (the one you see in a debugger for example) this is called the CS:EIP combination - where CS is the segment selector (called the CODE SEGMENT(short CS) selector) EIP E for 32 bit and IP for instruction pointer now might be a good time to call out a wiki page about that: https://wiki.osdev.org/Segmentation that CS selector is 16 bits wide (in 32 bits) and 16 bits means 65536 possible selctors ... so the combination 16:32 or CS:EIP would be 65536 * 4 GB - that would be theoretical 262144 GB that it could select (+ you have 6 of segment selectors all in range 0-65536) but here is the catch windows (either xp - 10) dont use this to pass the 4 GB limit the only things windows actually did with these registers is that they point to small pieces of memory (like the EPROCESS structure) that is possible - but it leaves out the use to pass the 4 GB of ram limit by just using a few kilobytes with that method ... here is an example where microsoft accesses a small piece of ram using a selector : https://devblogs.microsoft.com/oldnewthing/20220919-00/?p=107195 (the problem with the way this is used, it not used that to pass the 4 GB ram limit, rather is use that as small memory storage) so the next step: back to the app/executable as mentioned there is no compiler that actually generate the useage of segmentation ... therefore you would need a specific app/executable that can do so - and that means chrome still would not pass the 4 GB ram limit (because it cant use segmention) (and then you also would need the windows operating system code also to control this kind of memory managment) also to mention is the FPU unit even the elder ones are 64 bit (or bigger) in modern cpu´s they are 512 bits (AVX) so actually you can make 64 bit moves in 32 bits or calculations, compessions like h.265 do so also some routines are written in the FPU, for example cpu intense sort mechanism´s - you might heared MMX, SSE ect. so in short 32 bit has 64 bit commands that it can use over the FPU unit (what is actually done sometimes) it can pass the 4 GB of ram over multiple app´s/executables it cant pass more then 4 GB of ram with just one app/executable - unless it use a chuckwise method (like the ramdisc) - the segment registers are actually not used to pass the 4 GB ram limit(that also goes for win10 32 bit) so i tryed my best to explain this as simple as i could