Re: Can anyone get Edge Copilot to work without logging in after July 2026?

On Tue, 7/28/2026 4:43 PM, Chris wrote:
> Maria Sophia <[email protected]> wrote:
>> Chris wrote:
>>> Maria Sophia <[email protected]> wrote:
>>>> Can anyone get Edge Copilot to work without logging in after July 2026?
>>>> https://copilot.microsoft.com/
>>>>
>>>
>>> Just use a local model and don't bother with any of the online ones. They
>>> will *always* use you as training data unless you pay for a firewalled
>>> model. Doesn't matter whether you login or not.
>>
>> Thanks for that idea, which, I agree, is the best way to run an LLM.
>>
>> I researched the local models and they're perfect except... except that
>> they take a ton of disk space and seem to require a beefy machine.
>>
>> Dunno if my 2009 Windows 10 desktop can handle a local model but I do agree
>> that's the way to go for someone like me who cares about privacy.
>>
>> I'll have to look into it 'cuz these web-page LLMs have gotten me hooked on
>> the convenience, but, one by one, they've each started requiring a login. 
> 
> Well, then. Looks like you're going to have put a price on your desire for
> "privacy". 
> 
>> Looking it up, while other families exist (e.g., Qwen, DeepSeek, Gemma,
>> Mistral), apparently Llama remains the most widely used on Windows.
>>
>> Disk space needed seems to be about 3-7 GB for an 8 billion parameters LLM
>> model, and maybe around 30-40 GB for a 70 billion parameters LLM model.
>>
>> Parameters are the learned weights inside the neural network, where more
>> parameters add deeper reasoning and stronger language ability.	
>>
>> Apparently disk space depends on quantization (i.e., compression) though.
>>
>> Looking it up... 
>> The big problem is RAM where 64¡V128 GB RAM is normal for local LLMs.
>> The GPU needs to have VRAM starting at around 48 GB for local LLMs too.
>>
>> Apparently nost consumer GPUs (RTX 3060/3070/3080/4070/4080) will not work
>> as we need workstation-class cards (i.e., RTX 6000 Ada, A100, H100, etc.).
> 
> Lol no. That's the spec for *training* an LLM. Running an LLM requires a
> lot less. 
> 

A Google, seems to dig up tables of such info.

https://www.spheron.network/blog/gpu-memory-requirements-llm/

   Quick Answer: How Much VRAM Do You Need for an LLM?

   As a rule of thumb, an LLM needs about 2 GB of VRAM per billion parameters at FP16,
   or roughly 0.5 GB per billion at INT4, plus 15-20% on top for the KV cache, activations,
   and framework overhead.

   So a 7B model fits in ~16-20 GB, a 70B model needs ~140-170 GB at FP16 (or ~46 GB at INT4),
   and a 685B model like DeepSeek V3.2 needs ~822 GB at FP8.

   Model size     FP16 VRAM     INT4 VRAM     Smallest GPU setup that runs it
     7-8B          ~16-20 GB      ~6-7 GB      1x RTX 4090 (24 GB)
    13-14B         ~34 GB          ~10 GB      1x RTX 5090 (32 GB), INT4
     32B           ~76 GB          ~22 GB      1x RTX 4090/5090 (24-32 GB), INT4

    70-72B        ~168-172 GB    ~46-47 GB     1x L40S (48 GB) at INT4, or 1x B300 at FP16
   109-123B       ~262-295 GB    ~66-75 GB     1x H100 (80 GB), INT4

   400B+ MoE      ~960 GB+        ~240 GB+     1x B300 (288 GB) or 4x H100, INT4    {forgetaboutit territory]
   685B  MoE      ~1.6 TB         ~411 GB      8x H100 / 8x H200 at FP8

The same web site, has this on a separate page.

GPU Requirements: VRAM, Memory, and Storage
Variant            Precision          VRAM
GPT-OSS 20B        BF16              ~42 GB
GPT-OSS 20B        FP8               ~21 GB
GPT-OSS 120B MoE   MXFP4             ~60 GB  <=== running on Big Machine 128GB system RAM (no GPU) [58GB download]
GPT-OSS 120B MoE   BF16 TP4         ~240 GB

*******

My recommendation, is start with a small model, like a Gemma 2.4B or 4B, see
how much RAM it takes to run, as a "calibration" of some of these tables.

On Linux, the LMStudio was an AppImage. Just download it and run it.
AppImage is a kind of container, similar to FlatPak or SNAP.

This is not the latest, I checked the browser on the machine, to see where
I got the AppImage from. This would be a few months out of date.

    https://installers.lmstudio.ai/linux/x64/0.4.12-1/LM-Studio-0.4.12-1-x64.AppImage

The Harmony package isn't theirs, so it comes from somewhere as well. You will
see that item listed in my downloads, in the picture below.

In any case, you don't have to know a lot to use it. That's the whole idea.
Load an open-weights model, give it a try. In this case, with the 60GB model
loaded, system RAM consumption is in the 80GB range. So there's a bit of
overhead on system RAM. If the Mixture of Experts were loaded to a video card,
the size for that is less, but it's generally going to bust any video card
you can afford. This is where the machines with a low end iGPU that maps
96GB of system RAM for the GPU, comes in handy, as you buy a 128GB machine for
$3K-$6K, it isn't as fast as an RTX6000, but it also doesn't cost $15K just
for the video card with 96GB of fast VRAM. Apple this week, is apparently
playing with the idea of leasing things like a Mac Studio, as a solution
for the RAM cost/availability issue.

    [Picture]  Paul uses his LLM-AI...

     https://i.postimg.cc/qqXCTQ7V/LMStudio-memory-usage.gif

     https://imgur.com/a/1s2JZcv

A short sampling of the C code it wrote. Yes, it cheated.
What was I thinking :-) Oh, yeah, this was a simulation.

    /* -------------------------------------------------------------
     * 2) Convert decimal digits → binary precision.
     *
     *   bits ≈ digits × log₂(10)
     *   Add a safety margin (64 bits ≈ 20 extra decimal digits).
     * ------------------------------------------------------------- */
    const double LOG2_10 = 3.32192809488736234787;   /* exact enough */
    mpfr_prec_t prec = (mpfr_prec_t)ceil(dec_digits * LOG2_10) + 64;

    /* -------------------------------------------------------------
     * 2) Initialise MPFR with the required precision.
     * ------------------------------------------------------------- */
    mpfr_set_default_prec(prec);
    mpfr_t pi;
    mpfr_init(pi);               /* allocates space for a variable of 'prec' bits */

    /* -------------------------------------------------------------
     * 3) Compute π.  MPFR's const_pi uses a very fast AGM‑based method     <=== as a student, it always cheated at school...
     *    and returns a correctly rounded value (round‑to‑nearest).              My fault for not slapping it around a bit...
     * ------------------------------------------------------------- */
    mpfr_const_pi(pi, MPFR_RNDN);   /* MPFR_RNDN = round to nearest */

With a good deal more effort, I could convince it to use
one of the better PI algo that have been invented. Instead
of using an infinite precision library that happens to have available
to it, the "constant" PI. Cheating with ArcTan, might take longer.

   Paul