Shrine Auditorium, Los Angeles

The cult star proves she is ready for pop’s big leagues in a show that blends chaotic punk energy with technical finesse

The last time Slayyyter toured, in 2023, she struggled to break even and had to fly home boxes of unsold merch. Back then, she was still largely the domain of Twitter gays: a subcultural figure to those who assessed music in terms of “flops” and “bops”.

Then, midway through 2025, she released the electro-trashy Beat Up Chanel$, and suddenly caught everyone’s attention. With a career-defining Coachella set earlier this year, she had broken through into the mainstream alongside a class of flop-no-more artists – Zara Larsson, Raye and Tinashe – who had spent years seeming cruelly shut out of its central sphere, only to break through with a surprise big hit. For these artists, and Slayyyter in particular, the urgency of a last chance had become as galvanizing as the urgency of a first.

Our first step into on-device coding agents 

Junie has been able to connect to local model runtimes for a while. Point it at Ollama or LM Studio, load a local model, and the agent runs against it. Plenty of people are already doing this. But it also means you have to pick the model, tune the settings, and handle a lot of manual setup – and small models can only help with a limited set of simple tasks.

So we’ve done all of that for you. Introducing Junie Local: It ships a model we chose and tuned against our own agent loop, installs with a single command, and runs entirely on your machine. No tokens, no quota, no code ever leaving your machine. And it’s free.

One command, no configuration

Inside Junie, run /local. The model downloads, the local server starts, and Junie switches over. There is no JSON profile to write, no runtime to install first, and no endpoint to point at.

The model is Qwen3.6-27B at 4-bit, there’s about 20 GB to download, and you’ll need an M5 Mac with 64 GB of RAM. Everything after the download happens on your hardware, so your prompts, source, and diffs stay put.

Your existing setup carries over. Plan mode, live prompting, guidelines, skills, and your /commands behave the same way. The engine changed, the agent did not.

Things we learned about making it fast

Everyone benchmarks generation speed. For a coding agent, that turns out to be the wrong number to chase because most of the time is spent on prefill, while the model reads files to work out what is going on. Optimizing for prefill is where the real gains were, which is why Junie Local starts at Apple M5: The M5 Neural Accelerator has 8-bit arithmetic instructions that M4 lacks, and using them gave us around 40% more prefill throughput. We are going to send that patch as a PR to MLX-VLM.

We also deliberately chose Qwen3.6 over the newer 3.8. Qwen3.8 needs reasoning enabled to work reliably, and with it on, tasks run roughly four times slower. On today’s Macs, 3.6 wins.

There is a lot more to it, including KV-cache reuse across tasks and the speculative decoding setup that roughly doubles generation speed. Read the deep-dive post here: How We Optimized the Qwen 3.6 Model for Our Junie Agent.

How good is it?

We evaluate every model on JetBrains’ own private test set before it goes near Junie, and Junie Local was no exception. Qwen3.6-27B scored on par with Sonnet 4.5 (10,000-token reasoning limit). GPT-5 at medium effort scored slightly higher.

Worth noting what those numbers include: We ship the local model with reasoning disabled entirely because our tests found it added very little quality and cost two to three times as many tokens. So, these results are what the model does without reasoning, against cloud models that had it switched on.

For everyday work, you most likely wouldn’t notice the gap. On complex architectural reasoning, you definitely would.

What changes when nothing is metered

Benchmarks tell you whether a model can do the work. They do not tell you what changes when the work is done for free.

Cost efficiency has been a dial you hold in Junie for a while: Plan on a strong model, implement on a cheap one. Junie Local turns that dial down to zero. When one more iteration is free, work you would never usually spend credits on becomes worth handing over. Junie Local is ideal for:

• Multifile refactors and renames that were not worth the spend.
• Test coverage gaps you have been ignoring for the past two quarters.
• Dependency upgrades and framework migrations.
• Getting oriented in a repository you inherited.

Long, repetitive, mechanical work is exactly what an agent is for, and exactly what you stop asking for when you are keeping an eye on your balance.

For some teams, the privacy you get with Junie Local is the whole reason to read this post. There’s no vendor data policy to review because there’s no vendor in the loop. If you work under client NDAs, that moves the conversation from “we assessed the provider” to “no provider was involved.”

It also works with no network at all. Once the weights are on disk, Junie Local behaves the same way when you’re sitting on an airplane as it does at your desk.

Yes, the requirements are high

We know that an M5 Mac with 64 GB of RAM is a big ask. We are not going to pretend otherwise, and we know it puts Junie Local out of reach for many people reading the post.

That is simply what it costs to run a 27B model well today, and it is the number we are working hardest to bring down. The aim is a lower memory floor, wider hardware, and more of the stack optimized. If the lofty requirements are the reason you cannot try Junie Local, rest assured that we are working to bring them down.

This is the first step

One model, one chip family, one platform. We started narrow because tuning one model across the whole stack beats supporting every model badly.

Mac was the starting point, not the plan. We already have working prototypes for DGX Spark and RTX 5090, and we are looking at 24 GB cards. Prefill behaves very differently on a discrete GPU, so much of the optimization work shifts to that hardware.

If you have thoughts on which platform should land next, now is a good time to let us know.

Getting started

Junie Local is completely free – no registration, no subscription, no credits, and no card required.

Open Junie, run /local, and feed it a task you’ve been putting off. Then tell us what broke, what surprised you, and what you want next. Every part of Junie came from that feedback loop, and this is no different.

A while ago, we launched a long-term project to enable users to run Junie entirely locally, with local inference, across a wide variety of hardware setups. After much anticipation, we recently released an initial version of Junie Local that works on a MacBook M5 with Qwen3.6-27B.

In this blog post, I will share what it took to make it work and why we chose to release it on Qwen3.6-27B rather than Qwen3.8-27B. We made optimizations across the whole stack, from the Junie agent itself to our chosen inference engine.

Let’s start with Junie – after all, this is where you will begin interacting with the local model.

Junie optimizations

Extending the agent’s rolling context

Like any other coding agent, Junie has a main execution loop, where all its work is performed:

• First, the user specifies a task.
• Then, Junie sends it to the LLM.
• Then, the LLM responds with some tool calls (like Bash commands, instructions to read/write files, and more).
• Finally, Junie sends the result of this command back.

Here is a very simplified flow chart of what is happening under the hood:

As you can see from the chart, the LLM continues to receive context-expanding requests, allowing it to partially reuse information from those it has already handled. To be more specific, this means we can reuse the prefill data from the previous request for the next, and this data is referred to as the KV-cache.

But when we ask Junie to do the second task in the same session, it takes only relevant pieces from the context and puts them in the window:

With cloud models, this usually works perfectly because even if the model needs the content of some files again, it will request access and process them again. Prefill is really fast, too.

For local models, that is not the case – prefill isn’t that fast, and it actually takes significant time to “read” files.

To solve this problem, we changed the logic for local inference. Now, we add every new request directly to the rolling context:

This way, we can re-use KV caches from the previous task, i.e. if the model has already read a file, it will stay in the context window, and we don’t need to “read” it again.

Maximizing initial reusable prefix

Another similar optimization we have made relates to the system prompt and initial context that Junie sends when starting a new coding session.

In the previous section, the flow was somewhat simplified: Upon the first LLM request, much more data is actually sent to the LLM than was shown in the chart:

As you can see, a whole different set of information is sent to the LLM. And all this information is sent and processed at the start of every new session. Naturally, we would prefer to be able to cache it somehow 🙂

With this in mind, we changed the order in which we send this data:

We also added special logic to the inference engine to cache the prefix all the way up to the user’s request, so for subsequent tasks (in the same project), it is simply reused. We left out any project context after the user’s request because it is quite small and mostly consists of top-level project files, so it can change frequently.

Getting progress updates to work

With more powerful cloud models, Junie asks the LLM to add a special block in an XML-like format with updates that will be shown to the user. Unfortunately, Qwen 3.6 mostly ignores such requests. At the same time, the model writes its actions as plain text as part of the result of an LLM request – i.e. the LLM sends some tool calls with some accompanying text explaining them.

So, the fix is simple – just use this text generated by Qwen 3.6 as an update for the user. Such adaptations are model-specific, that is to say that we were lucky that Qwen 3.6 behaves in this way – some models don’t print anything there, and others generate far too much text.

Removing unnecessary calls to the LLM

This next optimization, disabling all optional LLM requests, might seem trivial, but it really helped make the agent more efficient. In practical terms, this meant that we disabled any logic that produced a short description of the task. While it’s true that we sacrificed some UX by doing so, we didn’t consider this loss excessive. In addition, we completely disabled multi-agent mode, as the most efficient way to process LLM requests on an M5 is via sequential processing, so there is no point in enabling multiple agents – they will be bottlenecked by the inference anyway.

Model parameter optimizations

reasonning_effort: None

When we were testing the cloud version of the Qwen3.6-27B internally, we noticed that enabling reasoning does not add a significant quality boost. So, for the local version, we decided to completely disable reasoning. This is a big deal, as reasoning tokens used by the inference engine perspective are the same as tokens used to generate the main response. Therefore, with reasoning disabled, we need to generate 2–3x fewer tokens, and that translates to a 2x speed-up on task execution, with an insignificant effect on quality.

Quantization

We decided to use the 4-bit version because it performs only slightly worse on benchmarks than its 8-bit counterpart, and because generation is memory-bottlenecked, using the 4-bit version is ~2x faster than the 8-bit version. However, when we compared the prefill speed between the 8-bit and 4-bit versions, we noticed they were the same… We thought that this was odd, so we dug deeper.

Inference engine optimization

Prefill hack

Some might wonder why we’re even concerned about prefill anyway. After all, the whole internet is full of generation speed benchmarks and optimization options. 

Well, on a discrete GPU (like the RTX 5090), they might be right to question its importance. On that kind of hardware, it is indeed extremely fast because prefill is compute-bound, and discrete GPUs are usually quite powerful. This means you can get something like 3,700 t/s prefill speed on default configurations. On the M5 out of the box, it was somewhere in the neighborhood of 650 t/s. So when the model was requesting the content of the file, i.e. when investigating, the majority of time was spent on prefill, not generation! 

What is worse is that there was no difference between 4-bit, 8-bit, or 16-bit quantization in terms of prefill speed. But why? Well, prefill is compute-bound, which means we are not limited by the memory speed at all. And it turns out that the majority of matrix operations during prefill were performed in full 16-bit mode. i.e. all 4-bit weights were converted to 16-bit numbers before operations were performed. But the M5 processor has special operations for 8-bit numbers that are significantly faster than 16-bit operations. So, when we applied a patch to the MLX-VLM package that switched some^* matrix operations during prefill to 8-bit, we got a ~40% prefill speed gain!

By the way, this is the main reason why we decided to focus on M5 chips. M4 chips don’t have these 8-bit arithmetic instructions, and the M4’s 16-bit arithmetic delivers 20–30% slower prefill.

^*Qwen3.6-27B uses both full-attention layers and self-attention layers. We found that even under 4-bit quantization, the full-attention weights remain stored in full 16-bit precision. Since these layers stay at full precision regardless, we didn’t apply this optimization to them – it’s applied only to the self-attention layers, where it actually reduces memory/compute. Here is the link to the patch in MLX-VLM. What’s more, the same optimization can also be applied in vLLM, just by editing the model’s config file. Config example

Speculative decoding via MTP and n-gram matching 

As standard optimizations, we applied:

• MTP (Multi-Token Prediction) with a separate draft model: A speculative decoding approach where a smaller draft model proposes several tokens ahead, which the main model then verifies.
• N-gram speculative decoding: Instead of a draft model, this method looks for previously repeated token sequences in the context and “predicts” upcoming tokens by matching against them.

We enabled both methods simultaneously. In practice, this means that during generation, we sometimes accept not just the ~3 tokens proposed by MTP, but also up to 8 additional tokens accepted from the n-gram method. The illustration below shows raw-generated tokens color-coded by the method that produced each accepted token (draft model vs. n-gram).

Combined, this gives up to a 2x speedup in generation.

Qwen3.8-27b

Given all this, why didn’t we use 3.8 instead of 3.6?

Unfortunately, Qwen 3.8 requires reasoning mode to be enabled in order to function well. Without it, output quality degrades significantly – on typical tasks, it can even fail entirely, getting stuck in a loop where it repeats the same tool call indefinitely. But enabling reasoning mode substantially increases the number of generated tokens: At medium reasoning effort, roughly 5x more tokens are produced. Since prefill time stays roughly constant, the net slowdown is closer to 4x rather than a full 5x. That’s still a significant cost – which is why, for now, on Mac hardware, Qwen3.6-27b remains the better choice. 

Closing thoughts

I hope that after reading about our journey, you can see that focusing solely on generation t/s is the wrong approach when it comes to typical agent programming tasks.

You need to optimize all parts of the stack, including:

• Generation and prefill: The token-by-token decoding process and the initial context-processing pass.
• Model parameters and quantization: The model’s weight precision and configuration.
• Agent harness: The surrounding orchestration layer (tool calls, control flow, prompting logic) that drives the model.
  

So, this is what we are planning to do in the future. M5 support is just the first step – we already have prototypes for DGX Spark and RTX 5090 (and we’re even looking at 24 GB cards, too), so stay tuned!

TL;DR

• Repository on GitHub: Modern Go Guidelines.
• Purpose: Modern Go Guidelines are a set of skills that help AI coding agents write up-to-date Go code that matches the Go version in your project.
• Version support: The skills cover useful language features and standard library additions from Go 1.0 through Go 1.27. Guidelines for newer versions are excluded when your project uses an older version.
• Focused context: The tool uses list for short guidelines and explain for detailed examples. This progressive disclosure approach gives agents detailed guidance only when they need it and helps them apply the skills more reliably.
• Installation: You can install the plugin from the marketplace or a local repository. The integration requires the Go toolchain, runs from a local cache, and does not modify your project.

Why AI coding agents need modern Go skills

AI coding agents can produce working Go code, but they typically rely on outdated patterns. Older syntax appears more often in their training data. Newer language features and standard library additions may also fall outside their training cutoff.

The GoLand team created Modern Go Guidelines to close this gap. These Golang skills give agents an up-to-date reference for writing modern code. They help agents select features supported by the Go version in your project and avoid code that requires a newer version.

Modern Golang skills are an open-source contribution from the GoLand team to the broader Go community. You can use them with supported AI coding agents in the terminal. 

Modern code for the correct Go version

Newer code is useful only when your project can compile it. For this reason, the guidelines match the Go version declared in your go.mod file.

Consider a project that contains the go 1.25 directive.

The agent can receive skills for Go 1.25 and earlier. It does not receive Go 1.26 or Go 1.27 skills. For example, it can learn to use sync.WaitGroup.Go, which Go 1.25 introduced. It will not receive a suggestion to use errors.AsType, which requires Go 1.26.

This version check ensures that the generated code is compatible with your project. It also reduces the amount of context the agent must read. The agent does not spend tokens on features that it cannot use.

CLI tool with focused output

The agent uses a CLI tool that comes with the go-modern-guidelines plugin. It includes the use-modern-go skill, a set of instructions that teaches the agent when and how to use the CLI. The tool supports two main subcommands: list and explain. The skill tells the agent to run list for the relevant Go file before editing and to call explain when it needs details about a specific rule.

Each agent integration runs these subcommands through its own wrapper. The examples below use the CLI binary name.

Your agent uses the CLI to get skills for the Go version(s) used in your project. The list subcommand returns short, relevant guidelines. When the agent needs more context, the explain subcommand provides detailed guidance and code examples.

go-modern-guidelines list --file-path ./internal/worker/worker.go

Your agent can also set the version directly:

go-modern-guidelines list --go-version 1.27

The output starts with the newest applicable guidelines and includes a stable identifier (ID) for each one:

...
sync_waitgroup_go: Use wg.Go when spawning goroutines tracked by a sync.WaitGroup.
testing_t_context: Use t.Context() when a test function needs a context tied to the test lifetime.
json_omitzero: Use omitzero on JSON-tagged bool, numeric, struct, and time fields whose zero value should be omitted; keep omitempty for empty strings, slices, and maps.
...

The short output helps the agent find relevant guidance without loading all available explanations and code samples.

An agent may not recognize a recent Go feature or know how to apply it because the feature falls outside its training data. When the agent needs more information about a guideline, it uses the explain subcommand.

go-modern-guidelines explain generic_methods

The command returns a detailed explanation and a before-and-after example. The example compares an older pattern with its modern replacement, helping the agent apply the change correctly.

generic_methods:
  Since: Go 1.27

  Summary:
    Use generic methods instead of package-level generic helper functions when the operation naturally belongs to the type itself.

  Details:
    Generic methods keep operations in the namespace of the type that owns them. Keep package-level helpers for operations that do not naturally belong to one receiver type.

  Examples:

  Before:
    type Set[T comparable] map[T]struct{}
    func Map[T comparable, U any](s Set[T], f func(T) U) []U {
      out := make([]U, 0, len(s))
      for value := range s {
        out = append(out, f(value))
      }
      return out
    }
    names := Map(users, func(user User) string {
      return user.Name
    })

  After:
    type Set[T comparable] map[T]struct{}
    func (s Set[T]) Map[U any](f func(T) U) []U {
      out := make([]U, 0, len(s))
      for value := range s {
        out = append(out, f(value))
      }
      return out
    }
    names := users.Map(func(user User) string {
      return user.Name
    })

Your agent can request several explanations in one command:

go-modern-guidelines explain generic_methods atomic_types errors_as_type

What the guidelines cover

The project covers useful language features and standard library additions from Go 1.0 through Go 1.27. It also includes the patterns handled by the Go modernize analyzer.

The guidelines help agents choose patterns such as:

• slices.Contains instead of a manual search loop.
• min and max instead of handwritten comparisons.
• cmp.Or instead of a chain that selects the first nonzero value.
• sync.WaitGroup.Go instead of separate Add, go, and Done calls.
• errors.AsType for type-safe error matching in Go 1.26 and later.
• new(value) when you need a pointer to a value in Go 1.26 and later.
• strings.CutLast and bytes.CutLast instead of LastIndex and manual slicing in Go 1.27.

These examples solve a common problem with generated code. An agent may know an older pattern because that pattern appears in a large body of existing code. The provision of explicit rules helps the agent choose the most current form of a given syntax.

These modern Go skills complement tools such as go fix. Our repository helps agents write current code from the start, while the go fix command helps update patterns that already exist in a codebase.

Installing the guidelines into your AI agent

You can install the plugin from the marketplace or from a local repository. Both methods require the Go toolchain on your PATH. On first use, the integration installs the command-line tool with go install and stores it in a local cache. It does not modify your project.

Install the plugin from the marketplace

1. Open a session with your AI agent (for example, run claude in the terminal).
2. Add the Modern Go Guidelines as a Claude marketplace:

/plugin marketplace add JetBrains/go-modern-guidelines

1. Install the plugin:

/plugin install modern-go-guidelines

1. Activate the guidelines:

/use-modern-go

The integration checks the Go version in your project and provides the AI agent with the corresponding guidelines.

Install the plugin from a local repository

Use a local repository to test the plugin before publishing or updating it. The repository root must contain the .*-plugin/marketplace.json file.

1. Open a terminal and run your AI coding agent.
2. Add the local repository as a Claude marketplace. Replace the example path with the absolute path to your repository:

<claude|codex> plugin marketplace add /absolute/path/to/go-modern-guidelines

1. Install the plugin from the marketplace:

<claude|codex> plugin install modern-go-guidelines@goland-<claude|codex>-marketplace

1. Start or restart your AI agent in your Go project.
2. Activate the guidelines in the session:

/use-modern-go

The AI agent reads the marketplace definition from your local repository and installs the plugin in its plugin cache. Your repository remains the marketplace source.

Start with modern Go

Language releases move faster than model training cycles. Your coding agent needs a small, current source of truth to keep up.

Our repository of modern Golang skills provides that source, without sending irrelevant material to the agent. Your go.mod file sets the boundary. The list subcommand shows what applies. The explain subcommand adds detail only when the agent needs it.

Explore the project, installation instructions, and current guidelines in the Modern Go Guidelines repository.

Happy coding!

The GoLand team

• Huge hailstones prompt organisers to act 15km from end

• Riders seen heading into hotel on route to take cover

A torrential hailstorm in the French Pyrenees forced the abandonment of the ⁠third stage of the Vuelta a España on Monday.

With 15 kilometres (9.32 miles) remaining of the 174km route ⁠from Gruissan to Font-Romeu, the ​skies darkened as the peloton neared the top of the Col de Mont-Louis and huge hailstones began ⁠bouncing off the tarmac and pelting the riders.

Как-то незаметно прошла новость, что иена упала до минимального за 40 лет значения к доллару. Ну, казалось бы: упала, так упала. Тем более что объяснение везде одно и то же.

Мол, ставка Банка Японии — 1%, а у ФРС США — 3,5–3,75%, и значит, делают вывод: глобальные инвесторы занимают в иенах, потом их продают, меняют на доллары и вкладываются в долларовые активы — акции и облигации на Уолл-стрит.

Называется эта игра на ставках, или кэрри-трейд. Ну, а раз иену сбрасывают, вот она и катится по наклонной.

Arbitrator determined the Post improperly fired Karen Attiah, a union-protected employee, over social media posts

An independent arbitrator has ordered the Washington Post to rehire the high-profile opinion columnist Karen Attiah, abruptly fired by the news organization last September over comments she made on social media about Charlie Kirk, the then recently slain conservative activist.

On Monday, an arbitrator ruled that the Post had violated her rights as a union-protected employee and ordered the newspaper to reinstate her and compensate her for lost wages.

• Child wandered on field during MNUFC’s 5-1 win

• Minnesota posts win was ‘Like taking money from a baby’

A toddler interrupted a Major League Soccer match between Minnesota United and San Jose Earthquakes on Saturday by invading the pitch – a bizarre scene punctuated by an on-air analyst saying, “There’s a baby on the field.”

With a minute and a half to play in the game that Minnesota won 5-1 at PayPal Park in San Jose, California, the small child took to the field – and the referee blew his whistle to stop play.

Arbitrator determined the Post improperly fired Karen Attiah, a union-protected employee, over social media posts

An independent arbitrator has ordered the Washington Post to rehire the high-profile opinion columnist Karen Attiah, abruptly fired by the news organization last September over comments she made on social media about Charlie Kirk, the then recently killed conservative activist.

On Monday, an arbitrator ruled that the Post had violated her rights as a union-protected employee and ordered the newspaper to reinstate her and compensate her for lost wages.

After higher prices for winter kick in, energy debt unpaid for more than 30 days likely to rise, says Energy UK

Households in Great Britain could owe their energy suppliers as much as £7bn by the end of the year after higher gas and electricity prices forecast for the winter kick in, an industry group is warning.

Domestic energy debt and arrears climbed by about £500m over the past year to a record £6bn at the end of June as the Middle East conflict continued to stoke rising gas market prices.

Неважно, что делает LLM. Задача все равно приходит словами, и одно пропущенное не может испортить уже вполне материальное действие. Смотрю на LLM глазами лингвиста и разбираюсь, как языковед проверяет LLM от токенизации до прагматики и что разработчик может превратить из этого филологического занудства в код, метрики и тесты.

• Child wandered on field during MNUFC’s 5-1 win

• Minnesota posts win was ‘Like taking money from a baby’

A toddler interrupted a Major League Soccer match between Minnesota United and San Jose Earthquakes on Saturday by invading the pitch – a bizarre scene punctuated by an on-air analyst saying, “There’s a baby on the field.”

With a minute and a half to play in the game that Minnesota won 5-1 at PayPal Park in San Jose, California, the small child took to the field – and the referee blew his whistle to stop play.

As holidaymakers descend on Brittany this summer, trebling the population of some villages and towns, local people are unimpressed

Name: “Parisians out!”

Age: It officially commenced at the start of August.

Когда говорят о DuckDB, обычно вспоминают аналитику: локальные запросы к Parquet, быстрые агрегации, ноутбуки. Но у него есть свойство, к аналитике отношения не имеющее: он умеет соединять источник и приёмник данных внутри одного SQL-плана. С расширениями для Oracle и PostgreSQL перенос данных сводится к одному запросу — без Instant Client, без OCI, без Python и без промежуточных файлов. А если одной сессии Oracle мало, чтение разбивается на параллельные шарды, читающие один согласованный снимок по единому SCN.

Virus has already caused catastrophic losses in seals in South America and sub-Antarctica, particularly among pups

• Follow our Australia news live blog for latest updates

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

Scientists have warned deadly H5 bird flu could cause “carnage” for Australia’s seal and sea lion populations after detection of the virus in long-nosed fur seals in South Australia.

SA confirmed Australia’s first case in a mainland mammal on Saturday after a dead long-nosed fur seal found at Beachport on the Limestone Coast tested positive for H5N1.

Barcelona target left exposed after draw with Villarreal as supporters vented their fury at his ‘dream’ to leave

Julián Álvarez entered a long, dark tunnel on his own. “We’re stronger together,” Giuliano Simeone said but that wasn’t the way it went. At the end of their first home game of the season, a 2-2 draw with Villarreal, all of Atlético Madrid’s players gathered by the centre circle, shook hands with their opponents and each other, then headed towards the south end of the Metropolitano. Almost all of them did, anyway: one was left behind. Somebody in a suit had a quiet word then the press officer came, pointing in the other direction. So, while his teammates turned to the supporters who had turned on him, the man wearing No 19 went west, to the exit.

Álvarez walked alone. Head down in silence, as he had been all afternoon and beyond, he set off slowly across the pitch accompanied only by his thoughts and the whistles that followed him. Not offered a hand to shake or a nod of acknowledgment, he stepped past the Atlético badge on the touchline where the mouth of the tunnel opens. Either side, supporters hung over the void, whistling and shouting. Way off to his left, Atlético’s other players paused, seemingly waiting for him to slip out of sight before approaching the stand, but none turned back. A scarf was thrown, landing at Álvarez’s feet and left lying there. And then he disappeared into the dark, a portrait of the place he is in.

Despite its global reputation, my time there felt less sexy party, more wholesome summer camp. Then one day my boss told me a hard truth

When I tell people I spent a chunk of my early 20s working at a hipster clothing retailer infamous for salacious ads and sexual assault allegations, I’m usually met with scandalised interest. I imagine what they imagine: a harshly lit harem of flesh and vice, where young women were offered up on an altar of mid-priced T-shirts.

We had our moments. An occasional visiting corporate lackey would inevitably grind up against one of us while checking a window display. A weekly caller would gasp and choke while asking if we sold women’s underwear. A co-worker inquired whether I’d be interested in going on dates with rich, interesting men for money. It was impossible to ignore the reputation of our store. But it was the 2010s, a strangely liminal time of sexual and social awakening. When we could roll our eyes at the problematic gender politics of our advertisements while never considering wearing a bra to work.

Меня зовут Павел, я разработчик в R77.AI. В статье расскажу, почему Python-библиотеки для ML могут незаметно ходить в интернет, как находить такие скрытые загрузки и что с ними делать в закрытом контуре.

Полгода назад я поддерживал TypeScript SDK для одной панели администрирования. Обычная библиотека: сгенерированный из OpenAPI клиент, авторизация, ретраи, вебхуки. И в какой‑то момент я поймал себя на том, что рутинные вопросы к панели — «у кого истекает доступ на этой неделе», «почему нода отвалилась», «сколько трафика съел вот этот аккаунт» — я решаю одинаково: открываю редактор, пишу пятнадцать строк скрипта на своём же SDK, запускаю, читаю, удаляю.

Мысль напрашивалась: SDK уже типизирован, схемы уже есть, значит модель может вызывать его сама. Так появился marzban-mcp.

Дальше выяснилось, что «обернуть SDK в MCP» — это примерно 10% работы. Остальные 90% — ответ на вопрос, который в обычной библиотеке вообще не стоит: что можно доверить модели делать с боевой инфраструктурой, а что нельзя, и как эту границу выразить в коде.

Virus has already caused catastrophic losses in seals in South America and sub-Antarctica, particularly among pups

• Follow our Australia news live blog for latest updates

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

Scientists have warned deadly H5 bird flu could cause “carnage” for Australia’s seal and sea lion populations after detection of the virus in long-nosed fur seals in South Australia.

SA confirmed Australia’s first case in a mainland mammal on Saturday after a dead long-nosed fur seal found at Beachport on the Limestone Coast tested positive for H5N1.

На мероприятиях по сетевой безопасности всё чаще обсуждают, как правильно соотносить показатели производительности сетевых средств защиты информации (СЗИ) с потребностями организации. Новые функции и продукты в условиях импортозамещения появляются с умопомрачительной скоростью. И с такой же скоростью для них разрабатываются новые методики, показатели, измерительные средства. Но эта гонка касается не только потребителей и интеграторов. Разработчикам нужно как успевать создавать и модернизировать продукты на уровне конкурентов, так и качественно проверять, отлаживать свои решения.

Особенно остро этот вопрос стоит для NGFW — самого сложного и полнофункционального продукта в линейке сетевых СЗИ. Наши коллеги уже делились опытом в этой области. Мы расскажем о своём подходе: как мы сопровождали разработку и тестировали режимы работы сетевых СЗИ с помощью собственного генератора трафика.

В пятницу, 21 августа, миллиардеру Сергею Брину исполнилось 53 года. Он известен как сооснователь компании Google. По данным Forbes, в 2026 году состояние Брина оценивается в $260 млрд, что делает его четвёртым богатейшим человеком мира.

История Брина выделяется на фоне других сверхбогатых предпринимателей, поскольку он стал самым успешным в бизнесе и технологиях выходцем из СССР.

The distinction has become blurred between something being medically available and actually being medically useful

When a friend finally arranges the chat we were meant to have some weeks ago, she apologises profusely for the lack of contact. I tell her she doesn’t need to mollify me but it turns out she is the one in need of sympathy. Her husband had gone into hospital for what was termed a routine procedure. While waiting to collect him, my friend suddenly heard the overhead announcement of a code, announcing a patient in extremis.

“Something told me it was him.”