This review contains spoilers for The Last of Us season 2 episode 6. After last week’s brutal and violent installment, The Last of Us season 2 takes us back in time for episode 6. “Feel Her Love” teased the return of Pedro Pascal, and now we get to see what memories Ellie might be looking back on as she avenges Joel’s death. That’s right, it’s time for a flashback episode. It may seem a little strange to pause the action of the season for an entire episode dedicated to Joel and Ellie’s recent past, but this episode is actually taking a page straight out of The Last of Us Part II. While not all of the flashbacks here are replicated exactly as they are in the game, flashbacks are used periodically in The Last of Us Part II as a sort of palate cleanser to all of the violence the player experiences and as a narrative device to show us key moments of Joel and Ellie’s relationship in the time between the first and second games. This episode essentially serves the same purpose. The first flashback of the hour takes us back to Austin, Texas in 1983, and we get to see Tommy and Joel as kids for the first time. Tommy was buying pot and got into an altercation with the dealer, Joel saw and came to his brother’s defense. Tommy is worried about getting the belt from their dad, so Joel offers to take the fall for him. Their police officer father (played brilliantly by Tony Dalton) takes a break from his shift after hearing about what happened. He sees through Joel’s lie, and the two have a heart-to-heart. He tells Joel about how hard his father was on him, and admits that although he tried to do better, he knows he’s still been harder than he should be on Joel and Tommy. He tells Joel that if he ever becomes a father, he hopes he does a little better than he did. In the next flashback, we get to see a little bit of that. Two months after Joel and Ellie arrived in Jackson, we see Joel trading LEGOs with Seth for some kind of surprise for Ellie. He then goes home and works on refurbishing a guitar for her, the very same guitar we see in the season 2 premiere. While he’s working, Tommy brings Ellie home because she deliberately burned her arm while on kitchen duty to cover up evidence of her immunity. After Tommy leaves, she’s apologetic to Joel, saying, while slightly loopy on pain meds, that she just really wanted to wear short sleeves again. A cake arrives at their house moments later, and Joel gives Ellie her birthday surprise, which she happily digs into. She asks him to play a song for her on the guitar he made for her, and he plays the song “Future Days” by Pearl Jam. As mentioned in last week’s review, this song becomes an important part of their relationship. A year later it’s Ellie’s 16th birthday, and Joel is taking her into the woods for a surprise. Fans of The Last of Us Part II will recognize this scene, and it’s one of the game’s best. Joel has found an abandoned museum with a space exhibit that’s still somewhat intact. He invites Ellie to join him in the capsule on display, and he even found a recording of an actual shuttle launch to really give Ellie an immersive experience. But even though Ellie seems overjoyed at this surprise, we can start to see the tension brewing between them. Ellie wants to start going on patrol and Joel is still hesitant. And on their way back, Ellie sees fireflies – the insect not the people – and pauses, something clearly on her mind even if she doesn’t admit it to Joel. The next year, Joel arrives home from patrol early, bringing home another cake to surprise Ellie. To his surprise, however, he finds her alone in her room with Cat, who is giving her a tattoo over her burn scar. Joel gets upset and chases Cat out. Ellie responds by angrily moving her stuff into the garage while Joel is asleep. He stops her, but instead of forcing her to stay in the house, he offers to help clean up the garage for her to help her move. Pedro Pascal is so good at Joel’s subtle expressions that we can tell this bothers him, but he’d rather give Ellie the space she wants than lose her entirely. Two years later, Ellie is in her garage apartment, rehearsing how to ask Joel about what really happened in Salt Lake City. Joel knocks on her door, offering to finally take her on her first patrol for her 19th birthday. While on the trail, Joel tells Ellie that he’d like to do this more often, spend time together like they used to. It’s clear that Ellie still has her questions about Salt Lake on her mind, but Joel is barely able to ask her what’s on her mind before they’re interrupted by a radio call – Eugene and Adam are in trouble and need help. Joel tells Ellie to go back, but she replies “I’m not your fucking kid, Joel, I’m your partner. We stick together.” When Joel and Ellie arrive, Adam is already dead and Eugene has been bit. He begs for them to take him to Jackson’s gates so he can tell Gail goodbye, but Joel refuses. Ellie pleads with him too, and Joel appears to relent. He tells Ellie to go get the horses and bring them down the trail. He looks her in the eye and promises that he and Eugene will meet up with her. But while Ellie is gone, he takes Eugene to a clearing and shoots him. They return to Jackson, and Ellie watches Joel lie through his teeth to Gail about what happened, that Eugene shot himself to save them. Furious, she tells Gail the truth, and we can see on her face that she doesn’t have to ask Joel about Salt Lake City anymore – she’s already confirmed that Joel lied to her about what happened. When she says “You swore,” to Joel, she’s not just talking about his promise that day. Join our mailing list Get the best of Den of Geek delivered right to your inbox! Nine months later we’re back to where the season started – New Year’s Eve. We get to see the party and its aftermath from Joel’s perspective. The scene on the porch plays out a little differently this time around – when Ellie storms past him she comes back around. The two have a heart-to-heart. Ellie demands that Joel doesn’t go behind her back and take her off patrol, which he agrees to. He then asks her about Dina, and her feelings for her. Ellie then calls Joel an asshole and confronts him about his lies. She tells him that that day with Eugene confirmed what she already knew, and gives him one last chance to tell her the truth about what happened with the Fireflies. Joel admits to everything, though his face says more than his words. He tells Ellie that he would do it all over again. Ellie thinks it’s because he’s selfish, but Joel replies with a variation of what his father told him at the beginning of the episode. He says “Because I love you, in a way you can’t understand. Maybe you never will. But if that day should come, if you should ever have one of your own, well then, I hope you do a little better than me” Ellie’s last words to him in that moment are “I don’t think I can forgive you for this, but I would like to try.” And we now know that these were likely her final words to Joel before his death. It explains why she was willing to go on patrol with him that morning – she was trying to take a step toward forgiving him. Getting to watch Pedro Pascal and Bella Ramsey on screen together again is such a treat, even if they are dealing an immense amount of emotional damage to each other and the audience. The way they capture Joel and Ellie’s physicality and emotions is spot on. These characters aren’t great at communicating verbally – we see it takes years for Ellie to ask Joel about Salt Lake City. But there’s still so much language in what they don’t say that defines their relationship. This episode may have given us a break from the violence of the last two, but that doesn’t mean it isn’t still a little brutal to watch. Just because we’re not actively watching Joel get beaten to death again, doesn’t mean these flashbacks don’t drive the broken golf club in even deeper into our hearts. We watch Joel and Ellie’s relationship break and start to mend itself again, knowing that they won’t have a chance to fully reconcile. Ellie’s desire for revenge makes all the more sense knowing that Abby took away her chance to forgive Joel – all she has left to forgive now is his memory. New episodes of The Last of Us season 2 premiere Sundays at 9 p.m. ET on HBO, culminating with the finale on May 25, 2025. Learn more about Den of Geek’s review process and why you can trust our recommendations here.

Clair Obscur: Expedition 33 writer Jennifer Svedberg-Yen would be the first to tell you: writing a video game is work. At least writing a novel is a one-person operation for most of the time. At least a screenplay for a film only needs to come in around 120 pages, unless you’re working for Martin Scorsese. But writing a video game? That means filling hours of space, bending the material to fit the play, and usually working with a team of other writers to make it all cohere. Sometimes to hit a deadline, you just need to throw words at the wall. Especially when it’s 3 a.m. That can still result in brilliance. All the Frenchy bits and bobs in Clair Obscur have captured the imaginations of players, but few quite like the character of Esquie, and especially one camp conversation in which the oversized gestral reflects on his friend François with Verso. Verso knows François to be a grump, but Esquie insists that “Franfran used to be all ‘Wheeee!’ But now he’s all ‘Whooo.’” Over about a minute, Esquie further defines “whee” and “woo” while players even choose their own whee/woo path through the dialogue tree. It is tremendously silly. “That was me at three in the morning trying to come up with something,” Svedberg-Yen admits with a laugh. “I needed to write seven relationship dialogues for Esquie!” Svedberg-Yen says the script for Clair Obscur: Expedition 33 comes in around 800 pages long, which doesn’t even include all of the NPC dialogue or the piles of lore-related documentation written as foundation for the story. To fill that much space, the writer says she grabbed inspiration from everything and everywhere around her. For instance, Svedberg-Yen says Monoco, the floating gestral who later joins the Expedition 33 crew, is based on her dog, and when her pup needed a haircut, she decided to write that into the story.  “I was like, OK, that’s going to be the conversation for Monoco and Verso about haircuts. He says, ‘you look like an overgrown mop.’ I literally said that to my dog — and I could use that.” The “whee whoo” sequence made even less sense in the wee hours of the morning, but it felt right.  “I knew what I wanted to say, where it’s talking about something heavy and sad and how you can feel the joy and the grief,” Svedberg-Yen says. “And I was so tired. I didn’t have any words. So I was just like, ‘wheeeeee!’” As a fantasy writer, Svedberg-Yen says her number one goal is authenticity, sculpting characters who are born from real places and real circumstances, even if they’re otherworldly. So she doesn’t often question her instincts – even the kooky ones. There was room for moments of levity in the otherwise tragic Clair Obscur because, hey, that’s life. “Did I push it too far at all? Sometimes, when I’m at a loss for words, I’m like, what am I feeling right now? And then I put that into the script. That’s authentic because it is what I am feeling.”

Music is a pleasant healer, but the same cannot be said about the speakers that we use at home to deliver soothing and healing music into our ears. Bloom is set to change that with its interesting design: It is a speaker inspired by the natural bud and its quiet journey into a full bloom. In that emotion, the Bloom, a sustainable ambient speaker, is born on the idea of ​​‘atmosphere’ before ‘function.’ It fills the space with an aroma before the music can take over as a complementing partner. To that accord, as the designer says, “Bloom is a natural bud that quietly blooms.” It gently fills the space with emotion before being a speaker which spreads quality sound. Even though the music ability comes second to emotional quotient, Bloom is no less in audio finesse. This premium quality Bluetooth speaker is built-in with a healthy influx of speaker, tweeter, and woofer for eminent sound that can fill the space. Designer: Yeonu Hwang The Bloom, an audio products brand, is known for emphasising sustainability in almost all aspects of its production, from the use of recycled plastic in construction to locally sourced materials for speaker drivers, and more. Bloom Bluetooth speaker from Yeonu Hwang may have little connection, but it does have the same ethos. The speaker uses coffee and natural aromas that slowly spread in the space like the light and emitted sound. The Bloom is thus a reference to how sustainable fragrance of everyday materials can fill the routine, owing to the use of discarded coffee grounds, recycled glass and fabric in the creation. Result of sustainable development and harmony between technology and natural materials, the Bloom speaker also exudes substance in its appearance, which is spearheaded by its cylindrical design and a color palette inspired by wood, earth and sunlight. Each of these tones has a different appeal, they reflect the warmth, the flow of life, and the prominence of quietly being there and radiating calm. The calmness is assured by the diffuser on the top, which is integrated into the speaker magnetically, so it can be attached or detached at will, depending on how you choose to use the speaker. Inside its soft and emotionally charged exterior, the Bloom has a well-balanced arrangement of three key drivers: tweeter, full-range, and woofer, ensuring professional-level audio delivery. Courtesy of the design and the positioning of the speakers in it, the Bloom can create an immersive, 360-degree listening experience. Really interesting onboard are the controls, with the slide gesture (on the touch panel – no physical buttons), the Bloom allows the user to control light, the emotions, and the sound, creating an atmosphere that slowly changes with the movement of the fingertips on the controls. Since the entire contraption is flawless and smooth, the connectivity ports have been slotted right in the base to safeguard the aesthetic brilliance. The post Inspired by nature in all its forms, the Bloom ambient speaker puts atmosphere before function first appeared on Yanko Design.

Recent advancements in LM agents have shown promising potential for automating intricate real-world tasks. These agents typically operate by proposing and executing actions through APIs, supporting applications such as software engineering, robotics, and scientific experimentation. As these tasks become more complex, LM agent frameworks have evolved to include multiple agents, multi-step retrieval, and tailored scaffolding to optimize performance. A central challenge lies in effectively exploring and understanding the environment, which has prompted the development of engineered scaffolds using tools, memory mechanisms, and custom pipelines. However, most existing methods assume partial observability, requiring agents to collect observations incrementally. While this assumption holds in dynamic or unfamiliar environments, it is less applicable in fully observable settings like SWE-bench, where all relevant information is accessible from the start. In software engineering, research on LM agents has focused on two main strategies: agent-based frameworks and structured pipelines. Agent-based systems, such as SWE-Agent and OpenHands CodeAct, allow LMs to interact autonomously with codebases, often through custom interfaces and retrieval tools. Other models like Moatless and AutoCodeRover enhance localization through search techniques, while SpecRover refines scaffolding design. Alternatively, structured pipelines—such as Agentless and CodeMonkey—decompose tasks into sequential phases like localization, repair, and validation. While these approaches depend on engineered components for performance, the current study proposes leveraging Long-Context LMs (LCLMs) to directly interpret the entire task environment. Advances in LCLM architecture and infrastructure now allow these models to outperform retrieval-augmented systems in many contexts, reducing reliance on complex external scaffolding.  Researchers from Stanford, IBM, and the University of Toronto explored whether complex scaffolding is necessary for LM agents tackling tasks like SWE-bench. They show that simply using LCLMs, such as Gemini-1.5-Pro, with proper prompting and no scaffolding, can achieve competitive performance—reaching 38% on SWE-Bench-Verified. Gemini-2.5-Pro, using the same simple setup, reaches 50.8%. Their work suggests that many complex agentic designs could be replaced with a single powerful LCLM, simplifying architecture and training. Additionally, a hybrid two-stage approach using Gemini-1.5-Pro and Claude-3.7 achieves a 48.6% solve rate, further supporting this simplified direction.  Traditional LM agents rely on interactive exploration due to partial observability, but many tasks, like software debugging, allow full observability. The study proposes state-in-context agents that leverage LCLMs to directly process full or compressed environment states, bypassing the need for complex agentic scaffolding. For large codebases, a ranking-based compression selects relevant files to fit within context limits. Two methods are introduced: DIRECTSOLVE, where LCLMs solve tasks using the full context; and SELECTSOLVE, where LCLMs localize relevant files for short-context LMs (SCLMs) to solve. Both use targeted patch formats and validation to ensure accuracy and reduce hallucination.  The experiments evaluate a simplified agent framework using LLMs on the SWE-bench Verified benchmark, which includes 500 real-world software engineering tasks. The proposed methods, DIRECTSOLVE and SELECTSOLVE, utilize LCLMs like Gemini-1.5-Pro and Gemini-2.5-Pro, and in SELECTSOLVE, an additional SCLM (Claude-3.7-Sonnet) for patch generation. Results show that DIRECTSOLVE outperforms complex agentic approaches like Agentless and CodeAct with minimal engineering. SELECTSOLVE further improves accuracy by leveraging stronger models for patching. Ablation studies highlight the importance of CoT prompting, code restatement, and token-efficient context design. Additionally, positioning relevant files at the start of the prompt improves performance, underscoring limitations in long-context processing.  In conclusion, the cost of using LCLM-based methods is currently higher than existing approaches like Agentless and CodeAct, averaging $2.60 per instance compared to $0.25 and $0.87, respectively. However, rapid drops in inference costs and increasing context lengths make LCLMs more practical. Techniques like KV caching significantly lower costs after initial runs, reducing it to about $0.725. Although slight codebase changes still limit caching benefits, further improvements could help. The study also suggests that LCLMs can handle long interaction histories, reducing the need for complex memory and retrieval mechanisms. Notably, unscaffolded LCLM models can perform competitively on SWE-bench tasks.  Check out the Paper. All credit for this research goes to the researchers of this project. Also, feel free to follow us on Twitter and don’t forget to join our 90k+ ML SubReddit. Sana HassanSana Hassan, a consulting intern at Marktechpost and dual-degree student at IIT Madras, is passionate about applying technology and AI to address real-world challenges. With a keen interest in solving practical problems, he brings a fresh perspective to the intersection of AI and real-life solutions.Sana Hassanhttps://www.marktechpost.com/author/sana-hassan/This AI paper from DeepSeek-AI Explores How DeepSeek-V3 Delivers High-Performance Language Modeling by Minimizing Hardware Overhead and Maximizing Computational EfficiencySana Hassanhttps://www.marktechpost.com/author/sana-hassan/Meet LangGraph Multi-Agent Swarm: A Python Library for Creating Swarm-Style Multi-Agent Systems Using LangGraphSana Hassanhttps://www.marktechpost.com/author/sana-hassan/ByteDance Introduces Seed1.5-VL: A Vision-Language Foundation Model Designed to Advance General-Purpose Multimodal Understanding and ReasoningSana Hassanhttps://www.marktechpost.com/author/sana-hassan/Researchers from Tsinghua and ModelBest Release Ultra-FineWeb: A Trillion-Token Dataset Enhancing LLM Accuracy Across Benchmarks 🚨 Build GenAI you can trust. ⭐️ Parlant is your open-source engine for controlled, compliant, and purposeful AI conversations — Star Parlant on GitHub! (Promoted)

Sony Interactive Entertainment’s next-gen VR headset, the PlayStation® VR2 (PS VR2), launches today, and we’re excited to share the latest tools you can use to build for this innovative platform. In this post, we’ll cover two aspects of developing for PS VR2: graphics and inputs.PS VR2 leverages PS5’s next-gen computing and graphics power to help you create stunning, high-performing VR games. You can target a 4k resolution equivalent, running titles at 60Hz, 90Hz, or 120Hz, which should be achievable with the PS5 using some of the techniques discussed below.First, let’s start off with render pipelines. We recommend the Universal Render Pipeline (URP) for most VR developers because URP will be our first render pipeline to support some of PS VR2’s unique features, such as foveated rendering and gaze tracking. You can also use the Scriptable Render Pipeline (SRP), Built-in Render Pipeline, and High Definition Render Pipeline (HDRP), but be aware that some features, like foveated rendering, are only available on URP for the time being.Overall, URP is a great match for VR games. It’s flexible, straightforward to use, and customizable. It also works well if you’re building for multiple platforms, including all-in-one VR devices. You can make your own custom render pipeline using SRP, and we provide an extensive C# API that allows you to implement any renderer your games require.The PS5 also provides advances on the GPU side through its new NGGC Graphics API. With NGGC, we’ve taken advantage of the optimization technologies available on PS5 in ways that were previously unavailable. We’ve also rearchitected our rendering backend to allow efficient utilization across multiple cores while improving GPU state transitions. This adds up to more efficient rendering in terms of CPU, GPU, and memory usage while offering the same visual results, without any reauthoring of assets or game code.PS VR2 will be able to use a technique known as foveated rendering. This technique helps you make VR games with better visual fidelity by decreasing the GPU rendering workload required for a given scene. Foveated rendering is used to improve GPU performance by reducing image quality in peripheral vision.PS VR2’s hardware can go a step further by using eye tracking to optimize GPU rendering. By projecting the eye-gaze information into screen space, you’re able to render at high quality in the precise screen area where a player is looking.The intent of foveated rendering and eye tracking is to keep the image quality high in those parts of the image deemed important, while smoothly fading to lower resolutions in areas of the image considered to be less important. This means that you can reduce the size of some render targets while still keeping quality where you want it.We’ve removed all of the complexity of setting this up in Unity, allowing you enough control over the degree of foveation to be able to balance image quality versus GPU performance for your specific requirements.With this capability, foveated rendering on PS VR2 can be up to 2.5x faster, without any perceptual loss compared to equivalent image quality through standard stereo rendering. We’ve also seen gains up to 3.6x faster when foveated rendering is combined with eye tracking. (Note that these tests represent ideal increases in performance, tested on a Unity demo, and numbers will vary based on your game.)Foveated rendering on PS VR2 can bring a massive reduction in GPU usage while producing the same perceptual quality – and, combined with eye tracking technology, the performance gains are even better.Outside of graphics performance, eye tracking also unlocks a new input method. You can use eye tracking to allow users to select items from menus, start interactions with NPCs, use in-world tools, and more. Eye tracking could even be a focal point of the gameplay mechanics.Leveraging eye tracking works in much the same way as other XR input devices. You have access to the components for eye gaze, which is a combination of position and rotation across both eyes that defines a place in the virtual world. You can use this to tell where the user is currently looking.In addition to basic pose information, you will also have access to pupil diameter and blinking states for both of the player’s eyes. Combining these with the pose, you can start to form your own ideas around gameplay and interaction to more deeply engage with players.Here is an example of a simple gaze-based reticle:You’ll see a gaze tracker object that drives the movement of the reticle in this script, using the same TrackedPoseDriver that we might use to track any other XR controller in Unity. This one just happens to be tied to the eyeGazePosition and eyeGazeRotation set up in our Input System Action Map. There is also a TrackedPoseProvider specifically made to handle eye tracking if you are planning to use the more traditional Unity input methods.The new Sense Controllers are available for Unity developers and include interesting unique features only found on PS VR2.Finger touch detection uses capacitive touch to detect when a player’s fingers are resting on the buttons without actually pressing them. These controls are available on all the primary buttons and thumbsticks, so you can use them to drive more natural gestures with players’ hands during gameplay. You could also, in a more basic approach, drive a hand model to enable players to “see” where their fingers are when they look at the controller. This can really help players stay focused and immersed in an experience without having to lift the headset up or feel around for a specific button.PS VR2 uses inside-out tracking technology for the new system, giving you six-degree of freedom tracking for both the headset and controllers. You can now use most, if not all, of the standard Unity XR stack, making it easier to develop your games for broader platform reach. To set up the controllers themselves, we have exposed these input controls through both traditional Unity Input Manager and the newer Input System package.In addition to eye tracking and controller input, PS VR2’s SDK also allows full control over PS VR2 Sense technology haptics. This includes audio-based haptic feedback to provide a deeper experience for players, as well as a more traditional vibration support. The new controllers also include the same Adaptive Triggers available with PS5 DualSense controllers, meaning you can program the triggers with different styles of feedback based on game context. In addition to controller-based haptics, PS VR2 has added headset feedback, allowing you to give players adjustable vibration in the headset. This could be used to alert players of an event, or combined with audio to add more realistic sensation to experiences.We have worked hard to give you flexibility when it comes to integrating PS VR2 input and haptics into your games. With a combination of tracking improvements and a standard Unity XR SDK for PS VR2, you can leverage the full Unity XR stack, including things like the XR Interaction Toolkit, other XR SDK-dependent assets, Unity Asset Store packages, and other packages available through the Unity Package Manager.These features allow you to explore new forms of gameplay and worldbuilding.PS VR2 is available today, and you can build for it with Unity 2021 LTS and later. Foveated rendering requires Unity 2022.2 and later. We’re excited to see what this headset means for the VR industry as it unlocks a new level of performance and input controls for you to build even more immersive and exciting experiences.You’ll need an active Unity Pro subscription (or a Preferred Platform license key provided by the respective platform holder) to access these specific build modules via developer platform forums. Register here to become a PlayStation developer.Share your PS VR2 and PS5 games with us using the #MadewithUnity hashtag on social media. Have questions? Registered PlayStation developers can connect with us in the Unity forum on the PlayStation developer site.

Editor's take: Whether these fines will persuade the public to switch to legal streaming services remains to be seen. For now, Italian authorities have made clear that they are prepared to pursue not only the suppliers but also the consumers of pirated content, marking a new chapter in the fight against digital piracy. In a significant escalation of its campaign against illegal streaming, Italy has begun issuing fines to thousands of individuals who subscribed to pirate IPTV services. This move follows a recent memorandum of understanding among the Prosecutor's Office, the Guardia di Finanza (a military police force in Italy), and the country's communications regulator AGCOM, which established a framework for sharing information on users of unauthorized streaming platforms. While the precise origin of the subscriber data remains undisclosed, it is believed to have been gathered during frequent law enforcement raids targeting illicit IPTV operations. These raids have yielded databases containing emails and other identifying information, enabling authorities to target end-users directly for the first time. The crackdown is rooted in Law 93/2023, anti-piracy legislation passed last year that allows for fines of up to €5,000 ($5,581) for repeat offenders. The law also introduced the Piracy Shield, a system enabling rapid ISP blocking of unauthorized streams. After the legislation passed, authorities wasted no time making it clear that the era of impunity for IPTV pirates was over. That warning has now materialized into action. At a recent press conference, the Guardia di Finanza revealed that 2,282 individuals across Italy have been fined for their involvement with pirate IPTV services. Initial penalties start at €154 ($172), but officials have stressed that repeat violations could dramatically increase fines, reaching the €5,000 maximum. This marks the first time the new law has been enforced against consumers, not just the operators of illegal services. The current wave of fines is reportedly linked to an operation in Lecce last October, where a major IPTV network was dismantled and subscriber information seized. // Related Stories Authorities have indicated that this is only the beginning, with ongoing investigations in several regions aimed at identifying further offenders. Three additional prosecutors' offices have already launched their inquiries, signaling a sustained national effort. The crackdown is part of a broader strategy to combat digital piracy in Italy, particularly the illegal streaming of football (soccer) matches – a major concern for the country's lucrative sports industry. The financial stakes are high. Luigi De Siervo, CEO of Serie A, has repeatedly emphasized the severe impact of piracy on Italian football, estimating losses of around €1 billion ($1.1 billion) every year due to unauthorized streaming. These losses threaten the financial stability of clubs and the entire football ecosystem, as television rights constitute a vital revenue stream. Paolo Scaroni, president of AC Milan, has highlighted the importance of enforcing existing laws, arguing that providers and consumers of pirated content must face consequences if the industry is to recover from the damage inflicted by piracy. Political support for the crackdown is strong, particularly from Senator Claudio Lotito, the architect of the anti-piracy law and owner of Lazio football club. Lotito has stated unequivocally that those who break the law will now face real and personal repercussions, declaring that the time for leniency is over. Inter Milan president Beppe Marotta echoed this sentiment, likening the new enforcement regime to a shift from a yellow card to a red card in soccer.

In this tutorial, we demonstrate how to build a powerful and intelligent question-answering system by combining the strengths of Tavily Search API, Chroma, Google Gemini LLMs, and the LangChain framework. The pipeline leverages real-time web search using Tavily, semantic document caching with Chroma vector store, and contextual response generation through the Gemini model. These tools are integrated through LangChain’s modular components, such as RunnableLambda, ChatPromptTemplate, ConversationBufferMemory, and GoogleGenerativeAIEmbeddings. It goes beyond simple Q&A by introducing a hybrid retrieval mechanism that checks for cached embeddings before invoking fresh web searches. The retrieved documents are intelligently formatted, summarized, and passed through a structured LLM prompt, with attention to source attribution, user history, and confidence scoring. Key functions such as advanced prompt engineering, sentiment and entity analysis, and dynamic vector store updates make this pipeline suitable for advanced use cases like research assistance, domain-specific summarization, and intelligent agents. !pip install -qU langchain-community tavily-python langchain-google-genai streamlit matplotlib pandas tiktoken chromadb langchain_core pydantic langchain We install and upgrade a comprehensive set of libraries required to build an advanced AI search assistant. It includes tools for retrieval (tavily-python, chromadb), LLM integration (langchain-google-genai, langchain), data handling (pandas, pydantic), visualization (matplotlib, streamlit), and tokenization (tiktoken). These components form the core foundation for constructing a real-time, context-aware QA system. import os import getpass import pandas as pd import matplotlib.pyplot as plt import numpy as np import json import time from typing import List, Dict, Any, Optional from datetime import datetime We import essential Python libraries used throughout the notebook. It includes standard libraries for environment variables, secure input, time tracking, and data types (os, getpass, time, typing, datetime). Additionally, it brings in core data science tools like pandas, matplotlib, and numpy for data handling, visualization, and numerical computations, as well as json for parsing structured data. if "TAVILY_API_KEY" not in os.environ: os.environ["TAVILY_API_KEY"] = getpass.getpass("Enter Tavily API key: ") if "GOOGLE_API_KEY" not in os.environ: os.environ["GOOGLE_API_KEY"] = getpass.getpass("Enter Google API key: ") import logging logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s') logger = logging.getLogger(__name__) We securely initialize API keys for Tavily and Google Gemini by prompting users only if they’re not already set in the environment, ensuring safe and repeatable access to external services. It also configures a standardized logging setup using Python’s logging module, which helps monitor execution flow and capture debug or error messages throughout the notebook. from langchain_community.retrievers import TavilySearchAPIRetriever from langchain_community.vectorstores import Chroma from langchain_core.documents import Document from langchain_core.output_parsers import StrOutputParser, JsonOutputParser from langchain_core.prompts import ChatPromptTemplate, SystemMessagePromptTemplate, HumanMessagePromptTemplate from langchain_core.runnables import RunnablePassthrough, RunnableLambda from langchain_google_genai import ChatGoogleGenerativeAI, GoogleGenerativeAIEmbeddings from langchain.text_splitter import RecursiveCharacterTextSplitter from langchain.chains.summarize import load_summarize_chain from langchain.memory import ConversationBufferMemory We import key components from the LangChain ecosystem and its integrations. It brings in the TavilySearchAPIRetriever for real-time web search, Chroma for vector storage, and GoogleGenerativeAI modules for chat and embedding models. Core LangChain modules like ChatPromptTemplate, RunnableLambda, ConversationBufferMemory, and output parsers enable flexible prompt construction, memory handling, and pipeline execution. class SearchQueryError(Exception): """Exception raised for errors in the search query.""" pass def format_docs(docs): formatted_content = [] for i, doc in enumerate(docs): metadata = doc.metadata source = metadata.get('source', 'Unknown source') title = metadata.get('title', 'Untitled') score = metadata.get('score', 0) formatted_content.append( f"Document {i+1} [Score: {score:.2f}]:n" f"Title: {title}n" f"Source: {source}n" f"Content: {doc.page_content}n" ) return "nn".join(formatted_content) We define two essential components for search and document handling. The SearchQueryError class creates a custom exception to manage invalid or failed search queries gracefully. The format_docs function processes a list of retrieved documents by extracting metadata such as title, source, and relevance score and formatting them into a clean, readable string. class SearchResultsParser: def parse(self, text): try: if isinstance(text, str): import re import json json_match = re.search(r'{.*}', text, re.DOTALL) if json_match: json_str = json_match.group(0) return json.loads(json_str) return {"answer": text, "sources": [], "confidence": 0.5} elif hasattr(text, 'content'): return {"answer": text.content, "sources": [], "confidence": 0.5} else: return {"answer": str(text), "sources": [], "confidence": 0.5} except Exception as e: logger.warning(f"Failed to parse JSON: {e}") return {"answer": str(text), "sources": [], "confidence": 0.5} The SearchResultsParser class provides a robust method for extracting structured information from LLM responses. It attempts to parse a JSON-like string from the model output, returning to a plain text response format if parsing fails. It gracefully handles string outputs and message objects, ensuring consistent downstream processing. In case of errors, it logs a warning and returns a fallback response containing the raw answer, empty sources, and a default confidence score, enhancing the system’s fault tolerance. class EnhancedTavilyRetriever: def __init__(self, api_key=None, max_results=5, search_depth="advanced", include_domains=None, exclude_domains=None): self.api_key = api_key self.max_results = max_results self.search_depth = search_depth self.include_domains = include_domains or [] self.exclude_domains = exclude_domains or [] self.retriever = self._create_retriever() self.previous_searches = [] def _create_retriever(self): try: return TavilySearchAPIRetriever( api_key=self.api_key, k=self.max_results, search_depth=self.search_depth, include_domains=self.include_domains, exclude_domains=self.exclude_domains ) except Exception as e: logger.error(f"Failed to create Tavily retriever: {e}") raise def invoke(self, query, **kwargs): if not query or not query.strip(): raise SearchQueryError("Empty search query") try: start_time = time.time() results = self.retriever.invoke(query, **kwargs) end_time = time.time() search_record = { "timestamp": datetime.now().isoformat(), "query": query, "num_results": len(results), "response_time": end_time - start_time } self.previous_searches.append(search_record) return results except Exception as e: logger.error(f"Search failed: {e}") raise SearchQueryError(f"Failed to perform search: {str(e)}") def get_search_history(self): return self.previous_searches The EnhancedTavilyRetriever class is a custom wrapper around the TavilySearchAPIRetriever, adding greater flexibility, control, and traceability to search operations. It supports advanced features like limiting search depth, domain inclusion/exclusion filters, and configurable result counts. The invoke method performs web searches and tracks each query’s metadata (timestamp, response time, and result count), storing it for later analysis. class SearchCache: def __init__(self): self.embedding_function = GoogleGenerativeAIEmbeddings(model="models/embedding-001") self.vector_store = None self.text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200) def add_documents(self, documents): if not documents: return try: if self.vector_store is None: self.vector_store = Chroma.from_documents( documents=documents, embedding=self.embedding_function ) else: self.vector_store.add_documents(documents) except Exception as e: logger.error(f"Failed to add documents to cache: {e}") def search(self, query, k=3): if self.vector_store is None: return [] try: return self.vector_store.similarity_search(query, k=k) except Exception as e: logger.error(f"Vector search failed: {e}") return [] The SearchCache class implements a semantic caching layer that stores and retrieves documents using vector embeddings for efficient similarity search. It uses GoogleGenerativeAIEmbeddings to convert documents into dense vectors and stores them in a Chroma vector database. The add_documents method initializes or updates the vector store, while the search method enables fast retrieval of the most relevant cached documents based on semantic similarity. This reduces redundant API calls and improves response times for repeated or related queries, serving as a lightweight hybrid memory layer in the AI assistant pipeline. search_cache = SearchCache() enhanced_retriever = EnhancedTavilyRetriever(max_results=5) memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True) system_template = """You are a research assistant that provides accurate answers based on the search results provided. Follow these guidelines: 1. Only use the context provided to answer the question 2. If the context doesn't contain the answer, say "I don't have sufficient information to answer this question." 3. Cite your sources by referencing the document numbers 4. Don't make up information 5. Keep the answer concise but complete Context: {context} Chat History: {chat_history} """ system_message = SystemMessagePromptTemplate.from_template(system_template) human_template = "Question: {question}" human_message = HumanMessagePromptTemplate.from_template(human_template) prompt = ChatPromptTemplate.from_messages([system_message, human_message]) We initialize the core components of the AI assistant: a semantic SearchCache, the EnhancedTavilyRetriever for web-based querying, and a ConversationBufferMemory to retain chat history across turns. It also defines a structured prompt using ChatPromptTemplate, guiding the LLM to act as a research assistant. The prompt enforces strict rules for factual accuracy, context usage, source citation, and concise answering, ensuring reliable and grounded responses. def get_llm(model_name="gemini-2.0-flash-lite", temperature=0.2, response_mode="json"): try: return ChatGoogleGenerativeAI( model=model_name, temperature=temperature, convert_system_message_to_human=True, top_p=0.95, top_k=40, max_output_tokens=2048 ) except Exception as e: logger.error(f"Failed to initialize LLM: {e}") raise output_parser = SearchResultsParser() We define the get_llm function, which initializes a Google Gemini language model with configurable parameters such as model name, temperature, and decoding settings (e.g., top_p, top_k, and max tokens). It ensures robustness with error handling for failed model initialization. An instance of SearchResultsParser is also created to standardize and structure the LLM’s raw responses, enabling consistent downstream processing of answers and metadata. def plot_search_metrics(search_history): if not search_history: print("No search history available") return df = pd.DataFrame(search_history) plt.figure(figsize=(12, 6)) plt.subplot(1, 2, 1) plt.plot(range(len(df)), df['response_time'], marker='o') plt.title('Search Response Times') plt.xlabel('Search Index') plt.ylabel('Time (seconds)') plt.grid(True) plt.subplot(1, 2, 2) plt.bar(range(len(df)), df['num_results']) plt.title('Number of Results per Search') plt.xlabel('Search Index') plt.ylabel('Number of Results') plt.grid(True) plt.tight_layout() plt.show() The plot_search_metrics function visualizes performance trends from past queries using Matplotlib. It converts the search history into a DataFrame and plots two subgraphs: one showing response time per search and the other displaying the number of results returned. This aids in analyzing the system’s efficiency and search quality over time, helping developers fine-tune the retriever or identify bottlenecks in real-world usage. def retrieve_with_fallback(query): cached_results = search_cache.search(query) if cached_results: logger.info(f"Retrieved {len(cached_results)} documents from cache") return cached_results logger.info("No cache hit, performing web search") search_results = enhanced_retriever.invoke(query) search_cache.add_documents(search_results) return search_results def summarize_documents(documents, query): llm = get_llm(temperature=0) summarize_prompt = ChatPromptTemplate.from_template( """Create a concise summary of the following documents related to this query: {query} {documents} Provide a comprehensive summary that addresses the key points relevant to the query. """ ) chain = ( {"documents": lambda docs: format_docs(docs), "query": lambda _: query} | summarize_prompt | llm | StrOutputParser() ) return chain.invoke(documents) These two functions enhance the assistant’s intelligence and efficiency. The retrieve_with_fallback function implements a hybrid retrieval mechanism: it first attempts to fetch semantically relevant documents from the local Chroma cache and, if unsuccessful, falls back to a real-time Tavily web search, caching the new results for future use. Meanwhile, summarize_documents leverages a Gemini LLM to generate concise summaries from retrieved documents, guided by a structured prompt that ensures relevance to the query. Together, they enable low-latency, informative, and context-aware responses. def advanced_chain(query_engine="enhanced", model="gemini-1.5-pro", include_history=True): llm = get_llm(model_name=model) if query_engine == "enhanced": retriever = lambda query: retrieve_with_fallback(query) else: retriever = enhanced_retriever.invoke def chain_with_history(input_dict): query = input_dict["question"] chat_history = memory.load_memory_variables({})["chat_history"] if include_history else [] docs = retriever(query) context = format_docs(docs) result = prompt.invoke({ "context": context, "question": query, "chat_history": chat_history }) memory.save_context({"input": query}, {"output": result.content}) return llm.invoke(result) return RunnableLambda(chain_with_history) | StrOutputParser() The advanced_chain function defines a modular, end-to-end reasoning workflow for answering user queries using cached or real-time search. It initializes the specified Gemini model, selects the retrieval strategy (cached fallback or direct search), constructs a response pipeline incorporating chat history (if enabled), formats documents into context, and prompts the LLM using a system-guided template. The chain also logs the interaction in memory and returns the final answer, parsed into clean text. This design enables flexible experimentation with models and retrieval strategies while maintaining conversation coherence. qa_chain = advanced_chain() def analyze_query(query): llm = get_llm(temperature=0) analysis_prompt = ChatPromptTemplate.from_template( """Analyze the following query and provide: 1. Main topic 2. Sentiment (positive, negative, neutral) 3. Key entities mentioned 4. Query type (factual, opinion, how-to, etc.) Query: {query} Return the analysis in JSON format with the following structure: {{ "topic": "main topic", "sentiment": "sentiment", "entities": ["entity1", "entity2"], "type": "query type" }} """ ) chain = analysis_prompt | llm | output_parser return chain.invoke({"query": query}) print("Advanced Tavily-Gemini Implementation") print("="*50) query = "what year was breath of the wild released and what was its reception?" print(f"Query: {query}") We initialize the final components of the intelligent assistant. qa_chain is the assembled reasoning pipeline ready to process user queries using retrieval, memory, and Gemini-based response generation. The analyze_query function performs a lightweight semantic analysis on a query, extracting the main topic, sentiment, entities, and query type using the Gemini model and a structured JSON prompt. The example query, about Breath of the Wild’s release and reception, showcases how the assistant is triggered and prepared for full-stack inference and semantic interpretation. The printed heading marks the start of interactive execution. try: print("nSearching for answer...") answer = qa_chain.invoke({"question": query}) print("nAnswer:") print(answer) print("nAnalyzing query...") try: query_analysis = analyze_query(query) print("nQuery Analysis:") print(json.dumps(query_analysis, indent=2)) except Exception as e: print(f"Query analysis error (non-critical): {e}") except Exception as e: print(f"Error in search: {e}") history = enhanced_retriever.get_search_history() print("nSearch History:") for i, h in enumerate(history): print(f"{i+1}. Query: {h['query']} - Results: {h['num_results']} - Time: {h['response_time']:.2f}s") print("nAdvanced search with domain filtering:") specialized_retriever = EnhancedTavilyRetriever( max_results=3, search_depth="advanced", include_domains=["nintendo.com", "zelda.com"], exclude_domains=["reddit.com", "twitter.com"] ) try: specialized_results = specialized_retriever.invoke("breath of the wild sales") print(f"Found {len(specialized_results)} specialized results") summary = summarize_documents(specialized_results, "breath of the wild sales") print("nSummary of specialized results:") print(summary) except Exception as e: print(f"Error in specialized search: {e}") print("nSearch Metrics:") plot_search_metrics(history) We demonstrate the complete pipeline in action. It performs a search using the qa_chain, displays the generated answer, and then analyzes the query for sentiment, topic, entities, and type. It also retrieves and prints each query’s search history, response time, and result count. Also, it runs a domain-filtered search focused on Nintendo-related sites, summarizes the results, and visualizes search performance using plot_search_metrics, offering a comprehensive view of the assistant’s capabilities in real-time use. In conclusion, following this tutorial gives users a comprehensive blueprint for creating a highly capable, context-aware, and scalable RAG system that bridges real-time web intelligence with conversational AI. The Tavily Search API lets users directly pull fresh and relevant content from the web. The Gemini LLM adds robust reasoning and summarization capabilities, while LangChain’s abstraction layer allows seamless orchestration between memory, embeddings, and model outputs. The implementation includes advanced features such as domain-specific filtering, query analysis (sentiment, topic, and entity extraction), and fallback strategies using a semantic vector cache built with Chroma and GoogleGenerativeAIEmbeddings. Also, structured logging, error handling, and analytics dashboards provide transparency and diagnostics for real-world deployment. Check out the Colab Notebook. All credit for this research goes to the researchers of this project. Also, feel free to follow us on Twitter and don’t forget to join our 90k+ ML SubReddit. Asif RazzaqWebsite |  + postsBioAsif Razzaq is the CEO of Marktechpost Media Inc.. As a visionary entrepreneur and engineer, Asif is committed to harnessing the potential of Artificial Intelligence for social good. His most recent endeavor is the launch of an Artificial Intelligence Media Platform, Marktechpost, which stands out for its in-depth coverage of machine learning and deep learning news that is both technically sound and easily understandable by a wide audience. The platform boasts of over 2 million monthly views, illustrating its popularity among audiences.Asif Razzaqhttps://www.marktechpost.com/author/6flvq/AWS Open-Sources Strands Agents SDK to Simplify AI Agent DevelopmentAsif Razzaqhttps://www.marktechpost.com/author/6flvq/Windsurf Launches SWE-1: A Frontier AI Model Family for End-to-End Software EngineeringAsif Razzaqhttps://www.marktechpost.com/author/6flvq/AI Agents Now Write Code in Parallel: OpenAI Introduces Codex, a Cloud-Based Coding Agent Inside ChatGPTAsif Razzaqhttps://www.marktechpost.com/author/6flvq/A Step-by-Step Guide to Build an Automated Knowledge Graph Pipeline Using LangGraph and NetworkX 🚨 Build GenAI you can trust. ⭐️ Parlant is your open-source engine for controlled, compliant, and purposeful AI conversations — Star Parlant on GitHub! (Promoted)

Control is still the GOAT when it comes to uncanny beauty in video games Unhomely alonely. Image credit: Remedy Entertainment Feature by Christian Donlan Contributing Editor Published on May 18, 2025 Stop me if you've heard this before. We say "uncanny", but in Germany it's "unheimlich". The unheimlich was a big deal for people like Freud, and it's hard not to love the term, just a little bit. Unheimlich means, well, it means uncanny - weird, eerie, unsettling. But more specifically, it translates as "unhomely." Unhomely. Now that is a word that carries a chill, a creep of the flesh, a word that registers an arachnid skittering in the corner of your vision. When something is familiar and unfamiliar all at once! You should feel like you're at home, but... Testify! Rotary telephones with no dials. Bodies suspended in the air with a kind of ballerina poise and elegance. Staff portraits, but they're, like, full-blown oil paintings, dark eyes and unknowable aspects. When it comes to the uncanny, there's one big budget game that really delivers on it for me. It's Control. It's a shooter, I guess, a third-person action game inspired by everything from The X-Files to House of Leaves to tropical Brutalism. There's a splinter of Psi-Ops: The Mindgate Conspiracy and even Stranglehold in there too. But it's also pure, delicious, slow-dripping uncanniness. It's familiar and unfamiliar. It's... Well... Control is set within a building known as the Oldest House, and here, already, things are getting weird. Lots of games are perfectly house-sized. Edith Finch. Maniac Mansion. But a special few are set within houses that feel much bigger than the game they contain - much bigger than a single imagination could ever understand. Jet Set Willy. Impossible Mission. Control. The Oldest House contains Control, then, but it also feels like it contains so many other things, so many other implausible, improbable, impossible things. This week, for example, Remedy gave us a taste of FBC: Firebreak, a hectic multiplayer action game. Yes, it's set in the world of Control, but more specifically it's set within the Oldest House. Why not? There's plenty of room. Here's Aoife's take on Control from back in the day.Watch on YouTube In Control's fiction, the Oldest House is the headquarters of the Federal Bureau of Control. This is a government agency that deals with extremely bizarre stuff. But the Bureau's surfaces are beautiful and often quietly elegant. The face the Oldest House presents to the world is one of tastefully curated mid-century modernism. Wood looks like wood. Tile looks like tile. Concrete looks like concrete, and there's lots of it, along with indoor bays for tropical plants and wide staircases and bright overhead lighting that's perfect for giving ghostly shape to cigarette smoke. Players come to the Oldest House as Jesse, a woman searching for her kidnapped brother. That's a straightforward set up, and a game as unmoored as Control needs it, just as it needs the surprisingly strict confines of its third-person combat. Shoot stuff with a gun that can change form. Throw stuff around with your mind. Explore and clear out monsters as you dig for the truth. There's this unexpected core of extreme orderliness at the center of Control, in terms of what you do most of the time and why you've been told you're doing it. In retrospect, I guess the name of the game was a hint. This orderliness allows the designers to then bolt on all kinds of antic zaniness with no danger of the whole thing collapsing into fripperies, and it reminds me a little of the way that even the most extravagant skyscraper begins with the fixed core of its elevator shafts. (In Control, it's the central elevator that often sends you off on missions. It all works!) Control. | Image credit: Remedy Entertainment The plot is really just there to direct you back and forth through the Oldest House itself, though, and like all uncanny things, transformation is always in the air. Sometimes the Oldest House is doing the transforming. Sometimes you're more directly in charge. Both these approaches are brilliant. When it comes to the Oldest House's own tricks, it tends to start with subtlety. Places will take slightly too long to reach. The signage looks weird and announces unusual departments. The technology is of the wrong era - green-screen computers? Bakelite phones? Radio equipment that looked like it may have been of use during the space race? This is all just the prelude, the aura before the migraine. But soon the Old House is revealing itself in full. Rooms telescope or twist, like the architect behind the place was willing to bust out a Spirograph. Smooth surfaces give way to jumbled blocks. In one area, chill infects the corridors and the glass freezes over, and are those tree trunks in the distance? In another, a furnace radiates the full heat of the sun. This is where that splinter of internal order really helps. It helps to orient. Because you know what you're doing and why you're doing it, the building can transform around you in quite wild ways without becoming frustrating. But the Oldest House also has a lovely sense of pace. It will go wild for a few moments and completely transform itself, but then it turns quiet again. Safe? Ah, but now you're left questioning the simplest things - the background hum, the volume of a room. Did I walk this way before? Was this hallway pointed in the same direction? Control. | Image credit: Remedy Entertainment Further on things get really, really weird, but in a way the Oldest House is at its best before it drops too far into sci-fi. It's at its best when it's got something tricksy, something of the funfair to it. There's an incredible sequence towards the end of the adventure when the Oldest House flings everything at you and you're racing through an environment that warps and twists and strobes, an environment that truly contains multitudes. This is fantastic, and feels like the middle-eight in a song, changing things up and leaving them elevated. But it's not the moment people mention the most in my experience when they talk about Control. That moment is an office that is simply overrun with Post-its. Post-its belong in offices, of course, but here they cover absolutely everything. Familiar and unfamiliar. And kind of funny, too. And here's a thing I really admire about Control. It's willing to be very funny, but not in the way that games about hellish offices normally try to be funny. It doesn't take the top-down approach, so often lifted wholesale from Portal's precision wit and cruelty, in which humans are sane lab-rats in an insane hierarchy of faux camaraderie and corporate double-speak, a world in which there are a million euphemisms for dying at work and there's a slice of cake promised if you can survive. Control. | Image credit: Remedy Entertainment No. Control is funny because it looks at the way all offices affect the people who work within them - how the creeping of weird rules and weird ways of being is slow and measured and often hard to spot. The comedy here comes from how that quietly insane hierarchy in turn warps ordinary people. The fact that it relies on the supernatural, in a way, only makes it more relatable. It's the comedy - and horror - of a room in which someone's really busted out the Post-its. It's the comedy of lamping someone with a photocopier. Here's a trailer for FBC: Firebreak. Are you ready to go back in?Watch on YouTube And with that image, we've the other kind of transformation in Control. It's the transformation brought about by the player, as they encounter the Oldest House's many enemies and use gunfire and numerous supernatural abilities to fight back. The gun you're given is pretty great, but Control's really about telekinesis - about picking stuff up with your brain, watching it sway woozily in the air, and then lobbing it somewhere in order to really hurt something. It's the transformation of impact, of violence and splatter. All that concrete is so eager to come apart in gritty chunks. All those office supplies are ready for a second life as a projectile or cudgel. You can take the Oldest House apart just as quickly as it tries to build itself into something monstrous. When I first played Control I would often end action sequences realising I was just firing wildly into the walls. They seemed, I guess, like a viable target. And while Control's mid-century vibes are very pleasant to engage with, it's the violence - this is a very weird thing to say - that's truly beautiful. When I first played the game, I remember chucking stuff at a filing cabinet for hours, just to enjoy the rippling of its drawers caused by the impact. In the moment of connection, it was briefly alive. And after a particularly fraught battle I remember staring at a crater on the wall, made by the impact of some kind of white foam or powder - maybe the aftermath of a fire extinguisher? This crater, this moon landing on a wall, struck me as being one of the most beautiful things I'd ever seen in a game. Not least because I suspect if I'd played that encounter slightly differently, I would not have seen it. There's so much more to Control than this, but the uncanny takes strange shapes when it lives in the mind, and this is the shape Control has taken for me. It's not the shape of the Oldest House, because who ever could map such a thing? But it's a shape that clearly fits inside the Oldest House. Deep inside, where it works its strange, dark, endlessly charming magic.