️ Updates from the opening round at Shinnecock Hills
️ Preview | Follow us on Instagram | Mail Matt

Good news! “Round 1 of the U.S. Open at Shinnecock Hills will resume at 9:05 a.m. ET.” So says the official tweet. That’s just over 15 minutes away.

Weather delay in the golf but they’re playing at the Oval. Should be the other way round surely?

Former presidents, heads of state and celebrities converged on a lakefront park in Chicago’s South Side to dedicate the Obama Presidential Center

• Sign up for the Breaking News US email

He calls the situation a “win-win” for the US.

Vance is here, and he starts by claiming that Trump’s peace deal with Iran “is already bearing real fruits for the American people”, with 12.5m barrels going through the strait of Hormuz last night and gas prices dropping below $4 today for the first time since the conflict began.

Sen. Bernie Sanders talks with NPR's Juana Summers about his new legislation, which would create a sovereign wealth fund, and give the American people a say in regulating AI.

⚽️ Kick-off time: 12pm local time/3pm EDT/8pm BST/5am AEST
⚽️ Player guide | Bracketology | Golden Boot | Email Daniel

Some more mails:

“Hello Daniel,” says regular correspondent, Krishna Moorthy. “Can’t believe this is your first MBM!”

Hi there. I just want to say, as someone born and raised in the US, that soccer will never be a truly major sport here until it’s shown on regular TV, and that’s not happening without ad breaks. I don’t write to praise US capitalism or the media landscape it produces! I only acknowledge that that’s the country I live in.

Former presidents, heads of state and celebrities converged on a lakefront park in Chicago’s South Side to dedicate the Obama Presidential Center

• Sign up for the Breaking News US email

He calls the situation a “win-win” for the US.

Vance is here, and he starts by claiming that Trump’s peace deal with Iran “is already bearing real fruits for the American people”, with 12.5m barrels going through the strait of Hormuz last night and gas prices dropping below $4 today for the first time since the conflict began.

All living former presidents gathered for the dedication of the Obama presidential center in Chicago. It was a star studded event that harkened back to a more-optimistic era in American politics.

️ Updates from the opening round at Shinnecock Hills
️ Preview | Follow us on Instagram | Mail David

Good news! “Round 1 of the U.S. Open at Shinnecock Hills will resume at 9:05 a.m. ET.” So says the official tweet. That’s just over 15 minutes away.

Weather delay in the golf but they’re playing at the Oval. Should be the other way round surely?

They can put the matches away, at least for a while. Before this game, Hugo Broos had responded to fierce criticism over South Africa’s start to the World Cup by revealing that eight months ago after qualification a friend had said they would erect a statue of him and the coach had replied by saying: “Make it out of wood; that way it will burn more easily.” Beaten 2-0 by Mexico, they were seven minutes away from following that with a 1-0 loss to Czechia, left with no points, no goals and not much hope. But from almost nowhere, in an arena that Broos criticised as “not a football stadium”, they got the penalty that allows them to fight another day.

Pavel Sulc was the unfortunate man who gave it away, not given time to remove his hand from the path of another long shot. Teboho Mokoena was the man who scored it and what it means could be seen not only in how he celebrated then but in the tears that had rolled during the national anthem before.

⚽️ Kick-off time: 3pm local/6pm EDT/11pm BST/8am AEST
⚽️ Player guide | Bracketology | Golden Boot

Canada’s head coach Jesse Marsch makes two changes. Cyle Larin, who came off the bench to equalise against Bosnia and Herzegovina, and Ali Ahmed come in for Liam Millar and Tani Oluwaseyi. Alphonso Davies is among the substitutes.

Qatar are unchanged.

Former presidents, heads of state and celebrities converged on a lakefront park in Chicago’s South Side to dedicate the Obama Presidential Center

• Sign up for the Breaking News US email

He calls the situation a “win-win” for the US.

Vance is here, and he starts by claiming that Trump’s peace deal with Iran “is already bearing real fruits for the American people”, with 12.5m barrels going through the strait of Hormuz last night and gas prices dropping below $4 today for the first time since the conflict began.

Two payments of $50m will boost Ukraine’s air defence and munitions supply. Follow today’s news live

• Get our breaking news email, free app or daily news podcast

AFL great Tony Modra has been seriously injured in a truck accident on his South Australian property, Australian Associated Press reports.

Modra, renowned as one of the AFL’s most brilliant players in a career spanning 1992 to 2001 at Adelaide and Fremantle, was in hospital in a serious condition with undisclosed injuries on Thursday night.

What happens in Ukraine matters here in the Indo-Pacific, which is why it is so important for Australia to stay the course and continue to stand with Ukraine until they find peace on their terms.

Wealth tax criticized by billionaires and Gavin Newsom would levy a one-time 5% tax on residents worth over $1bn

A popular proposal in California to impose a wealth tax on billionaires has gained enough signatures to qualify for the ballot in November, state officials announced on Wednesday.

The news is set to intensify an already heated debate around the tax, which has pitted tech moguls and the state’s governor, Gavin Newsom, against the labor union backing the measure.

Wealth tax criticized by billionaires and Gavin Newsom would levy a one-time 5% tax on residents worth over $1bn

A popular proposal in California to impose a wealth tax on billionaires has gained enough signatures to qualify for the ballot in November, state officials announced on Wednesday.

The news is set to intensify an already heated debate around the tax, which has pitted tech moguls and the state’s governor, Gavin Newsom, against the labor union backing the measure.

Wealth tax criticized by billionaires and Gavin Newsom would levy a one-time 5% tax on residents worth over $1bn

A popular proposal in California to impose a wealth tax on billionaires has gained enough signatures to qualify for the ballot in November, state officials announced on Wednesday.

The news is set to intensify an already heated debate around the tax, which has pitted tech moguls and the state’s governor, Gavin Newsom, against the labor union backing the measure.

Interior department insists water at Washington landmark is ‘crystal clear’ as witnesses report murky green pool

US federal government workers continue take on the green hue that has swept across Washington’s reflecting pool, an increasingly fiendish battle the Trump administration compared to its war with Iran.

After Donald Trump ordered a $14.2m refurbishment to turn the monument “American Flag blue” in time for the country’s 250th birthday celebrations, the administration encountered a formidable foe: algae.

Interior department insists water at Washington landmark is ‘crystal clear’ as witnesses report murky green pool

US federal government workers continue take on the green hue that has swept across Washington’s reflecting pool, an increasingly fiendish battle the Trump administration compared to its war with Iran.

After Donald Trump ordered a $14.2m refurbishment to turn the monument “American Flag blue” in time for the country’s 250th birthday celebrations, the administration encountered a formidable foe: algae.

Interior department insists water at Washington landmark is ‘crystal clear’ as witnesses report murky green pool

US federal government workers continue take on the green hue that has swept across Washington’s reflecting pool, an increasingly fiendish battle the Trump administration compared to its war with Iran.

After Donald Trump ordered a $14.2m refurbishment to turn the monument “American Flag blue” in time for the country’s 250th birthday celebrations, the administration encountered a formidable foe: algae.

For the last year, AI agents have been getting more powerful.

The problem?

Most of them still felt like developer tools.

You had to work in terminals, manage configuration files, memorize commands, and scroll through endless logs just to understand what your agent was doing.

That’s fine if you’re a developer.

But if AI agents are going to become mainstream, they need something else:

A great user experience.

That’s exactly what Hermes Agent’s newly released Desktop App delivers.

🎥 Full video walkthrough

🤔 The Biggest Problem With AI Agents

Most AI agent frameworks have incredible capabilities:

• Browse the web
• Read and write files
• Execute code
• Automate workflows
• Use multiple tools
• Coordinate sub-agents

But using them often looks like this:

❌ Terminal windows everywhere
❌ Session IDs to manage manually
❌ Configuration files to edit
❌ Logs that are difficult to understand
❌ Very little visibility into what the agent is actually doing

For experienced developers, this is manageable.

For everyone else, it’s a major barrier.

🧠 What Is Hermes Agent?

Hermes Agent is an open-source AI agent framework created by the team at Nous Research.

It can run locally on your machine or on remote servers and connect to multiple AI providers including:

🧩 OpenAI
🌐 Gemini
🧠 Claude
🏠 Local models through Ollama
🔌 Other supported providers

Once connected, Hermes can:

• Browse the web
• Analyze documents
• Run terminal commands
• Automate workflows
• Send messages
• Manage emails
• Create and execute multi-step plans

Think of it as an autonomous AI worker that can actually take action instead of only generating text.

✨ The Desktop App Changes Everything

The new desktop application provides a complete visual interface for managing and monitoring AI agents.

Instead of wondering what your agent is doing, you can now see everything.

📂 Session Management

Conversations are automatically organized.

Sessions are grouped by profile, making it much easier to manage multiple agents with different responsibilities.

You can also switch models with a single click without diving into configuration files.

🔍 Watch Your Agent Work

One of the most impressive features is transparency.

You can inspect:

🔎 Tool calls
📚 Sources used by the agent
⚙️ Workflow execution steps
🧠 Reasoning process
📈 Agent progress

This is incredibly useful when debugging workflows or understanding why an agent made a particular decision.

Most AI agent platforms treat this as a black box.

Hermes makes it visible.

🎙️ Voice Interaction

Hermes supports voice input directly from the desktop app.

You can simply speak to your agent and let the local transcription system convert speech into text.

Small feature.

Huge usability improvement.

👤 Profiles: Specialized AI Agents

This might be my favorite feature.

A Hermes Profile is essentially its own AI agent.

Each profile can have:

📝 Independent instructions
🧠 Separate memory
🛠️ Different tools
📚 Different skills
⚡ Unique capabilities

For example:

• Software Engineering Agent
• Research Agent
• Content Creation Agent
• Marketing Agent
• Stock Research Agent

Instead of one general-purpose assistant, you can build an entire team of specialized AI workers.

🛠️ Skills and Tools

Hermes includes a powerful skill system.

What’s particularly interesting is that Hermes can generate new skills from your conversations over time.

The more you use it, the more personalized it becomes.

You can also selectively disable skills to:

🎯 Reduce context size
💰 Save tokens
⚡ Improve performance

This is a subtle feature that becomes very important at scale.

💬 Messaging Integrations

The desktop app supports integrations with external platforms such as:

💬 Discord
📱 Telegram
📨 WhatsApp
🔗 Other supported channels

Your agents can communicate and deliver updates outside the desktop application itself.

This opens the door to some very interesting automation workflows.

📦 Artifacts: Everything In One Place

One challenge with AI agents is finding things they created days ago.

Hermes solves this with Artifacts.

Generated files, images, links, and outputs are automatically collected into a centralized workspace.

No more hunting through old conversations.

⚙️ Advanced Settings For Power Users

The settings panel exposes a surprising amount of customization.

You can configure:

⚙️ AI Providers
🔑 API Keys
🎨 Appearance
🔌 MCP Integrations
🎙️ Voice Settings
🛠️ Tool Configuration
🌐 Gateway Settings

You can even assign different models to different tasks.

For example:

• One model for reasoning
• Another for vision
• Another for web extraction

This level of flexibility is something advanced users will appreciate.

⏰ Autonomous Scheduled Agents

One feature I think is massively underrated:

📅 Cron Jobs

You can schedule agents to run automatically.

Examples:

📈 Daily stock market reports
📧 Email summaries
📰 Industry news monitoring
🏢 Competitor tracking
📊 Business intelligence reports

You define:

• The task
• The schedule
• The delivery destination

Then Hermes runs it automatically.

Your AI agent becomes proactive instead of reactive.

👥 Multi-Agent Visibility

When Hermes encounters a complex task, it can spawn additional agents to help complete the work.

The Desktop App includes a dedicated view for monitoring these sub-agents.

You can watch:

👥 Which agents were created
📋 What tasks they are handling
🔄 Their current progress
🎯 How work is being coordinated

For anyone interested in multi-agent systems, this is fascinating to observe.

🎯 Why This Matters

The most important thing about this release isn’t the interface itself.

It’s what it represents.

AI agents are moving from:

“Developer-only tools”

to

“Tools anyone can use.”

The Desktop App dramatically lowers the barrier to entry while preserving the power that makes Hermes compelling.

And that’s exactly what the AI agent ecosystem needs right now.

What feature do you think is still missing from modern AI agent platforms? Let me know in the comments.

React 19 Concurrent Rendering Deep Dive: Actions, Transitions, and Suspense in Production

Most React performance issues stem from treating async operations as blocking events. Teams wrap every network call in loading states, freeze the UI during mutations, and sacrifice responsiveness for correctness. React 19's concurrent rendering model solves this by allowing the framework to interrupt, pause, and resume rendering work based on priority. The result: smooth interactions even when expensive operations run in the background.

This matters because users perceive UI responsiveness in milliseconds. A search input that stutters while filtering 10,000 rows feels broken. A form submission that freezes the page destroys trust. Concurrent rendering keeps the UI responsive by deferring low-priority updates and batching state changes intelligently.

Understanding React 19's Concurrent Architecture

React 19 ships concurrent features that were experimental in 18: Actions, useTransition, startTransition, and coordinated Suspense. These primitives share a common foundation—React can now split rendering work into chunks and prioritize user input over background computation.

The architecture introduces two update lanes: urgent and transition. Urgent updates (keystrokes, clicks) render immediately. Transition updates (data fetching, heavy calculations) yield to urgent work. When a transition is pending, React shows the last committed UI instead of a loading spinner. This preserves perceived performance.

The failure mode with traditional React is visible: developers chain useState with async handlers, manually toggle loading booleans, and end up with jittery UIs where typing lags because the component re-renders on every network response. Concurrent rendering eliminates this by handling update priority automatically.

Actions and useTransition: Making Async Updates Smooth

Actions formalize async state transitions in React. The useTransition hook returns [isPending, startTransition]. Wrap any state update in startTransition and React marks it as non-urgent. The isPending boolean tracks whether the transition is active, enabling granular loading indicators without blocking the UI.

The diagram shows how urgent updates (typing) interrupt transition updates (filtering). React commits the input value immediately but defers the expensive filter operation. When the user types again, React abandons the in-progress transition and starts fresh. This prevents stale results from appearing after the user has moved on.

The implication here is that developers no longer debounce inputs manually or manage request cancellation. React handles interruption automatically. If a transition takes 500ms and the user types again at 300ms, React discards the first transition and starts the second. The UI stays responsive.

Building a Real-World Search with useTransition and startTransition

Consider a product catalog with 5,000 items. Filtering on every keystroke without concurrent rendering causes visible lag. The pattern below shows how useTransition isolates the expensive filter operation from the input update.

import { useState, useTransition } from 'react';

interface Product {
  id: string;
  name: string;
  category: string;
  price: number;
}

function ProductSearch({ products }: { products: Product[] }) {
  const [query, setQuery] = useState('');
  const [filteredProducts, setFilteredProducts] = useState(products);
  const [isPending, startTransition] = useTransition();

  const handleSearch = (value: string) => {
    // Urgent: update input immediately
    setQuery(value);

    // Non-urgent: filter in the background
    startTransition(() => {
      const results = products.filter(p =>
        p.name.toLowerCase().includes(value.toLowerCase()) ||
        p.category.toLowerCase().includes(value.toLowerCase())
      );
      setFilteredProducts(results);
    });
  };

  return (
    <div>
      <input
        type="text"
        value={query}
        onChange={(e) => handleSearch(e.target.value)}
        placeholder="Search products..."
        className={isPending ? 'opacity-50' : ''}
      />
      <div className="grid grid-cols-4 gap-4">
        {filteredProducts.map(product => (
          <ProductCard key={product.id} product={product} />
        ))}
      </div>
      {isPending && <div className="spinner" />}
    </div>
  );
}

The input value updates synchronously—no lag. The filter operation runs as a transition, yielding to new keystrokes. The isPending flag dims the input and shows a spinner without freezing the page. This pattern scales to datasets 10× larger because React batches the transition work and prioritizes user input.

React concurrent rendering architecture diagram

The key distinction: urgent updates commit immediately and transition updates can be interrupted. Without this separation, every keystroke blocks until the filter completes. The user perceives stuttering. With transitions, the UI stays fluid and React discards stale work automatically.

useOptimistic: Instant Feedback While Requests Process

Optimistic updates show the intended result before the server confirms. React 19's useOptimistic hook manages this pattern. Pass the current state and an update function; React returns the optimistic state and a setter. When the server responds, React reconciles with the real data.

import { useOptimistic } from 'react';

interface Message {
  id: string;
  text: string;
  status: 'sending' | 'sent' | 'error';
}

function ChatThread({ messages, onSend }: {
  messages: Message[];
  onSend: (text: string) => Promise<Message>;
}) {
  const [optimisticMessages, addOptimistic] = useOptimistic(
    messages,
    (state, newMessage: Message) => [...state, newMessage]
  );

  const handleSubmit = async (text: string) => {
    const tempMessage: Message = {
      id: crypto.randomUUID(),
      text,
      status: 'sending'
    };

    addOptimistic(tempMessage);

    try {
      const confirmedMessage = await onSend(text);
      // React reconciles when messages prop updates
    } catch {
      // React reverts optimistic state on error
    }
  };

  return (
    <div>
      {optimisticMessages.map(msg => (
        <div key={msg.id} className={msg.status === 'sending' ? 'opacity-60' : ''}>
          {msg.text}
        </div>
      ))}
    </div>
  );
}

The optimistic message appears instantly. When the server confirms, React merges the real message by ID. If the request fails, React reverts the optimistic state. This approach eliminates the perceived delay between user action and UI feedback. For forms and chat interfaces, this distinction is critical.

Developers often implement optimistic updates with manual rollback logic and complex state synchronization. useOptimistic handles reconciliation automatically. The hook works with transitions—wrap the server call in startTransition and React coordinates the optimistic update with the async response. Read more about this pattern in useOptimistic React 19 Guide.

Suspense Boundaries in Production: Coordinating Async States

Suspense boundaries define loading states declaratively. Wrap async components in <Suspense fallback={...}> and React shows the fallback while waiting. With concurrent rendering, Suspense coordinates multiple boundaries intelligently. React batches updates and avoids cascading spinners.

The diagram shows nested Suspense boundaries. The auth boundary resolves first, then the data boundary. React shows progressive fallbacks instead of a single top-level spinner. When both resolve, the complete UI renders in one commit. This prevents layout shift and flickering.

The practical implementation isolates async operations in separate components. The parent wraps each in Suspense with a specific fallback. React coordinates the loading sequence and batches the final commit. This pattern scales to complex UIs with dozens of async dependencies.

Concurrent rendering performance comparison

Teams often nest Suspense boundaries incorrectly—wrapping the entire page instead of isolating independent async sections. The result: one slow request blocks the entire UI. Granular boundaries allow fast sections to render while slow sections show fallbacks. React handles the coordination automatically.

Concurrent Rendering vs Traditional Rendering: Performance Comparison

Traditional rendering blocks on every state update. A 300ms filter operation freezes the input until complete. Concurrent rendering splits work into chunks and yields to higher-priority updates. The difference in perceived performance is measurable.

The traditional path blocks the UI for 300ms every keystroke. The concurrent path updates the input synchronously and defers the filter. If the user types again, React abandons the in-progress filter and starts fresh. The user never experiences lag.

Benchmarks show 60% reduction in input lag for transition-wrapped updates. The cost: additional memory for tracking transition state. The tradeoff favors responsiveness—most production apps benefit from this exchange. The failure mode is subtle: transitions that complete instantly add overhead without benefit. Use transitions for operations exceeding 100ms.

Production Patterns: Combining Actions, Transitions, and Suspense

The most powerful pattern combines all three primitives. An async form submission uses useTransition for the mutation, useOptimistic for instant feedback, and Suspense for dependent data. React coordinates the entire flow without manual state management.

The flow starts with user action. The transition marks the mutation as non-urgent. The optimistic update shows the intended result. The server responds, and Suspense refetches dependent data. React commits all updates in one batch. The UI never blocks, and the user sees instant feedback.

This pattern eliminates the traditional loading state machine. No boolean flags for isLoading, isError, isSuccess. React manages state transitions through Suspense and transition hooks. The code stays declarative and the performance characteristics improve. For complex forms and multi-step wizards, this approach is essential.

Integration with state management libraries like Jotai enhances this pattern further. Atoms wrap async logic, Suspense handles loading states, and transitions coordinate updates. The combination scales to enterprise applications with hundreds of async dependencies. Learn more in Jotai Atomic State Management React.

Adopting Concurrent Features: Migration Strategy and Performance Wins

Migration starts with identifying blocking operations. Profile the app with React DevTools and find setState calls that cause jank. Wrap expensive updates in startTransition. Add Suspense boundaries around async components. Measure before and after with the Profiler.

The incremental approach works: migrate one feature at a time. Start with search inputs and infinite scroll—these show immediate improvement. Move to forms and mutations next. Finally, adopt Suspense for data fetching. Each step delivers measurable wins without requiring a full rewrite.

The performance gain is consistent: 40-60% reduction in blocking time for heavy UIs. Memory overhead increases slightly (5-10%) due to transition tracking. The tradeoff favors user experience. Teams that adopt concurrent rendering report higher engagement and lower bounce rates. The investment pays off quickly.

Developers building complex TypeScript applications will find concurrent patterns integrate cleanly with existing patterns. Type safety extends to Actions and transitions without friction. For desktop apps built with Electron, concurrent rendering improves perceived performance of CPU-intensive operations. See Extend Your Electron Desktop App with TypeScript for integration details.

That covers the essential patterns for React 19 concurrent rendering. Apply these in production and the difference will be immediate.

This is a submission for the June Solstice Game Jam

What I Built

Turing's Dawn is a browser puzzle game where daylight is a resource that drains in real time, and the only way to hold back the dark is to break the codes a vanished mind left behind.

On the longest day of the year, the light starts running out. You're stranded in the seam between the longest day and the shortest night, and a daylight meter drains the entire time you're solving. Six chambers, six codebreaking disciplines — a Caesar dial, a binary sunrise, a logic-gate garden, the pattern of days, an honest-to-goodness Turing machine, and a final Vigenère "Dawn Key" assembled from every fragment you collect. Solve a chamber and you claw some light back; stall, and the screen literally closes in — a vignette deepens, the edges bleed red, and a heartbeat starts up under the music.

My goal was to make the solstice theme mechanical, not decorative. "Longest day → shortest night" isn't a backdrop painted behind a cipher game — it's the pressure. Daylight is a real, draining clock, so the theme becomes a verb you can lose. And the whole thing is an ode to Alan Turing, who broke codes to push back a darkness of his own, and whose dawn came far too late.

Video Demo

https://youtu.be/kwdbez-77X8?si=WnSFTmtgGdSi5NRe

Code

https://github.com/pooja-bhavani/Turing-s-Dawn

How I Built It

Stack: React + TypeScript + Vite, Tailwind v4, Framer Motion for the juice, the Web Audio API for a drone / heartbeat / solve-chime built entirely in code, Google Gemini for adaptive hints, and Vitest for the engine. No game backend — it's a static site.

A few decisions I'm happy with:

• The clock changes everything. Light drains on a requestAnimationFrame loop while you play. That one mechanic turns "decode this string" into "decode this string before the dark wins" — and the soft-fail, the heartbeat, the vignette, and the score chase all fell out of it. To keep it fair, the timer pauses during narrative beats and end screens, and failure is soft: run out of light and the chamber waits — you rekindle and retry with no progress lost.
• The chamber I'm proudest of — "The Bombe." It doesn't ask you to describe a Turing machine; it makes you run one. You get a tape, a head, a state, and a rules table. You read the cell under the head, the matching rule lights up, you Step — head moves, cell rewrites, state changes — until it halts, then lock in what the tape reads. It animates a pure, unit-tested traceTuring() engine, so the UI is just drawing real machine configurations one step at a time. That's the ode I wanted: not a portrait of Turing, but a few minutes spent thinking the way his machines did.
• Every cipher is a hands-on instrument, never a plain text box: a Caesar dial you rotate, binary sunrise lamps you tap to read each byte, a logic-gate garden of switches that light the network live, sequence tiles for the pattern, the step-through Bombe, and the Dawn Key that aligns your collected fragments under the final Vigenère cipher.
• A living, AI-powered hint guide (Google Gemini). When you ask for help, gemini-2.5-flash reads the puzzle and the attempt you just typed and writes a fresh, in-character coach line that escalates with the tier. The hard part was spoiler-safety — LLMs love to blurt the answer — so the architecture is built to prevent it (details below).
• Built to be provably solid. The whole cipher engine is pure TypeScript — no React, no DOM, no side effects — so it's fully unit-tested with Vitest. Every chamber in the data file is proven solvable, every verifier proven to reject near-misses, and the Turing trace is tested to agree with the run-to-halt result and to terminate even on pathological rule sets. The game is data-driven: adding a chamber is a JSON entry, not new code.
• Accessible by default. Keyboard-playable throughout, prefers-reduced-motion aware, ARIA live regions announce the light meter / hints / narrative, color is never the only signal, and the synthesized audio only starts on your first click with a mute toggle that persists.

Prize Category

Best Ode to Alan Turing. The whole game is built around him. Every chamber is a codebreaking puzzle in the lineage of his work, and the hero chamber — "The Bombe" — puts you inside an interactive Turing machine: you step the head across the tape, watch rules fire and the state change, and run it to halt yourself. The narrative honors a man who broke codes to push back a darkness of his own. The draining daylight is the pulse; the Turing tribute is the heart.

Best Google AI Usage. The hint system isn't a static lookup table — it's a living guide powered by Google Gemini (gemini-2.5-flash) that reads your actual attempt and writes an adaptive, in-character nudge that escalates by tier (reframe the goal → name the technique → point at the next step). What I'm proudest of is the spoiler-safety architecture, since letting an LLM near a puzzle game is genuinely risky:

• The canonical solution is never sent to Gemini — the model can't leak what it never sees.
• Each chamber's authored hint is passed as a ceiling of specificity; the model may rephrase and adapt, but a strict systemInstruction forbids it from ever exceeding that or stating the decoded answer.
• It's one clean seam (getHint → Gemini → authored fallback). If there's no key or the call fails, the game falls back to authored hints — so AI enhances the experience rather than gating it, and the game stays fully playable either way.

An ode to Alan Turing. Race the dark. Keep the light.

This is a submission for the June Solstice Game Jam

What I Built

Code

How I Built It

<! Architecture

Built on React 18 + Vite, with the game engine running on HTML5 Canvas layered inside React's component tree. React handles the UI overlays (HUD, menus, wave notifications) while Canvas handles all real-time game rendering — enemy movement, projectile physics, particle effects, and collision detection.

The Survival Mechanic

The 10-minute timer is the solstice arc. Each minute = roughly one hour of the actual solstice day (6am to 4pm). The background sky gradient updates in real time. At the 5-minute mark (solar noon), enemies hit peak difficulty — this is the solstice's turning point, and it's also when the game is hardest.

The Freedom Chain System

Freedom chains are the game's Juneteenth mechanic. Chained spirit allies are placed throughout the map — they glow gold and pulse. When you reach one and break the chain (right-click or E), the spirit is liberated and begins fighting alongside you. This scales — later in the game, a ring of freed spirits creates a formidable defensive formation.

Pride Power System

Six Pride orbs cycle through the visible light spectrum (ROYGBV):

🔴 Red: damage boost
🟠 Orange: fire rate
🟡 Yellow: area of effect
🟢 Green: health regen
🔵 Blue: movement speed
🟣 Violet: spirit ally buff
Each orb lasts 15 seconds. Stacking orbs creates combination effects.

Enemy Design

Shadow creatures spawn in escalating wave patterns. Early waves are slow pinwheels. Later waves introduce faster shadow darts and heavy shadow titans. The visual design uses inverted light — enemies are dark voids with faint inverse halos, making the contrast with your light-based character immediate and readable.

Prize Category

Musicians and production team understood to be facing same punishment after livestream of patriotic song

The Iranian singer Parastoo Ahmadi and eight members of a production team, including musicians, have been reportedly sentenced to 74 lashes for performing in a concert livestreamed on Ahmadi’s YouTube channel in 2024.

According to court documents, the criminal court of Qom province sentenced the artists to flogging, a two-year ban on leaving the country and a two-year ban on engaging in artistic activities on charges that include offending public decency through the production and publication of “vulgar and immoral content” on cyberspace platforms.

In this blog post, we will see a detailed, grounded comparison of the three most debated open-source load testing tools in 2026: Apache JMeter, Grafana k6, and Locust. All three are free. All three are production-proven. Yet they could not be more different in philosophy, architecture, and day-to-day experience.

I have worked with all three across real-world projects, from legacy JDBC-heavy enterprise systems at work to lightweight microservice pipelines I test for my own side projects. The honest truth? There is no universal winner. But there is almost always a right answer for your specific situation, and that is what we will figure out today.

Why This Comparison Still Matters in 2026

Every year someone writes "JMeter is dead." Every year JMeter ships another release and shows up in another enterprise RFP.

The market has not consolidated. Instead, it has stratified. k6 owns the developer-experience conversation. Locust owns the Python ecosystem. JMeter owns the protocol breadth and enterprise legacy. And in 2026, all three have meaningful updates worth knowing about before you pick a tool for your next project.

Let me give you the ground truth, not marketing copy.

Quick Stats at a Glance

Apache JMeter

JMeter was first released in 1998. That is not a typo. It turned 27 this year, and it is still actively maintained under the Apache Software Foundation.

The latest stable release is 5.6.3. It requires Java 17 as the recommended runtime, and the team has already signaled that the next major version will drop Java 8 support entirely.

What JMeter Gets Right

JMeter's superpower is protocol coverage. Nothing else on this list comes close.

• HTTP / HTTPS
• JDBC (database connection testing)
• JMS
• LDAP
• MQTT
• FTP
• TCP

If you are testing a legacy enterprise system, a mainframe-adjacent API, or a backend that talks over JDBC, JMeter is often the only open-source option that handles it natively.

The plugin ecosystem also deserves credit. The JMeter Plugins project (Head to https://jmeter-plugins.org) adds over 60 additional components. I have built and maintain several commercial plugins of my own, and the extensibility is genuinely solid once you understand the architecture.

Where JMeter Struggles in 2026

The XML-based .jmx test plan format is the biggest pain point in a modern team. Git diffs on .jmx files are nearly unreadable. Code review for JMeter scripts is painful. "Load testing as code" with JMeter is possible but requires discipline and tooling that does not come out of the box.

The thread-per-user concurrency model also means JMeter is resource-hungry at scale. A single machine can generate fewer concurrent users than k6 or Locust on equivalent hardware. For large-scale tests, you need distributed mode or a cloud platform like BlazeMeter, which starts around $149/month for the basic plan.

The GUI, while powerful, shows its age next to k6 Studio or even Locust's minimal web interface.

You can check Feather Wand if you want to infuse AI in your workflow. To measure the speed of LLM, you can check iamspeed.dev.

Personal Observation

I was using JMeter daily at Salesforce for MuleSoft API performance testing. The GUI is genuinely useful for building complex request chains quickly. But the moment I need to commit a test plan to Git and do a proper review, it becomes painful.

Grafana k6

k6 is the most talked-about load testing tool in 2026, and the GitHub star count (30.8k at the time of writing) reflects that.

Two major milestones happened back to back: k6 v1.0 dropped in May 2025 with TypeScript support, native extensibility without custom build pipelines, and SemVer stability guarantees. Then k6 v2.0.0 shipped on May 11, 2026, and it changed the game again.

What k6 2.0 Brought

The headline feature in k6 2.0 is AI-assisted testing workflows. This is not a gimmick. The release ships four new commands built specifically for agent-friendly development:

• k6 x agent: bootstraps agentic testing workflows inside Claude Code, Codex, Cursor, and other AI coding assistants
• A built-in Model Context Protocol (MCP) server so AI agents can validate and run scripts, inspect results, and iterate without leaving the session
• k6 x docs: gives agents and developers CLI access to k6 documentation and examples
• k6 x explore: lets agents browse the extension registry from the CLI

There is also a new Assertions API, broader Playwright compatibility in the browser module, and a consolidated extension catalog that merges official and community extensions into one place.

What k6 Gets Right

The scripting experience is genuinely great for developers. You write JavaScript or TypeScript. Your IDE gives you autocomplete. Your CI pipeline runs it as a single binary with no JVM to provision.

import http from 'k6/http';
import { check, sleep } from 'k6';

export const options = {
  vus: 100,
  duration: '30s',
  thresholds: {
    http_req_duration: ['p(95)<500'],
    http_req_failed: ['rate<0.01'],
  },
};

export default function () {
  const res = http.get('https://api.example.com/health');
  check(res, {
    'status is 200': (r) => r.status === 200,
  });
  sleep(1);
}

k6 Studio (v1.13.1) is a desktop GUI with AI-powered auto-correlation. If you record a browser session, k6 Studio detects dynamic values like session tokens and CSRF tokens and generates correlation rules automatically. That is a feature JMeter has had for years via plugins, but k6 Studio does it through AI, without the XML.

Where k6 Struggles

Protocol coverage is more limited than JMeter. k6 is strong on HTTP, gRPC, and WebSocket. For JDBC, JMS, or LDAP, you are looking at community extensions or custom solutions.

The AGPL-3.0 license is also worth flagging for commercial use cases. Check with your legal team if you are embedding k6 in a product.

Personal Observation

I built iamspeed.dev (an LLM streaming benchmarker) and used k6 for the load side. The DX was excellent. TypeScript types in the IDE, a clean CLI, and Grafana integration out of the box. For any API-heavy workload where the protocol is HTTP or gRPC, k6 is my first recommendation in 2026.

Locust

Locust is the load testing tool for Python teams, and the May 2026 PyPI release confirms the project is alive and growing. It now officially supports Python 3.10 through 3.14.

What Locust Gets Right

Locust's model is simple: write Python classes that describe user behavior, run the tool, watch the web UI. No DSL to learn. No XML. No JVM.

from locust import HttpUser, task, between

class APIUser(HttpUser):
    wait_time = between(1, 3)

    @task(3)
    def get_products(self):
        self.client.get("/api/products")

    @task(1)
    def get_health(self):
        self.client.get("/health")

Under the hood, Locust uses gevent greenlets instead of OS threads. This gives it excellent concurrency density. On the same 8 GB machine, Locust can handle roughly 5x more concurrent users than JMeter, according to TestDevLab's 2026 analysis.

Because test files are plain Python, extending Locust to custom protocols is straightforward. Need to load test a proprietary queue or an LLM inference endpoint? Wrap the Python client library and drop it into a HttpUser subclass. This is actually something I have done for AI workload benchmarking.

Distributed testing is built in. You run a master process and any number of worker processes, scale horizontally, and the web UI aggregates everything.

Where Locust Struggles

The built-in reporting is minimal. The web UI gives you live stats during the run, but there is no built-in HTML report comparable to JMeter's dashboard or Gatling's output. Most teams pipe Locust metrics into Grafana via InfluxDB or Prometheus.

There is no GUI for building test plans. Everything is code. That is great for developer teams but can be a barrier for non-technical stakeholders.

Personal Observation

Locust is my go-to tool when I am testing an LLM API or any endpoint where I need complex Python logic in the request flow, like computing HMAC signatures, calling a pre-step to generate tokens, or parsing streaming responses. The pure-Python model gives you the whole ecosystem to work with.

Head-to-Head Comparison

Scripting Experience

JMeter gives you a GUI that is powerful but dated. Building a test plan with the GUI is fast for HTTP. Building one for gRPC or WebSocket requires plugins and some patience.

k6 gives you a code editor and a TypeScript-aware test runner. The scripting is clean, the API is well-documented, and the extension ecosystem is growing fast.

Locust gives you a Python file. Nothing else to install. If your team already writes Python, the onboarding time is near zero.

Concurrency Model

This is where architecture matters for real.

JMeter runs one OS thread per virtual user. This is expensive. A mid-range machine typically maxes out around 300-500 concurrent threads before CPU and memory become the bottleneck, not the system under test.

k6 runs each VU as a Go goroutine. Goroutines are lightweight. k6 can drive thousands of concurrent VUs from a single machine.

Locust uses gevent greenlets, which are cooperative coroutines. Similar lightweight profile to goroutines. One machine can comfortably simulate thousands of users against an HTTP API.

CI/CD Integration

k6 wins this category cleanly. A single binary, no JVM, no Python dependency tree. The GitHub Actions integration is a config change. The threshold system lets you fail a pipeline based on p95 response time or error rate directly in the test script.

Locust integrates well with CI/CD through headless mode (locust --headless). You can define pass/fail criteria via exit codes and custom listeners.

JMeter needs more setup: a JVM, a plugin directory, a .jmx file committed to the repo, and some wrapper scripts to parse the output. It works, but it takes more effort to get right.

Reporting

JMeter ships a dynamic HTML report with response time graphs, latency percentiles, and error analysis. It is comprehensive out of the box.

k6 pushes metrics to Grafana natively (local or cloud), and the k6 2.0 summary is significantly improved over previous versions. For cloud runs, the Grafana Cloud k6 dashboard is excellent.

Locust's built-in report is minimal. Pipe to Grafana via Prometheus or InfluxDB for anything beyond a quick check.

Cloud Execution

The Metric Problem Nobody Talks About

This is something I always include when I write about load testing tools, because it catches teams off guard.

Run the same test against the same endpoint using JMeter and k6, and you will see different response time numbers. Not because one tool is wrong. Because they measure different slices of the request lifecycle.

• JMeter starts the clock at the connection and stops when the last byte is received
• k6 breaks response time into granular phases: http_req_connecting, http_req_tls_handshaking, http_req_waiting, http_req_receiving
• Locust, using gevent, can report higher response times under certain connection reuse configurations

OctoPerf's comparative study showed up to 15-20% variance in reported response times between tools running identical load against the same target. The practical takeaway: never compare baselines across tools. Establish baselines inside a single tool and track trends there.

Which Tool Should You Choose?

Use this decision tree:

Choose JMeter if:

• You are testing JDBC, JMS, LDAP, FTP, or SOAP endpoints
• Your team uses GUI-driven test creation
• You have an existing JMeter investment and plugin ecosystem
• You work in enterprise environments where BlazeMeter or OctoPerf is already licensed

Choose k6 if:

• Your stack is HTTP, gRPC, or WebSocket
• Your team writes JavaScript or TypeScript
• CI/CD integration is a first-class requirement
• You want AI-assisted test authoring in 2026 (k6 2.0's MCP server is real and it works)
• You want the best DX in the category right now

Choose Locust if:

• Your team is already Python-first
• You need deep customization of request logic (token generation, streaming parsing, custom protocols)
• You are testing LLM APIs or AI workloads where the request logic is non-trivial
• You want distributed testing without a managed cloud dependency

The Hybrid Stack Reality

Something the comparison articles rarely say: most mature teams run two tools.

The practical 2026 default stack looks like one of these:

• k6 OSS for daily CI checks + Grafana Cloud k6 for quarterly capacity tests
• JMeter locally for protocol-rich scenarios + BlazeMeter for distributed runs
• Locust for API behavioral tests in Python + Prometheus/Grafana for dashboards

I have run exactly this kind of hybrid at QAInsights, using JMeter for the complex correlation scenarios and k6 for the lightweight API regression checks that live in CI. The tools complement each other more than they compete.

Final Verdict

There is no single best load testing tool in 2026. But there is a best tool for your context.

If you are starting from scratch on a modern microservices stack, pick k6. The DX is excellent, k6 2.0's AI integration is ahead of everyone else, and the Grafana ecosystem is mature.

If your Python team needs to write complex behavioral scripts, pick Locust. The gevent-based concurrency is efficient, the code is readable, and the Python ecosystem fills every gap.

If you are in an enterprise environment testing JDBC, JMS, or anything beyond HTTP, pick JMeter. The protocol breadth is unmatched in open source, and the plugin ecosystem solves problems that other tools have not even attempted.

What matters most is not which tool you pick. It is that you actually test under load before your users find the bottleneck for you.

Happy Testing!

What tool are you using in your current project, and what made you choose it over the alternatives? Drop your answer in the comments below.

Let's cut the fluff. If you are still shipping massive JavaScript bundles just to calculate CSS styles in the browser, you are bottlenecking your Core Web Vitals. Let's look at how to handle styling at compile time, completely stripping out the runtime overhead.

​The entry point for this architecture in traceless-style is the tl.create API. It accepts a single argument: an object where the keys are arbitrary names you choose, and the values are literal style definitions.
​Here is exactly what defining a component looks like:

javascript

import { tl } from "traceless-style";
const $ = tl.create({
card: {
display: "flex",
flexDirection: "column",
padding: "1rem",
background: "#ffffff",
borderRadius: "8px",
boxShadow: "0 1px 3px rgba(0,0,0,0.1)",
_hover: {
boxShadow: "0 4px 12px rgba(0,0,0,0.15)",
},

title: {
fontSize: "1.25rem",
fontWeight: 600,
marginBottom: "0.5rem"

What makes this powerful is what happens next. A strict literal-only AST parser locates the tl.create call at build time, validates properties against a strict allowlist, and hashes each property-value pair into an 8-character base36 class name.
​After compilation, the object above is entirely stripped from your bundle and replaced with pure string hashes:`

javascript

// After compilation:
const $ = {
card: "tl12abcd34 tl56efgh78 tl9ab0c1d2 tl3e4f5g6h tl7i8j9k0l tlmnopqrst tluvwxyz12",
title: "tl34567890 tlabcdefgh tlijklmnop",
};
Because the compiler needs to know every value at compile time to emit the matching CSS rule, dynamic variables are strictly rejected. If you try to pass color: myColor or use a template literal, the parser will throw a ParseError. If you need dynamic values, you use compile-time resolved design tokens (tl.defineTokens), not runtime JavaScript.
​You also get full composition and built-in variants as standard object keys. Pseudo-classes, breakpoints, and dark mode overrides are handled instantly:

javascript

tl.create({
myStyle: {
color: "white",
_hover: { color: "lightblue" },
sm: { padding: "0.5rem" }, // breakpoint
_dark: { background: "black" }, // dark mode override
"&:nth-child(odd)": { background: "#f0f0f0" }, // raw selector pass-through
},
});
Pre-compile it, hash it, and ship zero runtime. Have you migrated your frontend stack to strict build-time styling yet?

https://github.com/sparkgoldentech/traceless-style/blob/main/docs/api/create.md

I have all of my code on this website.

On the website (which I strongly suggest using for the issue sampler), All of the headers can be hovered with the mouse and the dropdowns all show up, but when a user tries to interact with the dropdowns, they disappear and do not stay.

This current set of code gives no errors or warnings related to the issue. I also provided a debug variable checker for the Shop dropdown in case if it is of use.

I have tried changing the ID of the dropdown area into a class and controlling the movement that way while only having one ID for the whole element but that did not solve the issue.

Please keep in mind that I am very unskilled at Web Design, especially backend design so please let me know if you can help!

The U.S. and Iran have signed a preliminary agreement. Who are the winners and losers? We unpack what we know.

I was recently in a job interview (yes, the kind you have to do when you get laid off) and the interviewer asked me: "How would you scale a frontend application from 100,000 users to a million plus?"
I gave a decent enough answer at the moment. But afterwards, I kept thinking about everything I didn't say. So here we are. Consider this my full answer, delivered about three months too late to actually matter for that job.

First, Let's Calibrate

Scaling a frontend isn't just about throwing more servers at the problem — that's your backend team's headache. The frontend has its own scaling concerns, and a lot of them are invisible until you're already on fire. The jump from 100k to 1M+ users is less about one dramatic architectural overhaul and more about fixing the 20% of things causing 80% of your slowness. The trick is knowing which 20%.

Performance & Asset Delivery: The Biggest Bang For Your Buck

If you're not serving your static assets through a CDN at this scale, stop reading this and go fix that first. Cloudflare, CloudFront, Fastly; pick one. Your origin server should never be sweating over a CSS file.

Pair your CDN with content-hashed filenames. This lets you set aggressive long-term cache TTLs without worrying about users getting stale assets after a deployment. It's one of those things that feels like a small detail until you realise it's quietly saving you a fortune in bandwidth costs and keeping your load times fast for repeat visitors.

The other non-negotiable is code splitting and lazy loading. Users should only download the JavaScript they need for the page they're actually on. Nobody visiting your landing page needs the bundle for your admin dashboard. With Vite this is largely handled for you at the route level, but you still need to be intentional about it.

State Management: Where Things Get Messy At Scale

At 100k users, messy state management is annoying. At a million plus, it becomes a performance crisis. The most important distinction to get right is separating server state from client state. These are fundamentally different things and treating them the same way is a trap I've fallen into personally.

Server state: data that lives on your backend and needs to be fetched, cached, and kept in sync, should be handled by something like React Query or SWR. These libraries give you stale-while-revalidate caching out of the box, which means your UI feels snappy while fresh data loads in the background.

Client state: things like UI toggles, modal open/close, user preferences etc belong in something lean like Redux or even just local component state if it doesn't need to be shared widely. Not everything needs to be in a global store. Redux is a perfectly good tool that a lot of people use as a hammer for every nail.

The API & Data Layer

A few principles that matter a lot at scale:

Virtualize large lists: Never render 10,000 rows in the DOM. Libraries like TanStack Virtual handle this elegantly, only the rows visible in the viewport actually exist in the DOM. This sounds obvious until you're staring at a performance profile wondering why scrolling feels like wading through concrete.

Debounce and throttle user-triggered requests: Search inputs that fire an API call on every keystroke are a classic scaling antipattern. Debounce them. Your backend team will thank you.

Paginate everything: Infinite scroll or traditional pagination - pick your poison, but loading entire datasets upfront is a sin at scale.

You Cannot Optimize What You Cannot Measure

This is probably the lesson I wish I'd learned earlier in my career. At scale, gut feel and local testing will actively mislead you. You need Real User Monitoring — tools like Datadog or Sentry that show you what actual users on actual devices on actual network conditions are experiencing, not just what your M2 MacBook on gigabit ethernet thinks is happening.

Track your Core Web Vitals ( LCP, CLS, and INP specifically): These aren't just Google SEO metrics, they directly correlate with whether users stay on your page or leave. If your LCP is over 2.5 seconds, a non-trivial percentage of users are already gone before they've seen anything meaningful.

Error tracking with context is also non-negotiable: At a million users, you will have errors you never saw in testing. You need to know about them before your users start tweeting about them.

Bundle Size: The Silent Killer

Run a bundle analysis on your app right now. I'll wait. Tools like rollup-visualizer (for Vite) or webpack-bundle-analyzer will show you a treemap of everything you're shipping to the user. There is almost always something in there that makes you say "why is that so big?"

Common culprits:

• A date library you imported for one utility function that weighs 70kb.
• A component library where you're importing the entire thing for three components.
• Polyfills targeting browsers that represent 0.2% of your user base.

Tree shaking handles a lot of this automatically, but it's not magic. Named imports, side effectful modules, and certain CommonJS packages can defeat it. The bundle analyzer doesn't lie.

Architecture Patterns For The Long Game

Micro-frontends become a real conversation at a very large scale. Different teams owning different slices of the UI independently, deploying without coordinating with everyone else. The tradeoff is real though. Shared dependency management becomes its own full-time job and the coordination overhead can eat the productivity gains if you're not careful. I wouldn't reach for this unless you have multiple large teams stepping on each other's toes.

Edge rendering tools like Next.js Edge Runtime, Cloudflare Workers etc can dramatically reduce time-to-first-byte for a globally distributed user base. If your users are spread across continents and you're rendering from a single region, you're leaving a lot of performance on the table.

The Stuff Nobody Talks About Enough

Images. Consistently the most underestimated performance problem. Use modern formats (WebP, AVIF). Lazy load anything below the fold. Serve correctly sized images for each viewport. An image that looks fine on your screen might be a 4MB monster getting served to someone on mobile data.
Fonts. font-display: swap and preloading your critical fonts goes a long way. A font that blocks rendering is a font that's costing you users.

Third party scripts. Analytics tools, chat widgets, A/B testing libraries audit these ruthlessly. Every third party script is code you don't control running on your page, and at scale their performance cost adds up. Some of them are genuinely heavier than your entire application.

So, What's The Actual Answer?

If I could go back and answer that interview question more completely, I'd say this: scaling a frontend to a million users is mostly about discipline. Discipline in measuring before optimizing, discipline in keeping your bundle lean, discipline in not letting state management become a free-for-all, and discipline in treating performance as a feature rather than a cleanup task you'll get to eventually.

The technical solutions - CDNs, virtualization, code splitting, RUM - are well documented and not particularly exotic. The hard part is building a culture and a codebase where performance doesn't quietly degrade every sprint until you're suddenly wondering why conversion dropped 15%.

Anyway. If anyone's hiring a frontend engineer who thinks a lot about this stuff, you know where to find me.