Classic Mac OS Surfs the Modern Web with Macsurf Browser

the web. Macsurf eliminates this dependency entirely.

NetSurf: The Engine of Choice for Lightweight Browsing

Faced with the challenge of rendering the modern web on legacy systems, writing a browser engine from scratch is an-impossibly massive undertaking. Conversely, porting Chromium (Blink) or Firefox (Gecko) is equally impossible; these modern engines require gigabytes of RAM, multi-core gigahertz-class processors, and advanced C++ toolchains that do not exist on Classic Mac OS.

Britton found the ideal solution in NetSurf, a highly portable, open-source web browser originally written in 2002 for RISC OS—the operating system designed for the ARM-based Acorn Archimedes. NetSurf’s primary design goal is extreme lightweight performance. Rather than relying on a heavy third-party engine, NetSurf features its own custom layout and rendering engine written in strict ANSI C (C89/C99).

NetSurf is designed to squeeze maximum performance out of low-power processors, making it uniquely suited for first-generation PowerPC Macs. It does not attempt to compile modern, bloated JavaScript frameworks, yet it features a highly competent rendering pipeline capable

Posted in Internet Curiosities, Resources & Culture | Tagged , , , | Leave a comment

Antigravity CLI Replaces Gemini CLI: Google Sparks Developer Backlash

In the rapidly evolving landscape of artificial intelligence development, the relationship between tech giants and the open-source community has always been a delicate dance of mutual benefit and underlying friction. On May 19, 2026, that delicate dance turned into an outright confrontation. Google officially announced the deprecation and impending sunset of its highly popular, terminal-native AI assistant, Gemini CLI. Starting June 18, 2026, the open-source CLI and its corresponding Code Assist IDE extensions will completely stop serving requests for free tier, Google AI Pro, and Ultra subscribers. In its place, Google is pushing developers toward a new, closed-source proprietary tool: Antigravity CLI.

The move has sent shockwaves through the free and open-source software (FOSS) community, raising intense debates about corporate exploitation of open-source labor. While Google frames the migration as an essential technological upgrade to usher in the “agent-first” era, thousands of independent developers who built, polished, and integrated Gemini CLI see it as a textbook case of corporate bait-and-switch. Below, we break down the controversy, the technical leap of the new system, and the practical path forward for developers caught in the crossfire.

The Open-Source Betrayal: From Community Project to Proprietary Lock-In

To understand the depth of the developer backlash, one must look at the history of Gemini CLI. Released in mid-2025 under the permissive Apache 2.0 license, Gemini CLI quickly became a darling of the terminal-centric development world. Over the course of less than a year, the project compiled an impressive set of community milestones:

  • Over 100,000 GitHub stars, cementing its place as one of the fastest-growing terminal utilities of the decade.
  • More than 6,000 merged pull requests from hundreds of independent developers worldwide.
  • Broad ecosystem integrations, including Model Context Protocol (MCP) servers, custom shell hooks, and specialized developer skills.

FOSS commentators and contributors point out that Google capitalized heavily on this massive, unpaid community workforce to debug, optimize, and market Gemini CLI. Now, with those features fully battle-tested, Google is effectively closing the door. Starting June 18, 2026, only high-paying enterprise customers using Gemini Code Assist Standard or Enterprise will retain access to the legacy open-source Gemini CLI. Everyday developers—the very people who built the tool’s momentum—are being funneled into the proprietary ecosystem of Antigravity CLI.

Critics argue that this strategy leverages open-source contributions to build a developer base, only to lock down the successor behind proprietary licenses, usage limits, and closed-source binaries. In GitHub issue tracker discussions and across social platforms like Reddit, terms like “classic bait-and-switch” and “open-source open-washing” have dominated the discourse. The short 30-day transition window has only exacerbated the frustration, leaving teams scrambling to overhaul their active terminal workflows.

Decoding the Architecture of Antigravity CLI

While the licensing transition has drawn ire, the technical specifications of the Antigravity CLI are undeniably formidable. Google’s developers built the new tool from the ground up to address the fundamental limitations of the older Node.js-based Gemini CLI. By transitioning the codebase to Go, Google has delivered a lightweight, compiled binary that executes with near-zero latency, eliminating the startup lag that plagued Node-native terminal utilities.

An Agent-First Paradigm and Asynchronous Workflows

Unlike traditional LLM-powered command-line interfaces that operate on a rigid, single-thread request-and-response model, the new utility is designed as a task-oriented agent platform. It shares the same unified backend agent harness as Google’s desktop environment, Antigravity 2.0. This allows developers to work at a much higher level of abstraction:

  • Dynamic Subagents: When given a complex instruction, the main agent can autonomously spawn, delegate, and coordinate dedicated subagents to handle focused subtasks in parallel. This design preserves the context window of the primary agent and optimizes token usage.
  • Asynchronous Task Management: Rather than locking up the active shell session while generating complex refactors or conducting deep documentation searches, developers can run multi-agent workflows concurrently in the background. Users can monitor active background processes, view status logs, and instantly approve code executions.
  • Unified Architecture: By leveraging a single agent harness, any configurations, permissions, and tool-calling settings established in the Antigravity desktop app are automatically synchronized with the terminal interface.

Solving Context Amnesia via Local Memory Integrations

One of the persistent pain points of AI-assisted terminal work is the “cold start” problem—the reality that every fresh terminal session starts with zero knowledge of previous work. The new Go-based tool aims to solve this by integrating local memory systems directly into the developer’s workspace. Users can connect the platform to local markdown knowledge bases like Obsidian or utilize dedicated Model Context Protocol (MCP) servers like Mem0.

This persistent memory architecture ensures that key project files, architectural decisions, and personal style guides are remembered across different terminal sessions, machines, and workspaces. Rather than copy-pasting the same system prompts or project structures every morning, the tool dynamically surfaces the relevant context when requested, creating a cohesive, continuous engineering workspace.

The Command Center: Unpacking the New Slash Commands

Interaction in the new Go-compiled environment is heavily centered around interactive Terminal User Interfaces (TUIs) and specialized slash commands. These commands bypass normal chat flows to trigger complex, pre-configured agentic pipelines. Key workflows introduced in the tool include:

  1. /grillme: A command designed to pressure-test code and architecture. Instead of simply reviewing code, the agent takes an adversarial role, identifying edge cases, potential race conditions, and architectural bottlenecks before deployment.
  2. /goal: Used to define high-level engineering objectives. The system then translates this goal into an actionable, multi-step roadmap, executing the intermediate steps autonomously while prompting the user for approval at critical junctions.
  3. /rewind: A powerful state-management utility. If a series of autonomous code edits fails to compile or deviates from the design plan, developers can use this command to instantly roll back the codebase and agent state to a previous point in the session.
  4. /agents: Opens a dedicated management panel inside the terminal UI to view, monitor, and configure active, concurrent subagent sessions.

How to Prepare: The 30-Day Migration Blueprint

With the hard shutdown of consumer-tier Gemini CLI endpoints scheduled for June 18, 2026, developers must begin preparing their local environments immediately. For those choosing to adapt to the new proprietary platform, Google has streamlined the installation path via a rapid-install terminal script.

Step-by-Step Installation

To install the compiled Go binary (which registers the agy command in your system PATH), run the corresponding fast-path installer command for your operating system:

macOS / Linux:

curl -fsSL https://antigravity.google/cli/install.sh | bash

Windows (PowerShell):

irm https://antigravity.google/cli/install.ps1 | iex

Windows (Command Prompt):

curl -fsSL https://antigravity.google/cli/install.cmd -o install.cmd && install.cmd && del install.cmd

Once installed, you can launch the interactive Terminal User Interface by navigating to your target repository and executing the launcher command:

agy

Crucial Safety and Migration Precautions

Transitioning to a closed-source agent with autonomous terminal privileges requires a heightened focus on security and system monitoring. Developers planning their migration should adopt the following safety practices:

  • Audit Autonomous Privileges: Because the Go binary is proprietary, developers cannot inspect the underlying code governing tool execution. It is highly recommended to keep strict terminal prompt approvals active and avoid enabling raw “Yolo” modes that grant unchecked write permissions to your local environment.
  • Establish Local Backups: Before running commands that orchestrate dynamic subagents across a codebase, ensure that all local changes are committed to Git. Closed-source agents running multi-agent code refactors can write hundreds of lines across multiple directories concurrently, making clean version control your primary line of defense.
  • Migrate Custom Skills and Plugins: Review your legacy Gemini CLI skills, hooks, and MCP configurations. While there is no direct 1:1 parity out of the gate, many of these custom extensions can be ported over as plugins within the new ecosystem. Refer to the migration documentation to map old settings to the new Go-native equivalent.

The Future of Terminal AI: Innovation at What Cost?

The forced sunsetting of Gemini CLI stands as a landmark moment in the current era of artificial intelligence. On one hand, the technological capabilities of the new platform represent a massive leap forward. The Go-compiled architecture, the elegant TUI, the multi-agent asynchronous engine, and deep memory systems collectively elevate the terminal from a simple text interface into a fully autonomous, collaborative development environment.

On the other hand, the strategy behind this transition leaves a bitter taste in the mouths of FOSS advocates. It raises a troubling question: is the future of developer tools destined to be entirely proprietary and walled-off, even when built on the backs of open-source contributors? Whether the community will attempt to fork the open-source legacy of Gemini CLI or ultimately yield to the sheer performance of Google’s new closed-source paradigm remains to be seen. What is certain is that the deadline of June 18 is approaching rapidly, and developers have a hard choice to make.

Posted in Recommended Software, Resources & Culture | Tagged , , , | Leave a comment

Rustinel: A New Open-Source Endpoint Detection Tool for Windows and Linux

Modern security operations are inherently complex, particularly when managing mixed-operating system environments. For years, system administrators, security engineers, and DevOps teams have battled a persistent operational headache: the fragmentation of host telemetry. While Windows-focused security telemetry relies heavily on Microsoft Sysmon or native Event Tracing for Windows (ETW), Linux monitoring is traditionally managed through fragmented tools like auditd or custom eBPF (Extended Berkeley Packet Filter) pipelines. This divide forces defensive teams to maintain entirely separate logging agents, incompatible rule formats, and disparate analysis pipelines.

Enter Rustinel, an innovative, unified, open-source endpoint detection tool designed to bridge this gap. Developed by Théo Foucher, Rustinel tackles this operational divide head-on by collapsing cross-platform endpoint monitoring into a single, high-performance codebase. Written entirely in Rust to ensure memory safety and exceptional execution speeds, this lightweight utility normalizes system events from both Windows and Linux into a unified format, allowing teams to deploy identical detection rules across their entire digital fleet.

How Rustinel Redefines the Modern Endpoint Detection Tool

The foundational value of Rustinel lies in its ability to abstract the underlying OS architecture. Rather than forcing blue teams to translate Windows-centric behavioral detections into Linux equivalents, Rustinel serves as a universal translator. This is critical because modern threat actors do not limit their tactics to a single operating system; a multi-stage campaign might start with a phishing payload on a Windows workstation and pivot to a Linux-based database or cloud server.

Historically, a cross-platform endpoint detection tool would have meant deploying bloated, enterprise agents that consume massive system resources and run proprietary, closed-source engines. Rustinel flips this model. By leveraging a transparent, open-source framework, defenders can audit exactly how telemetry is parsed, evaluated, and alerted. It is designed specifically for defenders who want to understand exactly what telemetry is collected, how detections are evaluated, and where the current operational limits reside.

Deep-Dive Telemetry: ETW and eBPF Pipelines

Rustinel achieves its high-performance monitoring by tapping directly into the native instrumentation frameworks of each supported operating system:

  • Windows Telemetry (ETW): On Windows, Rustinel hooks into Event Tracing for Windows (ETW). It provides broad coverage across several crucial event types, including:
    • Process creation and termination
    • Image loading (DLL tracking)
    • Network connection attempts and socket events
    • File creation, modifications, and deletions
    • Registry modifications and persistence attempts
    • Domain Name System (DNS) queries
    • PowerShell command execution and script block logging
    • Windows Management Instrumentation (WMI) activity
    • Service installation and Scheduled Task creations
  • Linux Telemetry (
Posted in Recommended Software, Resources & Culture | Tagged , , , | Leave a comment

JINX-0164 macOS Malware Targets Crypto Developers and CI/CD Pipelines

In the rapidly shifting landscape of software supply chain security, a newly uncovered threat campaign has shattered the myth of Apple ecosystem invulnerability. The group behind this operation, tracked as JINX-0164, has engineered a multi-stage campaign targeting cryptocurrency firms with custom macOS malware designed to pivot from developer laptops straight into core automated infrastructure. First reported by the Wiz Customer Incident Response Team (CIRT), the campaign represents a terrifying evolution in financial cyber-espionage: a highly calculated sequence that turns developer trust, targeted social engineering, and continuous integration pipeline mechanics against their owners.

For years, cryptocurrency organizations and decentralized finance (DeFi) platforms have prioritized cloud infrastructure and blockchain smart-contract auditing. However, JINX-0164 exploits a different, softer target—the workstations of the developers themselves. Operating since at least mid-2025, this financially motivated threat actor leverages polished LinkedIn profiles, masquerades as recruiters or business partners, and bypasses local operating system protections to establish a permanent foothold. From there, the real damage begins, as the attackers systematically poison repositories and turn internal software supply chains into self-propagating malware delivery systems.

The LinkedIn Trap: How JINX-0164 Hooks Crypto Developers

The initial entry point of a JINX-0164 intrusion bypasses automated firewalls and perimeter defenses entirely, focusing on the human element through meticulously crafted spear-phishing and social engineering. Attackers curate highly convincing and polished LinkedIn profiles, posing as technical recruiters from reputable investment firms, cryptocurrency exchanges, or technology providers. They identify high-value targets within the organization—principally blockchain developers, DevOps engineers, and system administrators—and initiate contact with enticing offers of virtual business collaborations, advisory roles, or lucrative employment opportunities.

Once initial rapport is built and a developer’s guard is lowered, the attacker schedules a virtual meeting. Rather than sending a link to a mainstream videoconferencing platform, the target is directed to a malicious lookalike domain. These domains are designed to replicate standard teleconferencing landing pages but utilize typosquatted names such as:

  • teamicrosoft[.]com (impersonating Microsoft Teams)
  • bitget-meeting[.]com (impersonating the crypto trading platform)
  • us03-slack[.]online (impersonating Slack)

When the victim attempts to join the call, the fake platform simulates a technical failure, displaying a customized popup indicating an audio driver mismatch or a local hardware configuration error. The victim is immediately prompted to run an automated “system audio fix” to join the meeting. The sense of urgency created by the upcoming interview or business meeting frequently drives targets to authorize the download, which delivers a bash dropper script hosted on the attacker-controlled server apple.driver-store[.]com.

Deconstructing AUDIOFIX: A Sophisticated Strain of macOS Malware

The bash script downloaded during the fake meeting behaves as an architecture-aware downloader. It queries the host hardware via shell commands to determine if the victim is running an Intel (x86_64) processor or Apple Silicon (ARM64) architecture. Based on this discovery, it fetches a compiled Python-based macOS infostealer and Remote Access Trojan (RAT) called AUDIOFIX (also tracked as AUDIODFX).

To avoid raising suspicion within system monitoring logs, AUDIOFIX masquerades as the legitimate macOS Core Audio daemon, coreaudiod, which handles all sound card inputs and outputs on the operating system. The binary is written to the disk as ChromeUpdater and persistent execution is established using macOS’s native service management architecture, launchctl, injecting a property list (.plist) file under the user’s launch agents.

Once AUDIOFIX is loaded into memory, its primary objective is rapid, comprehensive credential harvesting. The malware is pre-configured to systematically extract the following local data structures:

  • iCloud Keychain Contents: Extracts stored cryptographic keys, application passwords, and secure notes.
  • Browser Credentials: Targets over 10 distinct web browsers, querying local SQLite3 databases (such as Chrome’s Login Data file) to exfiltrate plaintext usernames and passwords.
  • SSH Keys and Git Credentials: Scans the default ~/.ssh/ directory, harvesting private keys and configuration files that grant write access to external codebases.
  • Cloud Provider API Tokens: Scans system environment variables, local configuration files, and IDE history to extract high-value access keys for Amazon Web Services (AWS), Google Cloud Platform (GCP), Microsoft Azure, and Cloudflare.
  • Cryptocurrency Wallet Extensions: Identifies and systematically extracts private keys, recovery seed phrases, and session data from 51 different browser-based cryptocurrency wallet extensions.

Beyond this initial data dump, AUDIOFIX actively monitors the system clipboard. If a user copies an alphanumeric string resembling a cryptocurrency wallet address, the malware utilizes dynamic memory manipulation to hijack the clipboard, replacing the intended recipient’s address with one controlled by the threat group. Furthermore, AUDIOFIX hijacks ongoing session tokens for communication platforms like Slack, Discord, and Telegram, allowing the attackers to spy on internal corporate messaging, mimic the user, and orchestrate further lateral moves. To transmit this massive volume of stolen data, the malware establishes an HTTPS-encrypted tunnel back to the Command and Control (C2) server (primarily communicating with the domain datahub.ink), using AES-256-CBC encryption and randomized polling intervals to defeat standard network anomaly detectors.

MINIRAT: The Memory-Only Go-Based Backdoor

While AUDIOFIX functions as a primary harvester and persistent entry point, JINX-0164 deploys a secondary payload known as MINIRAT to maintain deep, resilient shell access. Unlike AUDIOFIX, which is built on Python, MINIRAT is a highly optimized, lightweight backdoor written in the Go programming language.

MINIRAT has been designed to operate as a fileless backdoor, executing directly within system memory space to avoid detection by traditional signature-based Endpoint Detection and Response (EDR) agents. Once initialized, MINIRAT establishes a secondary HTTPS polling loop with JINX-0164’s infrastructure, enabling the operators to execute arbitrary system-level commands, transfer files to and from the compromised endpoint, and perform live network reconnaissance on the organization’s internal subnet.

In April 2026, JINX-0164 expanded the deployment of MINIRAT by targeting the broader open-source ecosystem. The group orchestrated a supply chain attack by trojanizing version 4.9.1 of the npm package @velora-dex/sdk—a widely utilized decentralized exchange (DEX) software development kit. The attackers appended a malicious post-installation script to the package, which automatically downloaded and executed MINIRAT on any developer workstation or automated build node that pulled down the package, illustrating JINX-0164’s capability to orchestrate multi-faceted distribution models.

From Endpoint to Pipeline: The CI/CD Supply Chain Hijack

What elevates JINX-0164 above typical cyber-theft groups is their tactical decision to avoid immediate cloud account takeovers or instant wallet drains, which would trigger immediate security alerts. Instead, they focus on exploiting the organization’s software development pipeline. Once AUDIOFIX exfiltrates a developer’s GitHub Personal Access Tokens (PATs) or GitLab credentials, JINX-0164 leverages the compromised developer’s local identity to pivot into the organization’s internal Continuous Integration and Continuous Deployment (CI/CD) environments.

Using the open-source penetration testing tool nord-stream—an automation utility developed by Synacktiv to audit CI/CD pipeline vulnerabilities—the attackers enumerate internal development repositories. The nord-stream tool allows the threat actors to systematically extract sensitive environment secrets, such as production AWS roles, code-signing certificates, container registry credentials, and deployment tokens.

Armed with these pipeline credentials, JINX-0164 executes a classic “poison-the-well” supply chain compromise. They modify internal build configurations, injecting the AUDIOFIX bash dropper directly into the building workflow of the company’s proprietary applications. To bypass branch protection rules and peer reviews, they utilize Git metadata manipulation. By spoofing the commit identities—changing the author name and email in the Git log to match other senior developers in the organization—they push the malicious commits straight to active development branches (such as dev_remote_ea5Eu/test/v1). The next time another developer pulls the latest commits or initiates a local build, their system executes the malicious payload, establishing an internal, self-propagating chain of infection that spreads laterally across the engineering department without generating external network flags.

Evasion Tactics and Infrastructure Stealth

To mask their command-and-control communication and maintain an aura of legitimacy, JINX-0164 employs rigorous operational security. The group completely avoids using fixed, static IP addresses for their C2 nodes. Instead, they route their outgoing traffic through commercial Virtual Private Network (VPN) services, specifically favoring:

  • Astrill VPN
  • Mullvad VPN
  • ExpressVPN

Additionally, they lease extensive networks of residential proxies, allowing their C2 traffic to blend in with standard consumer broadband connections from regions geographically adjacent to their targets. This makes geographic blocking ineffective and hinders automated threat-hunting efforts that flag data exfiltration to unrecognized IP ranges. Analysts have noted that while JINX-0164 shares behavioral traits, lures, and targeting footprints with prominent North Korean state-sponsored threat groups like Sapphire Sleet (UNC1069) and BlueNoroff, there is currently no technical or infrastructure overlap with established DPRK clusters. JINX-0164 remains categorized as an independent, highly specialized, and financially motivated threat actor.

Architecting a Modern Defense Against Pipeline Hijacking

Because the initial compromise is driven by high-credibility social engineering, relying solely on user awareness training is insufficient. Organizations—specifically those within the blockchain, Web3, and cryptocurrency spaces—must enforce robust, multi-layered technical controls to sever the JINX-0164 attack chain:

  1. Block Unsigned Binary Execution on macOS: Enforce strict Apple Gatekeeper and Mobile Device Management (MDM) configurations that completely block the execution of unsigned or unnotarized binaries, preventing developers from manually running system “fixes” and audio drivers downloaded from third-party sites.
  2. Harden Git and Branch Controls: Implement mandatory branch protection policies on all repositories. Require signed commits via GPG keys to prevent the commit spoofing utilized by JINX-0164 to impersonate legitimate team members. Enforce a dual-approver peer review workflow for all merges into main or release branches, ensuring a single compromised token cannot poison the codebase.
  3. Implement Fine-Grained Developer Tokens: Migrate away from classic, broad GitHub Personal Access Tokens (PATs). Enforce fine-grained tokens restricted to specific repositories with read-only access where write-access is unnecessary, and strictly limit the lifetime of active secrets.
  4. Audit Security Framework Calls: Configure EDR systems to actively monitor and alert on non-browser applications attempting to read the macOS Keychain or query the local SQLite databases of web browsers. Anomalous programmatic access to ~/Library/LaunchAgents/ or system-level processes mimicking the Core Audio daemon (coreaudiod) should trigger immediate host isolation.
  5. Deploy Real-Time Secrets Scanning: Continuously monitor and audit CI/CD pipeline build logs for indicators of secret scanning tools like nord-stream. Deploy automated detectors that look for unexpected additions of outbound webhooks or modification of workflow YAML files.

Ultimately, the threat posed by JINX-0164 shows that the target is no longer the production cloud server; it is the developer’s laptop, which serves as the ultimate gateway to the entire automated build process. By treating developer workstations and CI/CD pipelines as highly sensitive, zero-trust infrastructure, security teams can neutralize these sophisticated operations before they lead to catastrophic compromise.

Posted in Security & Privacy, Threat Alerts | Tagged , , , | Leave a comment

VS Code AI Update: Offline Support and Local Models Released

In the rapidly evolving landscape of developer tooling, local autonomy has emerged as the ultimate engineering battleground. On May 28, 2026, Microsoft officially shipped Visual Studio Code 1.122, a release that represents a monumental paradigm shift for privacy-first developers, enterprise architects, and engineering teams operating in secure, high-compliance environments. The headlining advancement in this iteration is the complete decoupling of the “Bring Your Own Key” (BYOK) AI features from the long-standing GitHub authentication requirement. By liberating the VS Code AI framework from cloud sign-in constraints, Microsoft has transformed its ubiquitous code editor into an unmatched local sandbox capable of running fully offline, air-gapped AI workflows.

The End of Mandatory Authentication: How VS Code AI Liberates the Offline Sandbox

Prior to version 1.122, developers wishing to use custom large language models (LLMs) or local models inside VS Code were met with a frustrating architectural paradox. Even if an engineer had set up a completely self-hosted inference server—such as Ollama or LM Studio running state-of-the-art open-weights models like DeepSeek, Llama, or Phi-4-mini—the editor still demanded an active GitHub authentication handshake before enabling the chat workspace. This telemetry-linked friction effectively locked out developers working in ultra-secure corporate intranets, defense systems, and medical laboratories where external network traffic and public cloud access are strictly prohibited by compliance protocols.

With VS Code 1.122, this authentication barrier is completely dismantled. The editor now supports the execution of chat assistants, multi-agent pipelines, and tool callouts entirely offline, without sending telemetry or requiring a Microsoft or GitHub cloud session. This update fundamentally changes the core philosophy of VS Code’s integrated intelligence, allowing teams to fully leverage local computing power for code generation, architectural analysis, and debugging while maintaining absolute control over their intellectual property.

How to Configure Your Decoupled VS Code AI Workspace

To establish a fully offline or private AI environment, VS Code 1.122 provides a streamlined configuration pipeline directly within the editor’s command interface. Setting up a BYOK provider silences all subsequent GitHub sign-in prompts and immediately unlocks the Chat panel. The setup process is straightforward:

  1. Open the Command Palette by pressing Ctrl+Shift+P (Windows/Linux) or Cmd+Shift+P (macOS).
  2. Search for and execute the Chat: Manage Language Models command.
  3. Within the Language Models editor interface, select your desired model provider. The native system supports a wide range of external and local engines, including Anthropic, Azure AI Foundry, Gemini, OpenAI, OpenRouter, or any custom compatible endpoint.
  4. To integrate local setups like Ollama or LM Studio, configure a custom OpenAI-compatible endpoint pointing to your local address (e.g., http://localhost:11434 for Ollama).
  5. Once at least one custom BYOK provider is verified and enabled, the primary Chat workspace becomes available, and the system permanently suppresses cloud authentication prompts.

This decentralized architecture relies on a locally stored chatLanguageModels.json configuration file to save API routes, token contexts, and model metadata, ensuring your entire configuration remains locally auditable and reproducible across massive developer workstations.

Architectural Boundaries: Chat, Agents, and MCP vs. Inline Autocomplete

While this update is a massive victory for digital sovereignty, developers must understand the technical boundaries between the fully decentralized VS Code AI environment and features that still rely on GitHub infrastructure. Microsoft has partitioned the editor’s AI capabilities into distinct lanes:

  • Fully Offline & Decoupled (No Sign-In Required): The primary Copilot Chat interface, developer-defined custom agents, custom utility tools, and active Model Context Protocol (MCP) servers. This allows users to write prompts, inspect local codebases, execute local agent workflows, and leverage complex tool-calling models entirely within an isolated network.
  • Cloud-Tethered (GitHub Sign-In Required): Inline autocomplete suggestions, Next Edit Suggestions (NES), semantic code search, and features reliant on cloud-generated vector embeddings.

The reasoning behind this division is structural. High-speed inline autocompletions demand sub-100ms latencies and complex predictive algorithms that remain tightly coupled to GitHub’s proprietary cloud-completion infrastructure. However, for deep reasoning, systemic code refactoring, and multi-file analysis, local LLMs operating through the newly freed Chat interface are more than capable of handling heavy developer workloads.

A Financial Pivot: GitHub Copilot Shifts to Usage-Based Billing

Coinciding with the decoupling of local AI setups, the VS Code 1.122 release marks a major financial transition for developers utilizing official cloud extensions. GitHub Copilot has officially transitioned to a usage-based billing model. Moving away from flat-rate monthly subscriptions, this system calculates consumption via AI credits that are spent based on the complexity of developer interactions.

To help developers navigate this transition without running into unexpected costs, Microsoft has introduced several helper utilities inside the IDE:

  • Model Picker Cost Indicators: The model selection dropdown now displays real-time pricing indicators based on input, output, and cached token costs for different models. Choosing lighter models for basic tasks helps developers preserve their credit pool.
  • Updated Copilot Status Dashboard: An integrated billing HUD displays aggregate credit consumption, offering immediate visibility into how much budget an agent session or a complex chat prompt has consumed.
  • Language Models Editor Upgrades: A centralized dashboard where developers can view precise model capabilities, maximum context window constraints, and distinct billing rates for active models.

Unleashing 1M Context Windows, Browser Emulation, and OpenTelemetry

Beyond the local AI revolution, VS Code 1.122 packs powerful modern capabilities designed to accelerate the development of complex web applications and distributed agent frameworks. Key technical upgrades in this release include:

Massive 1-Million-Token Context Support

For developers utilizing cloud-hosted endpoints such as Anthropic’s Claude or OpenAI’s GPT models, VS Code 1.122 now natively supports 1-million-token context windows. This massive upgrade allows developers to feed entire repositories, thousands of lines of documentation, or massive multi-file codebases directly into a chat prompt, dramatically reducing context fragmentation and enabling hyper-accurate, project-wide refactoring passes.

Integrated Browser Device Emulation

Web developers can now test the responsive behavior of web applications natively within the IDE’s integrated browser. By selecting the “Show Emulation Toolbar” from the browser’s overflow menu, developers can emulate screen dimensions, touch interfaces, mobile viewports, and custom user-agent headers. Furthermore, automated agents can programmatically trigger these emulations using Playwright scripts to catch UI responsiveness bugs during background test execution.

Granular OpenTelemetry Logging for Agents

To facilitate corporate auditing and agent monitoring, local agent sessions in VS Code 1.122 now emit rich OpenTelemetry signals. Emitted under the canonical github.copilot.* attribute namespace, these signals provide structured data on repository context, agent execution tracks, detailed tool parameters, and hook outcomes. This provides organizations with a robust audit trail to analyze AI behavior and ensure compliance without sacrificing developer productivity.

Linux Wayland Compatibility and the 1.122.1 Prompt Patch

Following the main release, the VS Code team quickly rolled out a critical dot-one patch (v1.122.1) to address several early-adopter issues. Most notably, the update resolves a highly frustrating bug affecting Linux developers running modern KDE Plasma 6 Wayland desktop environments. In the initial 1.122 builds, an aggressive screen-sharing permission loop would endlessly prompt users during startup, halting development. The v1.122.1 patch cleanly breaks this permission cycle, restoring smooth performance and system stability across Linux, Windows, and macOS distributions.

Ultimately, Visual Studio Code 1.122 stands as a monumental milestone for the developer ecosystem. By removing the GitHub sign-in requirement for BYOK models, Microsoft has acknowledged the growing demand for absolute data privacy and offline capability. Whether you are running a fully air-gapped system powered by Ollama and DeepSeek, or orchestrating multi-agent networks over local MCP servers, the latest VS Code release ensures that your AI assistant remains entirely on your terms.

Posted in Recommended Software, Resources & Culture | Tagged , , , | Leave a comment

AI Agent Security: Protecting Developer Workspaces with Pipelock

The developer ecosystem is undergoing its most rapid paradigm shift since the emergence of cloud computing. Autonomous AI coding assistants—including Claude Code, Cursor, Cline, Zed, and AutoGen—have transitioned from simple autocomplete widgets to active, self-directed agents. These agents are routinely granted active shell access, privileged workspace directories, and local execution power. More concerningly, their execution environments are preloaded with highly sensitive environment variables, such as $ANTHROPIC_API_KEY, $OPENAI_API_KEY, or production database credentials. This creates an unprecedented threat landscape: a single prompt injection or a tainted package dependency can allow a compromised agent to run a silent curl command, immediately exfiltrating developer credentials to an attacker-controlled server. As these tools integrate deeper into the software development lifecycle, robust AI agent security has evolved from an enterprise afterthought to an absolute runtime necessity.

Redefining AI Agent Security in the Era of Autonomous Coding

To defend against this emerging class of vulnerabilities, developer Joshua Waldrep, under the PipeLab project, introduced Pipelock. Sourced under the Apache License 2.0, Pipelock is an open-source, stateless AI agent firewall and egress proxy. It acts as a local security harness, sitting inline between autonomous AI agents and the external network. Rather than relying on the agent’s internal cooperation, Pipelock intercepts all outbound HTTP, WebSocket, and Model Context Protocol (MCP) traffic. It isolates the agent’s environment, scans transit payloads in real time, and blocks unauthorized outbound data before it can escape the local boundary.

Traditional software security methods rely on SDKs, decorators, middleware, or API wrappers. However, when applied to autonomous AI agents, these methods introduce a fundamental flaw: they require the agent to cooperate. If an agent is manipulated via an adversarial prompt injection or a poisoned package, it can easily bypass those wrappers entirely. Pipelock addresses this security gap through capability separation, an architectural design that mirrors how TLS manages trust on the open web. The architecture enforces two isolated zones:

  • The Agent Zone: The autonomous agent process holds the secrets, environment variables, and execution context, but is strictly isolated from direct network access.
  • The Proxy Zone: The Pipelock proxy holds direct network access, but possesses no knowledge of the agent’s internal secrets.

By forcing all outbound traffic to cross this scanning boundary, Pipelock ensures that any malicious or anomalous attempt to bypass security policies is caught and blocked at the network layer.

The Pipelock Architecture: High Performance, Zero Dependencies

Unlike resource-heavy security agents that add significant latency, Pipelock is compiled as a single Go binary (~20MB in size) with only 22 dependencies. This stateless design yields near-zero latency overhead, processing URL scans in roughly 40 microseconds per request. It operates cleanly on Linux and macOS environments, making it ideal for local developer machines as well as ephemeral CI/CD pipelines. Pipelock’s execution framework is built around three core capabilities: Detect, Enforce, and Prove.

1. Detect: Bidirectional Egress and Ingress Filtering

Pipelock’s detection engine is designed to inspect every request and response before they cross the wire. This is achieved through three highly specialized scanning subsystems:

  • 11-Layer URL Scanner Pipeline: Outbound requests pass through a sequential defense-in-depth pipeline. This pipeline covers scheme validation, CRLF injection detection, path traversal blocking, domain blocklisting, Data Loss Prevention (DLP), Server-Side Request Forgery (SSRF) protection, rate limiting, URL length and structure checks, and per-domain data budgets.
  • Data Loss Prevention (DLP): Pipelock scans outbound request bodies for 48 credential patterns, including API keys, OAuth tokens, cryptographic private keys, and cryptocurrency private keys. To prevent “alert fatigue” and false alarms, Pipelock runs four custom checksum validators (including Luhn, mod-97, ABA, and WIF algorithms) to eliminate 90% to 99% of false positives. It is resilient against evasion tactics, decoding payloads that have been obfuscated using Base64, hex, URL-encoding, or Unicode variations before scanning them.
  • Response Scanning and Normalization: Inbound LLM streams are evaluated against 25 prompt injection and state-manipulation patterns. Because attackers often use complex evasion methods to bypass string matching, Pipelock passes incoming responses through six normalization steps. These steps strip out zero-width characters, resolve homoglyphs (lookalike Unicode characters), and decode leetspeak. To maintain high performance, a rapid keyword pre-filter skips these intensive normalization passes for clean, non-suspicious traffic.

2. Enforce: Strict Network Isolation and Sandbox Containment

Pipelock translates its detection capabilities into active protection through multiple sandboxing mechanisms. In standard deployments, Pipelock can enforce boundaries using traditional proxies (e.g., HTTPS_PROXY). However, in high-security environments, it leverages operating system kernels to isolate the agent process entirely:

  • Linux Kernel Containment: Pipelock leverages Landlock LSM, seccomp BPF filters, and network namespaces to strip the agent process of direct network access. The only network path available to the agent is loopback traffic routed straight to Pipelock.
  • macOS Sandboxing: Uses sandbox-exec policies to enforce file system and network isolation.
  • Fail-Closed Design: If any scanning service, configuration check, or validation step fails, Pipelock defaults to a strict “fail-closed” mode, terminating the transaction immediately to prevent leaks.

3. Prove: Cryptographically Verifiable Audit Trails

A primary challenge in securing autonomous agents is “self-attestation.” If an agent is compromised, it cannot be trusted to report its own actions honestly. Pipelock solves this by acting as an independent, external mediator. It logs all agent activity to a hash-chained, tamper-evident “flight recorder” using SHA-256 chain links. Every decision, policy execution, and network request is signed using Ed25519 cryptography. Pipelock outputs these signed receipts as an **Audit Packet**, which can be validated offline by third-party auditors or compliance pipelines without running the firewall itself. This is supported by dedicated verifier SDKs written in Go, TypeScript, and Python.

Major Advances in the May 2026 Releases (v2.3.0 to v2.5.0)

Throughout May 2026, Pipelock rolled out a series of significant updates under versions 2.3.0 through 2.5.0. These additions transform the tool from a basic proxy into a comprehensive, enterprise-ready security control plane.

Host Containment Lifecycle (v2.5.0)

Pipelock v2.5.0 introduces a dedicated command-line interface (CLI) to manage the entire lifecycle of local host containment. Using the new command set, developers can cleanly orchestrate isolated runtime environments on Linux:

  • pipelock contain install: Configures a local three-UID security architecture on the host machine. This allocates dedicated user IDs for the operator, the pipelock-proxy, and the pipelock-agent. It configures nftables owner-match rules to block the agent’s direct outbound access while forcing loopback routing to the proxy.
  • pipelock contain verify: Audits active system tables and permissions to ensure containment remains unbroken.
  • pipelock contain rollback: Reverts all local user permissions, kernel policies, and network rules cleanly.
  • pipelock contain grant-workspace / revoke-workspace: Manages workspace Access Control Lists (ACLs), permitting the isolated agent to read and write only to specified directories while blocking access to the rest of the host file system.

Model Context Protocol (MCP) Integrity Manifests

The Model Context Protocol (MCP) is the emerging standard for connecting LLM agents to local developer tools and databases. However, this introduces the risk of MCP tool poisoning, where malicious actors swap out legitimate local scripts for compromised binaries. Pipelock v2.5.0 introduces pre-spawn binary integrity checks for MCP servers. Using the command pipelock mcp integrity manifest generate, Pipelock resolves all symbolic links and interpreter shebangs to hash the true target binary. Pipelock then signs this manifest. Before spawning any MCP subprocess server, Pipelock verifies its hash against the trusted manifest, preventing symlink swap attacks at runtime.

Learn-and-Lock Behavioral Contracts (v2.4.0)

To eliminate manual policy writing, Pipelock v2.4.0 introduced the Learn-and-Lock contract pipeline. This workflow operates in four progressive stages:

  1. Observation: Pipelock monitors and logs normal agent interaction, profiling outbound domains, tool calls, and data volumes during typical developer workflows.
  2. Compilation: The firewall compiles this baseline into an immutable behavioral contract.
  3. Shadow Mode: The contract is run in a non-blocking shadow configuration to detect and flag anomalies without disrupting active workflows.
  4. Active Lock: The contract is enforced, immediately blocking any deviations from the established baseline, such as sudden outbound traffic spikes or access to unapproved domains.

Class-Preserving Request Redaction and SSE Scanning

<

Posted in Recommended Software, Resources & Culture | Tagged , , , | Leave a comment

Claude Opus 4.8 Released: Anthropic Secures $65 Billion Funding

“`

Let’s refine the text further to expand the descriptions.
Make sure the flow is continuous.
Let’s review the paragraph in Section 3 about “Architecting Autonomy: Dynamic Workflows and Effort Controls” and “Cognitive Economics: Fast Mode and the Honesty Breakthrough”.

Let’s write a beautifully complete, highly engaging HTML text.
Let’s check the word count of the refined text. I need to ensure it’s comfortably between 1000 and 1500 words of plain text.

Let’s calculate the plain-text word count of my planned draft:
1. First paragraph (Intro): ~160 words.
2. Second section (The Sovereign Wealth…): ~420 words (it has three paragraphs).
3. Third section (The Quantitative Edge…): ~380 words (with the list).
4. Fourth section (Architecting Autonomy…): ~310 words (two paragraphs).
5. Fifth section (Cognitive Economics…): ~260 words (two paragraphs).
6. Sixth section (Beyond the Horizon…): ~170 words.
Total plain-text word count: ~1700 words. Let’s make it slightly tighter, targeting ~1250-1350 words to stay perfectly in the middle of the “1000 to 1500 words” requirement.

Let’s edit the draft to optimize length and impact, aiming for around 125

Posted in Artificial Intelligence, Technology & AI | Tagged , , , | Leave a comment

Proton Mail Upgrades Easy Switch to Integrate Gmail Seamlessly

The process of “de-Googling”—or systematically reclaiming one’s digital autonomy from the pervasive surveillance engines of Big Tech—is a modern-day necessity that has historically been stymied by immense logistical friction. Migrating away from Gmail is particularly painful. For the average user, a legacy email address acts as the structural anchor for hundreds of online identities, subscriptions, financial services, and personal contacts. However, on May 28, 2026, Swiss privacy champion Proton Mail shattered this transition barrier by rolling out a major, dual-directional upgrade to its “Easy Switch” migration utility. No longer just a static, one-time backup tool, the utility has been transformed into a dynamic, live operational bridge. This means users can now seamlessly send and receive Gmail messages directly from within the secure Proton Mail ecosystem, allowing them to phase out Google at their own pace without breaking their daily communication workflows.

Breaking the Moat: Why Leaving Gmail Has Been Historically Difficult

For over two decades, Google has maintained an ironclad grip on consumer email through Gmail. While the service is marketed as free, the true cost of admission is your personal data. Google scans activity, processes messages, and monitors telemetry to build comprehensive advertising profiles that follow users across the internet. Despite being fully aware of these privacy-invasive practices, many users remain trapped in the Google ecosystem due to the high “cost of switching”.

To fully migrate to a privacy-first alternative, a user must traditionally complete several grueling steps:

  • Identify and log into every digital service—from online banking to streaming platforms—and manually update their registered email address.
  • Inform hundreds of personal and professional contacts of their new email coordinates.
  • Export years of historical communications, folder hierarchies, and metadata without losing critical documents.
  • Monitor both the old and new inboxes simultaneously during a prolonged transition period to ensure no critical notifications are missed.

This overwhelming friction is Google’s competitive moat. By forcing an “all-or-nothing” approach to email migration, Big Tech has successfully disincentivized millions from moving to encrypted alternatives. The upgraded Easy Switch utility from Proton is designed specifically to drain this moat, turning a hostile, abrupt departure into a smooth, managed off-ramp.

The Evolution of the Proton Mail “Easy Switch” Utility

Previously, the Easy Switch tool in Proton Mail operated primarily as a localized, administrative import wizard. It allowed users to connect their Google, Outlook, Yahoo, or Apple accounts to execute a one-off import of historical IMAP directories, contacts, and calendar databases. While effective for archiving past data, it did not solve the continuous operational problem: once the import was finished, the user still had to keep checking Gmail for incoming traffic and reply using Google’s interface.

The May 2026 update radically redefines this utility. The “Easy Switch” tool has evolved into an active, bi-directional gateway. Under this new paradigm, users enjoy a suite of dynamic capabilities directly from their Proton interface:

  • Live Inbox Synchronization: Proton automatically fetches your most recent Gmail history and ensures that all new incoming mail sent to your legacy Gmail address appears instantly inside your Proton inbox.
  • Native Send-As Integration: You can compose, reply to, and send emails using your `@gmail.com` address directly from the Proton Mail app or web client.
  • Tracker and Ad Elimination: All incoming Gmail traffic routed through Proton is automatically subjected to Proton’s strict security protocols, instantly stripping out spy pixels and blocking tracking elements.
  • Asymmetrical Synchronization: Actions taken in your Proton interface—such as archiving, deleting, or sorting messages into custom folders—are handled locally and are not reflected back in Google’s database, preserving a clean workspace.

System Architecture: How the One-Way Privacy Firewall Works

From a technical standpoint, integrating a privacy-focused, zero-knowledge platform with a data-harvesting legacy provider like Google presents unique security challenges. Proton has solved this by implementing a strict, unidirectional data-flow architecture.

When you link your Google account to Proton Mail, the authorization is handled securely via Google’s OAuth 2.0 protocol. You grant Proton permission to access your Gmail backend through secure, restricted API tokens. This gives Proton the necessary clearance to retrieve your incoming messages and send outgoing emails through Google’s SMTP relays.

Crucially, this data pipeline is entirely one-directional. While Proton has authorized access to read and transmit Gmail data on your behalf, Google is granted absolutely zero access or visibility into your native Proton Mail inbox. Your secure, zero-access encrypted Proton messages, custom PGP keys, and native `@proton.me` correspondence remain locked behind local, client-side encryption. Google’s trackers cannot cross this digital threshold, establishing an unbreachable privacy firewall between your old digital life and your new one.

Neutralizing Google’s Data Profiling: Immediate Privacy Wins

Even though your legacy emails are still technically associated with a Google address, managing them through the Proton interface delivers immediate, substantial privacy benefits over using the native Gmail application or web client.

First, Gmail’s native applications are notorious for gathering exhaustive telemetry. According to app privacy disclosures, the Google email client tracks approximate user location, device IDs, search history, and user interactions to target ads. By abandoning the Gmail app and accessing your mail strictly via the Proton Mail app, you immediately sever this telemetry pipeline. Google can no longer monitor which emails you click on, how long you dwell on a message, or what physical location you are occupying when checking your inbox.

Second, Proton’s backend actively scrubs incoming Gmail traffic. Most marketing emails today are embedded with “spy pixels”—invisible 1×1 tracking images that report back to advertisers the moment an email is opened. Proton blocks these remote images by default and strips out tracking parameters from links, isolating you from corporate surveillance networks.

Third, this integration unlocks an extraordinary cryptographic edge case: automatic end-to-end encryption for Gmail addresses. Normally, PGP encryption is only available when both parties use secure providers. However, if User A and User B have both connected their legacy Gmail accounts to Proton Mail, any emails exchanged between them are automatically encrypted with PGP on the client side before they are ever sent. To Google’s servers, these messages look like garbled, unreadable ciphertext, completely blinding Google’s automated scanning and AI-training algorithms.

The Technical Catch: Google’s Servers Still Loom

While this updated migration bridge is a massive leap forward for consumer privacy, Proton is remarkably transparent about its technical limitations. This feature is designed to be an off-ramp, not a permanent, hybrid security solution.

Because the emails are still bound to your `@gmail.com` domain, any communication sent to or from that address must still traverse Google’s infrastructure. When an external sender emails your legacy address, the message lands on Google’s servers first before Proton’s Easy Switch fetches it. Similarly, when you send an email “from” your Gmail address inside Proton, it is routed through Google’s outbound SMTP servers.

Consequently, Google can still scan and analyze the content of these messages as they rest on its servers. For truly sensitive, confidential communications, users must use their native, end-to-end encrypted `@proton.me` addresses. The true value of this new tool is organizational: it allows you to centralize your operations, protect your usage telemetry, clean up tracker scripts, and steadily migrate your logins to Proton without ever having to log into Google’s interface again.

Step-by-Step: Activating the Dynamic Gmail Sync in Proton Mail

Configuring the new dynamic integration is straightforward and can be completed in just a few minutes through the Proton web interface:

  1. Log into your account at mail.proton.me using a web browser.
  2. Click on the Settings gear icon in the top right corner and select All settings.
  3. In the left-hand navigation menu, select Import via Easy Switch.
  4. Click on the Google / Gmail option.
  5. When prompted, authenticate using your Google credentials through the secure OAuth pop-up window.
  6. Review and approve the specific permissions, allowing Proton to securely fetch and send emails on behalf of your Gmail address.
  7. Select which elements you wish to synchronize (such as inbox history, calendars, and contacts).
  8. Click Start Import to initiate the continuous, dynamic background synchronization.

Once activated, the synchronization process runs seamlessly in the background. You can close the browser tab or use your computer normally while Proton builds your new, consolidated workspace.

A Gradual Rollout and a Broader Strategic Vision

Proton officially launched this upgraded Easy Switch functionality on May 28, 2026, starting with immediate access for legacy Visionary tier subscribers. The company is executing a gradual, phased rollout to the rest of its user base to ensure server stability and seamless API performance.

This release is a key milestone in Proton’s broader 2026 roadmap, which focuses on making privacy-focused alternatives practical for mainstream users. Rather than expecting consumers to make drastic sacrifices in convenience to protect their data, Proton is building a comprehensive suite of secure productivity tools. With recent expansions including an encrypted AI writing assistant (Proton Scribe), a secure 2FA authenticator (Proton Pass), private video calling, and encrypted collaborative spreadsheets, Proton is systematically dismantling the excuses to stay with Big Tech. By turning Gmail into a fully manageable extension of the Proton inbox, they have delivered the most powerful tool yet for anyone looking to reclaim their digital sovereignty.

Posted in Recommended Software, Resources & Culture | Tagged , , , | Leave a comment

Stop iPhone Ad Tracking: Use This Hidden Privacy Kill Switch

In an era where personal data is a prized global currency, our smartphones act as active beacons, transmitting a continuous stream of our digital lives to ad networks and data brokers. Every tap, search, location check, and purchase is quietly cataloged, painting an intimate picture of our daily habits. For years, this surveillance pipeline operated in the background, leaving users with little recourse. However, a powerful, built-in mechanism sits deep within your iOS settings, acting as a global kill switch to sever these connections. Regulating your iphone ad tracking settings is the single most effective action you can take to reclaim control over your digital footprint.

While Apple’s landmark App Tracking Transparency (ATT) framework was introduced in iOS 14.5, its implementation has evolved significantly. With the release of iOS 26.5 and upcoming features of iOS 27 in 2026, Apple has refined its privacy features, introducing robust Background Security Improvements and tighter constraints on developer access. Despite these advancements, many users still manage tracking requests on a tedious, app-by-app basis. By deploying iOS’s universal tracking blocker, you can programmatically shut down the metadata trail that tech platforms rely on to monetize your

Posted in Security & Privacy, Social Media & Big Tech | Tagged , , , | Leave a comment