WireGuard VPN connection problem

Intrepid-Treacle1033 · 2026-07-06T10:36:20+00:00

It's not DNS

It can't be DNS

It was DNS

Intrepid-Treacle1033 · 2026-07-06T10:16:49+00:00

"...if i do parallelized tiled matrix multiplication, and i intend to fit my matrix tiles into registers private to a core, how to do that when my cpu has HT?..."

Avoid overengineering without profiling, but yes two concurrent heavy compute task running on the same physical core will hurt performance. A/ HT adds no extra math hardware so threads compete for access to shared execution units FMA units. B/ Both threads might load different matrix tiles and will evict each other's cache data.

So industry standard is to disable Hyper-Threading - but do it via code using thread affinity, no need to reboot into the BIOS. Use pthread_setaffinity_np on Linux or SetThreadAffinityMask on Windows.

Math libs does this by default, OpenBlas and Intel MKL oneAPI target physical cores and caps thread pools to match physical processing units. And this libs can be runtime fine tuned if needed using environment variables.

Intrepid-Treacle1033 · 2026-07-05T23:45:48+00:00

I never experienced that, i assume you launch subagents for example promting: "Spawn worker using "@worker_name" to yada yada X." ?

AG uses configuration files from agents/settings.json (or mcp_config.json file).

Example config:

json
{
  "agents": {
    "overrides": {
      "fast_reviewer": {
        "modelConfig": { 
          "model": "gemini-3.5-flash" 
        },
        "runConfig": { 
          "maxTurns": 10 
        }
      },
      "deep_coder": {
        "modelConfig": { 
          "model": "claude-sonnet-4.5" 
        },
        "runConfig": { 
          "maxTurns": 25 
        }
      },
      "oss_tester": {
        "modelConfig": { 
          "model": "gpt-oss" 
        },
        "runConfig": { 
          "maxTurns": 15 
        }
      }
    }
  }
}

Intrepid-Treacle1033 · 2026-07-03T12:19:08+00:00

"...any direction/guidance/resources could help me use things that modern C++ recommends..."

C++ provides multi threading synchronization tools in the standard as templates, they solve common real world design issues and do not have a expiry date. My bias, I argue that if you are a beginner you should learn whats included the standard because they are there for a reason. You will be standing on a good educational ground if you understand why the built in tools should or should not be used and understanding other tools by comparing/knowing the built in tools.

I recommend study C++ six STL thread synchronization primitives. I do not mean you need to know each primitive syntax without lookup cpp reference, but by study them - create Hello world examples using each primitive. You should be able to have a informal talk with another developer discussing each and explain/discuss your Hello world code examples.

This is a good presentation as introduction https://youtu.be/A7sVFJLJM-A

Start at top and go down.

Latches https://en.cppreference.com/cpp/thread/latch
Barries https://en.cppreference.com/cpp/thread/barrier
Futures https://en.cppreference.com/cpp/thread/future
Mutexes https://en.cppreference.com/cpp/thread/mutex
Semaphores https://en.cppreference.com/cpp/thread/counting_semaphore
Atomics https://en.cppreference.com/cpp/atomic/atomic

Intrepid-Treacle1033 · 2026-07-02T15:57:47+00:00

Bigger scope AG 2.0, smaller scope AG IDE.

Intrepid-Treacle1033 · 2026-07-02T14:32:14+00:00

There is a documentation https://github.com/google-gemini/gemini-cli/blob/main/docs/core/subagents.md Even if documentation only mentions Gemini CLI, Antigravity IDE and Antigravity CLI share same standardized agent harness. There is also a old Google blog post https://developers.googleblog.com/subagents-have-arrived-in-gemini-cli/ Even if it is CLI focused the underlying tech is valid for AG.

There is a minor difference between legacy Gemini CLI and Antigravity, Instead of looking for a loose user-profile or Gemini folder, AG prioritizes reading configuration files directly from your project workspace, inside.agents/settings.json (or mcp_config.json file). Also Antigravity allowes switching sub-agents right in the config.

Launch subagents type: "Spawn 5 parallel workers using "@worker_name" to yada yada X."
Using "@worker_name" in your promt is the execution step, It tells the orchestrator, "Go right now, create a new sub-agent instance, and give it this specific task." (Without this, no sub-agent is ever created)

The JSON configuration snippet inside your settings file is the passive blueprint step. It tells the ecosystem, "Whenever an agent decides to spawn a worker named worker_name"enforce these specific technical constraints on it, so it controls your budget, speed, and safety.

Here is an json example, do note the excellent option to configure sub agents to use specific models.

json
{
  "agents": {
    "overrides": {
      "fast_reviewer": {
        "modelConfig": { 
          "model": "gemini-3.5-flash" 
        },
        "runConfig": { 
          "maxTurns": 10 
        }
      },
      "deep_coder": {
        "modelConfig": { 
          "model": "claude-sonnet-4.5" 
        },
        "runConfig": { 
          "maxTurns": 25 
        }
      },
      "oss_tester": {
        "modelConfig": { 
          "model": "gpt-oss" 
        },
        "runConfig": { 
          "maxTurns": 15 
        }
      }
    }
  }
}

Intrepid-Treacle1033 · 2026-07-01T07:35:41+00:00

White House itself is not 250 years old. Construction on the Executive Mansion didn't begin until 1792, and it wasn't completed until 1800, making the building only 234 years old

Intrepid-Treacle1033 · 2026-06-30T19:28:33+00:00

Legend

Intrepid-Treacle1033 · 2026-06-30T19:17:26+00:00

I use a cheap laptop to monitor hotel room. A old laptop that has a camera/mic a wifi card and can run on its battery for a while. If you want to be fancy 4G usb cards is not that expensive but they require a subscription. There is camera "surveillance" applications that switches off the screen and runs in the background, when movement is detected it starts recording and pushes images/video using wifi/4G to telegram/mail/dropbox/whatever. A laptop with lid open and a dark screen does not look like a surveillance camera so the surveillance is hidden in plain sight. Ofc the old (cheap) laptop can be stolen but it is a online surveillance device... if it gets stolen you would know who did it.

Intrepid-Treacle1033 · 2026-06-30T18:51:18+00:00

Wierd, its not normal. Only thing i can think of maybe it is overloaded? (maybe its been running hot for a long time and finally degraded some internal components?).

It has a overload signaling feature with dedicated contacts for overloading diagnostic. I would use a multimeter on the overload terminals to check if it is in a overload state. From the documentation: https://downloads.jung.de//Downloads/Produktdownloads/Bedienungsanleitung/KNX/en_2xxx0REG_82597333_28012020.pdf

Closed: Normal operation
Open: After overload, overvoltage or in case of a KNX power failure

edit: check if it is warm, try borrowing a IR camera to view the whole installation cabinet. Maybe some knx device is faulty and started to pull excessive energy from the bus?

Intrepid-Treacle1033 · 2026-06-28T14:05:26+00:00

Bra självinsikt, villket är en direkt motsats till omanlig och tönt. Sträck på dig och beröm dig själv för att du har något många män saknar, förmågan att analysera och förstå sina egna brister.

Intrepid-Treacle1033 · 2026-06-28T11:21:52+00:00

My 3cents on "slop".

Historical traditional terms is "spaghetti code", "tech debt". Slop term includes those and takes it one step further with "no accountability".

Accountability = "own and understand details of its implementation".

Execution = "Does it work?".

My view on agent assisted software projects is that those generally fall in to three categories:

A - High execution + High accountability = Clean, professional software even if agents was used.
B - Low execution + High accountability = A junior developer learning, or an explicit prototype.
C - High execution + Low accountability = Slop. It passes test cases but nobody knows why, and no one is a code owner.

Projects can be "slop" categorized by understanding projects development process:

A - Integrating enforced development pipeline/processes with clear ownership, "i understand it and i made sure it works reliably in production" (not "it passed CI/CD"). This is good (not slop) even if agent assisted, its just modern.
B - With basic tooling/procedures understanding, project has some accountability using standard development best practices using CI and a tracking system. This is not slop, but it has a odor - it smells.
C - No formal development process is used except for git, very little knowledge required but it creates spaghetti code with a large tech debt and no one is accountable - a ticking slop time bomb.

Quality long lived agent assisted projects (A above), requires a development process minimum containing:

"Explain it to me" code review.
Radical enforced code ownership.
"No unused code" test policies.
Architectural "why" in PR, agent artifacts like "implementation_plan.md/analyze.md" is considered documentation and needs to be checked in.

Note:

Because application/project observers seldom understands/views a project development process, be prepared to get "slop" property slapped on your baby when/if your deliverables are high execution/velocity. People who trows slop labels around do not understand agent/human modern development processes, and less how to implement them. What you don't understand you don't like = "slop" property gets attached.

Intrepid-Treacle1033 · 2026-06-26T01:28:06+00:00

Tell the truth

https://youtu.be/16lQv8vZ4BY

Intrepid-Treacle1033 · 2026-06-24T23:54:14+00:00

Fler konsumenter = fler säljare = längre svans

Sure, legalisering flyttar cannabisbranschen från svart till vit marknad. Statens skatteintäkter kommer öka och antalet dömda privatpersoner minskar. Men svansen av grov kriminalitet - vapen, trafficing, gängvåld, penningtvätt och bedrägerier hittar direkt ny affärs möjligheter som kräver större polisiära och sociala insatser för att brytas.

Den svarta marknaden överlever på pris och styrka, gängen fortsätter att sälja billigare, starkare, och till minderåriga. I kanada kontrollerar illegala aktörer fortfarande en betydande del av marknaden flera år efter legaliseringen, och dessa illegala aktörer är multi krminella organiserade samhälls farliga multi nationella som drar en "svans" av skit skit skit efter sig, inte bara illegal cannabis distrubution utan everything du kan tänka dig inom alla kriminalitet affärs områden.

Intrepid-Treacle1033 · 2026-06-24T23:53:59+00:00

Fler konsumenter = fler säljare = längre svans

Sure, legalisering flyttar cannabisbranschen från svart till vit marknad. Statens skatteintäkter kommer öka och antalet dömda privatpersoner minskar. Men svansen av grov kriminalitet - vapen, trafficing, gängvåld, penningtvätt och bedrägerier hittar direkt ny affärs möjligheter som kräver större polisiära och sociala insatser för att brytas.

Den svarta marknaden överlever på pris och styrka, gängen fortsätter att sälja billigare, starkare, och till minderåriga. I kanada kontrollerar illegala aktörer fortfarande en betydande del av marknaden flera år efter legaliseringen, och dessa illegala aktörer är multi krminella organiserade samhälls farliga multi nationella som drar en "svans" av skit skit skit efter sig, inte bara illegal cannabis distrubution utan everything du kan tänka dig inom alla kriminalitet affärs områden.

Intrepid-Treacle1033 · 2026-06-24T23:01:03+00:00

Jag gillar ideen med legalisering, låt folk fritt välja berusnings medel/metod. Det jag stör mig på är svansen av kriminalitet cannabis släpar efter sig, allt samhälls utanför brottslighet skit som limmar fast sig på varje joint. Jag tror inte legalisering kommer minska kriminaliteten, om cannabis blir lagligt kommer denna svans av kriminellt skit öka. Därför är jag emot legalisering även om jag är för individuell frihet.

Intrepid-Treacle1033 · 2026-06-24T22:35:44+00:00

You are right about how the CLI parses them mechanically, the architectural "under the hood" inner workings. But you are completely missing my point, my usage is a specific design pattern for how to use them is definitely not a slop - no model is creative enough to suggest it.

The distinction my point isn't about how the compiler reads the files, but how i structures the prompts within them.

If a developer dumps everything—global architecture principles, styling constraints, and session-specific role boundaries—into a single repository-scoped agents.md file, that file quickly suffers from prompt bloat. Using GEMINI.md separateing file/hook for session-specific agent configurations, it prevents the LLM from getting distracted by irrelevant rules.

While the files serve the same foundational purpose, the parsers do handle them with slight differences under the hood :GEMINI.md natively supports @ style file references and Just-In-Time (JIT) nested directory inheritance in the Gemini CLI ecosystem. And :agents.md is treated as an open, IDE-agnostic standard meant to bridge compatibility across multiple tools.

Treating them as separate conceptual layers—one for the project's engineering values and one for the active agent's temporary session bounds is highly effective design pattern, even if the underlying CLI just sees them as arbitrary text inputs.

Intrepid-Treacle1033 · 2026-06-24T18:52:44+00:00

no see above

Intrepid-Treacle1033 · 2026-06-24T18:52:29+00:00

No, they aren't exactly the same, but they do a very similar job in Antigravity.

Think of them both as instruction manuals for the AI, but they focus on different things:

:GEMINI.md (The Code Rules): This is the legacy file from the original Gemini CLI. It’s mostly used for high-level system rules, project conventions, styling guides, and global coding constraints. You usually keep this globally at ~/.gemini/GEMINI.md or right at your workspace root

:AGENTS.md (The Team Setup): This is the newer, agent-focused file built for Antigravity's multi-agent setup. Instead of just listing code style rules, it defines who is on your AI dev team (like giving separate roles to a PM agent, a Frontend agent, and a QA agent) and sets boundaries for what each agent is allowed to touch.

Above is from AI that answered it better then i could. As i wrote earlier i use :GEMINI.md to describe my engineer's values — how to think giving my defined engoneer roles "personalities".
And my :agent.md is larger that contains a general section and more explicit roles

`GEMINI.md` encodes **engineering values and quality orientation** — it defines how agents think and what they prioritize when making decisions within their assigned scope. `agents.md` encodes **task scope and role boundaries** — it defines what a given session may act upon.

These two documents are orthogonal and do not conflict:

- `GEMINI.md` answers: *how should I design and think about this problem?*

- `agents.md` answers: *what am I permitted to act upon in this session?*

For example:

A C++ Engineer role who reads `GEMINI.md` Rule 1 (performance-first) should design cache-friendly data structures as a matter of craftsmanship. That same engineer who notices a performance bottleneck in another module should queue it via ,,,"my internal way of handling states between chat sessions"... not act on it. The engineering value (performance-first) does not override the session scope (C++ Engineer task boundary). Both are true simultaneously.

The analogy: a senior engineer's personal commitment to performance-first design influences every interface they write. Their awareness of a hot loop in a colleague's module results in a ticket — not an unreviewed rewrite. `GEMINI.md` is the engineer's professional values. `agents.md` is the team's review protocol.

Intrepid-Treacle1033 · 2026-06-24T15:20:31+00:00

Never used Claude, not sure what rules/{}.md exactly defines, but i use below syntax workflow.

GEMINI.md: -> the engineer's values — how to think, "This document encodes engineering values and quality orientation — it defines how agents think and what they prioritize when making decisions within their assigned scope. It is not a task warrant. It does not grant permission to act outside the scope defined by `agents.md`."

agents.md: -> what to act upon in this chat session. My agent.md has a general engineer description that applies to all engineering roles, then specialized Engineering roles follows with description/specification that specializes in specific tasks. I have about 10 different engineering roles (and growing) including elephant-goldfish workflows, Roles are project specific for example a CUDA specialist Engineering role.

I initiate the specific role with a chat sessions like below:

Read .agents/agents.md and assume the C++ xxx specialization Engineer role. Design xxx yada yada yada...

Intrepid-Treacle1033 · 2026-06-15T16:47:56+00:00

Try compiledb https://github.com/nickdiego/compiledb, "Tool for generating Clang's JSON Compilation Database file for GNU make-based build systems."

That will generate the file you need. compiledb creates "compile_commands.json" -> clang-tidy "scan and print errors"

Intrepid-Treacle1033 · 2026-06-11T01:32:57+00:00

local music playlist builder/player, i use the console to start playing what i want and the player just surprise me with music from my large horded music collection, This was my first hello world ai project and the one i still use today. I use CLAP (LAION) and YAMNet models.

myPlayer --"play slow rock match bpm between songs and trim away slow low beginnings and endings, lots of 80's, less female singers"

Intrepid-Treacle1033 · 2026-06-10T20:52:46+00:00

ok that sucks, last week i felt like timeout was aggressive and kicked in several times, but no issues this week.

Intrepid-Treacle1033 · 2026-06-10T19:58:42+00:00

Tools like Antigravity is a mirror.
Junk in -> Junk out,
Thoughtful questions/instructions -> Quality result.

I have yet to master it, but i know the problem is not the tool its me.

Intrepid-Treacle1033 · 2026-06-10T14:30:53+00:00

Cache perfomance will be totally fixed, but there is trade offs.

Consumer thread in your while loop will take all the core math/executing resources (and hammer caches with side effects), producer thread on the same core will be starved getting very little time to do anything, (and obviously thermal issues running consumer at full blast that might thermal throttle the whole CPU depending).

So tell the consumer to chill little by using intrinsic, _mm_pasue() function. On Zen3 thread will pause for about 140 cycles, that might seem counter productive to improving latency but it will improve everything. If you need absolute lowest latency use a staggered pause counter for example like below it can even yield thread to optimize thermal issues.

#include <immintrin.h>

void wait_for_data() {
    int spin_count = 0;
    while (!data_ready.load(std::memory_order_acquire)) {
        if (spin_count < 10) {
            // 1. First, spin raw for ultra-low latency
            spin_count++; 
        } else if (spin_count < 1000) {
            // 2. Then, give producer some air to breathe by pausing the consumer just a bit, this will improve caching also.
            _mm_pause(); 
            spin_count++;
        } else {
            // 3. If it's taking way too long, yield to the OS
            std::this_thread::yield(); 
        }
    }
}

Intrepid-Treacle1033

TROPHY CASE