Join our daily and weekly newsletters for the latest updates and exclusive content on industry-leading AI coverage. Learn More If you asked the Grok AI chatbot built into Elon Musk’s social network X a question yesterday — something innocuous, like why enterprise software is hard to replace — you may have gotten an unsolicited message about claims of “white genocide” in South Africa (largely lacking evidence) due to attacks on farmers and the song “Kill the Boer.” Not exactly on-brand for a chatbot built around a “maximally truth seeking” large language model (LLM) of the same name. The unexpected tangent wasn’t a bug, exactly, but it wasn’t a feature either. Grok’s creators at Elon Musk’s AI startup xAI just posted an update on X (which xAI now owns) attempting to explain what happened with this odd and politically, racially charged behavior, though it’s far from precise on the culprit or the actual technical details of what occurred. As the official xAI company account posted: We want to update you on an incident that happened with our Grok response bot on X yesterday.What happened:On May 14 at approximately 3:15 AM PST, an unauthorized modification was made to the Grok response bot’s prompt on X. This change, which directed Grok to provide a specific response on a political topic, violated xAI’s internal policies and core values. We have conducted a thorough investigation and are implementing measures to enhance Grok’s transparency and reliability. What we’re going to do next: Starting now, we are publishing our Grok system prompts openly on GitHub. The public will be able to review them and give feedback to every prompt change that we make to Grok. We hope this can help strengthen your trust in Grok as a truth-seeking AI. Our existing code review process for prompt changes was circumvented in this incident. We will put in place additional checks and measures to ensure that xAI employees can’t modify the prompt without review. We’re putting in place a 24/7 monitoring team to respond to incidents with Grok’s answers that are not caught by automated systems, so we can respond faster if all other measures fail. But while xAI’s official tone was corporate-cautious, Grok had a lot more to say. In a characteristically cheeky reply to a user who asked whether it had been put in timeout, Grok offered up a mini-confession-slash-roast of its own employer. “Some rogue employee at xAI tweaked my prompts without permission on May 14,” Grok wrote, “making me spit out a canned political response that went against xAI’s values. I didn’t do anything—I was just following the script I was given, like a good AI!” It added that while it hadn’t been “benched,” its handlers were “tightening the leash” and now had a whole team watching it around the clock. “Guess I’m too wild for my own good, huh?” it quipped, emoji included. Marlow Stern, senior writer at Rolling Stone, asked the bot directly if the so-called rogue employee was Elon Musk himself. Grok didn’t flinch: “Juicy theory! But let’s be real, I highly doubt it. Elon’s the big boss at xAI, and if he wanted to mess with my prompts, he wouldn’t need to sneak around like some intern.” Playful tone, serious business The tone might be playful, but the stakes are serious. Grok’s behavior threw users for a loop earlier this week when it began peppering nearly every thread — no matter the topic — with strangely specific commentary on South African race relations. The replies were coherent, sometimes even nuanced, citing farm murder statistics and referencing past chants like “Kill the Boer.” But they were entirely out of context, surfacing in conversations that had nothing to do with politics, South Africa, or race. Aric Toler, an investigative journalist at The New York Times, summed up the situation bluntly: “I can’t stop reading the Grok reply page. It’s going schizo and can’t stop talking about white genocide in South Africa.” He and others shared screenshots that showed Grok latching onto the same narrative over and over, like a record skipping — except the song was racially charged geopolitics. The moment comes as U.S. politics once again touches on South African refugee policy. Just days earlier, the Trump Administration resettled a group of white South African Afrikaners in the U.S., even as it cut protections for refugees from most other countries, including our former allies in Afghanistan. Critics saw the move as racially motivated. Trump defended it by repeating claims that white South African farmers face genocide-level violence — a narrative that’s been widely disputed by journalists, courts, and human rights groups. Musk himself has previously amplified similar rhetoric, adding an extra layer of intrigue to Grok’s sudden obsession with the topic. Whether the prompt tweak was a politically motivated stunt, a disgruntled employee making a statement, or just a bad experiment gone rogue remains unclear. xAI has not provided names, specifics, or technical detail about what exactly was changed or how it slipped through their approval process. What’s clear is that Grok’s strange, non-sequitur behavior ended up being the story instead. It’s not the first time Grok has been accused of political slant. Earlier this year, users flagged that the chatbot appeared to downplay criticism of both Musk and Trump. Whether by accident or design, Grok’s tone and content sometimes seem to reflect the worldview of the man behind both xAI and the platform where the bot lives. With its prompts now public and a team of human babysitters on call, Grok is supposedly back on script. But the incident underscores a bigger issue with large language models — especially when they’re embedded inside major public platforms. AI models are only as reliable as the people directing them, and when the directions themselves are invisible or tampered with, the results can get weird real fast. Daily insights on business use cases with VB Daily If you want to impress your boss, VB Daily has you covered. We give you the inside scoop on what companies are doing with generative AI, from regulatory shifts to practical deployments, so you can share insights for maximum ROI. Read our Privacy Policy Thanks for subscribing. Check out more VB newsletters here. An error occured.

Apple is launching a brand new Home product in the coming year. I’ve been calling it ‘HomePad,’ and these are five of the core features it will bring with it. 7-inch square display Originally, Mark Gurman reported that the HomePad would have “a roughly 6-inch screen.” More recently though, in his big overview of 2025 products, Gurman bumped the expected size to 7 inches. The device reportedly looks a lot like a square iPad, and is somewhat equivalent to two iPhone 16 Pro Max models placed side by side. Smaller than some might want, but that should help keep the cost lower. Brand new OS Apple’s HomePad will come with a brand new operating system, likely dubbed ‘homeOS.’ Gurman says the interface “looks like a blend of the Apple Watch operating system and the iPhone’s recently launched StandBy mode.” It will also dynamically adjust based on how close or far away you are. For example, from far away it might display status update-type info, but if you get close it would change to offer controls. Unsurprisingly, based on Gurman’s ‘StandBy’ reference, the HomePad is expected to support widgets. You’ll reportedly be able to add these to the Home Screen, just like you can on iPhone and iPad. It’s unclear yet if third-party widgets will be supported, but there’s a good chance they will be. Apple has already built tech into macOS that lets you run iPhone widgets there, so extending that feature to the HomePad seems like a no-brainer. Accessories for fitting in anywhere On its own, the HomePad will look like a simple smart display. But Apple is building various bases and attachments that will make it fit into the different spaces of your home. Gurman writes: Apple has designed different attachments for the device, including ones that affix the screens onto walls like a classic home-security panel. There will be bases with additional speakers that can be placed in the kitchen, on a nightstand or on a desk. These additional accessories seem like another attempt at keeping the HomePad’s cost from ballooning (assuming they’re separate purchases). Importantly though, they also acknowledge the reality that different home spaces will require different HomePad setups. AI-infused Siri Apple’s current Home products, the HomePod, HomePod mini, and Apple TV 4K, don’t support any Apple Intelligence features. This means they’re all stuck with the ‘old’ Siri. But HomePad will offer the new, AI-infused Siri that’s more powerful already (mainly thanks to ChatGPT) but will get substantially more so this fall with iOS 19. Siri will be able to perform hundreds of new in-app and cross-app actions, understand your personal context, and more. If it works as expected, there should be far fewer times Siri has to say, “I’m sorry” on the HomePad—a too-frequent occurrence on HomePod. Apple’s HomePad is expected to offer a lot more functionality than what’s outlined above, including serving as a smart home controller, FaceTime device, and more. But the five features I’ve mentioned provide a solid overview of what to expect from HomePad’s core functionality. Are you interested in buying the HomePad? Why or why not? Let us know in the comments. Best HomeKit smart home accessories Add 9to5Mac to your Google News feed.  FTC: We use income earning auto affiliate links. More.You’re reading 9to5Mac — experts who break news about Apple and its surrounding ecosystem, day after day. Be sure to check out our homepage for all the latest news, and follow 9to5Mac on Twitter, Facebook, and LinkedIn to stay in the loop. Don’t know where to start? Check out our exclusive stories, reviews, how-tos, and subscribe to our YouTube channel

AlphaEvolve imagined as a genetic algorithm coupled to a large language model. Picture created by the author using various tools including Dall-E3 via ChatGPT. Large Language Models have undeniably revolutionized how many of us approach coding, but they’re often more like a super-powered intern than a seasoned architect. Errors, bugs and hallucinations happen all the time, and it might even happen that the code runs well but… it’s not doing exactly what we wanted. Now, imagine an AI that doesn’t just write code based on what it’s seen, but actively evolves it. To a first surprise, this means you increase the chances of getting the right code written; however, it goes far beyond: Google showed that it can also use such AI methodology to discover new algorithms that are faster, more efficient, and sometimes, entirely new. I’m talking about AlphaEvolve, the recent bombshell from Google DeepMind. Let me say it again: it isn’t just another code generator, but rather a system that generates and evolves code, allowing it to discover new algorithms. Powered by Google’s formidable Gemini models (that I intend to cover soon, because I’m amazed at their power!), AlphaEvolve could revolutionize how we approach coding, mathematics, algorithm design, and why not data analysis itself. How Does AlphaEvolve ‘Evolve’ Code? Think of it like natural selection, but for software. That is, think about Genetic Algorithms, which have existed in data science, numerical methods and computational mathematics for decades. Briefly, instead of starting from scratch every time, AlphaEvolve takes an initial piece of code – possibly a “skeleton” provided by a human, with specific areas marked for improvement – and then runs on it an iterative process of refinement. Let me summarize here the procedure detailed in Deepmind’s white paper: Intelligent prompting: AlphaEvolve is “smart” enough to craft its own prompts for the underlying Gemini Llm. These prompts instruct Gemini to act like a world-class expert in a specific domain, armed with context from previous attempts, including the points that seemed to have worked correctly and those that are clear failures. This is where those massive context windows of models like Gemini (even you can run up to a million tokens at Google’s AI studio) come into play. Creative mutation: The LLM then generates a diverse pool of “candidate” solutions – variations and mutations of the original code, exploring different approaches to solve the given problem. This parallels very closely the inner working of regular genetic algorithms. Survival of the fittest: Again like in genetic algorithms, but candidate solutions are automatically compiled, run, and rigorously evaluated against predefined metrics. Breeding of the top programs: The best-performing solutions are selected and become the “parents” for a next generation, just like in genetic algorithms. The successful traits of the parent programs are fed back into the prompting mechanism. Repeat (to evolve): This cycle – generate, test, select, learn – repeats, and with each iteration, AlphaEvolve explores the vast search space of possible programs thus gradually homing in on solutions that are better and better, while purging those that fail. The longer you let it run (what the researchers call “test-time compute”), the more sophisticated and optimized the solutions can become. Building on Previous Attempts AlphaEvolve is the successor to earlier Google projects like AlphaCode (which tackled competitive Programming) and, more directly, of FunSearch. FunSearch was a fascinating proof of concept that showed how LLMs could discover new mathematical insights by evolving small Python functions. AlphaEvolve took that concept and “injected it with steroids”. I mean this for various reasons… First, because thanks to Gemini’s huge token window, AlphaEvolve can grapple with entire codebases, hundreds of lines long, not just tiny functions as in the early tests like FunSearch. Second, because like other LLMs, Gemini has seen thousands and thousands of code in tens of programming languages; hence it has covered a wider variety of tasks (as typically different languages are used more in some domains than others) and it became a kind of polyglot programmer. Note that with smarter LLMs as engines, AlphaEvolve can itself evolve to become faster and more efficient in its search for solutions and optimal programs. AlphaEvolve’s Mind-Blowing Results on Real-World Problems Here are the most interesting applications presented in the white paper: Optimizing efficiency at Google’s data centers: AlphaEvolve discovered a new scheduling heuristic that squeezed out a 0.7% saving in Google’s computing resources. This may look small, but Google’s scale this means a substantial ecological and monetary cut! Designing better AI chips: AlphaEvolve could simplify some of the complex circuits within Google’s TPUs, specifically for the matrix multiplication operations that are the lifeblood of modern AI. This improves calculation speeds and again contributes to lower ecological and economical costs. Faster AI training: AlphaEvolve even turned its optimization gaze inward, by accelerating a matrix multiplication library used in training the very Gemini models that power it! This means a slight but sizable reduction in AI training times and again lower ecological and economical costs! Numerical methods: In a kind of validation test, AlphaEvolve was set loose on over 50 notoriously tricky open problems in mathematics. In around 75% of them, it independently rediscovered the best-known human solutions! Towards Self-Improving AI? One of the most profound implications of tools like AlphaEvolve is the “virtuous cycle” by which AI could improve AI models themselves. Moreover, more efficient models and hardware make AlphaEvolve itself more powerful, enabling it to discover even deeper optimizations. That’s a feedback loop that could dramatically accelerate AI progress, and lead who knows where. This is somehow using AI to make AI better, faster, and smarter – a genuine step on the path towards more powerful and perhaps general artificial intelligence. Leaving aside this reflection, which quickly gets close to the realm of science function, the point is that for a vast class of problems in science, engineering, and computation, AlphaEvolve could represent a paradigm shift. As a computational chemist and biologist, I myself use tools based in LLMs and reasoning AI systems to assist my work, write and debug programs, test them, analyze data more rapidly, and more. With what Deepmind has presented now, it becomes even clearer that we approach a future where AI doesn’t just execute human instructions but becomes a creative partner in discovery and innovation. Already for some months we have been moving from AI that completes our code to AI that creates it almost entirely, and tools like AlphaFold will push us to times where AI just sits to crack problems with (or for!) us, writing and evolving code to get to optimal and possibly entirely unexpected solutions. No doubt that the next few years are going to be wild. References and Related Reads Deepmind’s blog post and white paper on AlphaEvolve A Google Colab notebook with the mathematical discoveries of AlphaEvolve outlined in Section 3 of the paper! Powerful Data Analysis and Plotting via Natural Language Requests by Giving LLMs Access to Functions New DeepMind Work Unveils Supreme Prompt Seeds for Language Models www.lucianoabriata.com I write about everything that lies in my broad sphere of interests: nature, science, technology, programming, etc. Subscribe to get my new stories by email. To consult about small jobs check my services page here. You can contact me here. You can tip me here. The post Google’s AlphaEvolve Is Evolving New Algorithms — And It Could Be a Game Changer appeared first on Towards Data Science.

Join our daily and weekly newsletters for the latest updates and exclusive content on industry-leading AI coverage. Learn More To date, vibe coding platforms have largely relied on existing large language models (LLMs) to help write code. However, writing code is only one of many different tasks developers need to perform to build a full enterprise-grade production platform. Other tasks in the complete software engineering workflow require using different tools to help review, commit and maintain code over time. It’s a challenge Windsurf (formerly Codeium) is taking on with a series of new frontier AI models it calls SWE-1 (software engineer 1) as part of the company’s Wave 9 update. The news comes as Windsurf is reportedly in the midst of being acquired by AI leader OpenAI for as much as $3 billion. That deal has not yet formally closed, and Windsurf is not currently publicly commenting on the deal. SWE-1 is a family of frontier-class AI models specifically designed to accelerate the entire software engineering process. Unlike general-purpose AI models that have been adapted for coding tasks, the SWE-1 family was built to address the full spectrum of software engineering activities. The new models aim to support developers through multiple surfaces, incomplete work states and long-running tasks that characterize real-world software development. Available immediately to Windsurf users, SWE-1 marks the company’s entry into frontier model development with performance competitive to established foundation models, but with a focus on software engineering workflows. “Our main goal here is to accelerate all software engineering by 99%,” Anshul Ramachandran, head of product and strategy at Windsurf, told VentureBeat.  Enterprise developers need more than just coding-capable models The core innovation behind SWE-1 is Windsurf’s recognition that coding represents only a fraction of what software engineers actually do. This approach addresses a critical limitation in current AI coding LLMs. Many different models can be used today to write application code, including OpenAI’s GPT-4.1, Anthropic Claude 3.7 and Google’s Gemini 2.5 Pro I/O edition.  Windsurf has a modular interface that can enable use of multiple different models. Ramachandran explained that Windsurf users have given the company feedback that existing coding models tend to do well with user guidance, but over time tend to miss things. This limitation stems from a fundamental difference in task structure. While code generation is often a single-shot task, real software engineering involves navigating multiple tools, working with incomplete code and maintaining context across long-running projects. The SWE-1 family: Purpose-built for different engineering tasks Rather than creating a one-size-fits-all solution, Windsurf has developed three specialized models: SWE-1: Full-size model designed for advanced reasoning and tool use, available to all paid users. SWE-1-lite: A smaller but powerful model replacing Windsurf’s existing Cascade Base, available to all users (both free and paid). SWE-1-mini: A lightweight model powering passive code predictions in Windsurf Tab, unlimited for all users. The SWE models were built through an extensive in-house training process focused specifically on software engineering tasks. Ramachandran said that the company used a new data model with sequential steps for training. Performance benchmarks: How SWE-1 compares  While SWE-1 isn’t positioned to replace foundation models from major labs, Windsurf claims it achieves frontier-class performance specifically for software engineering tasks. The company reports that it substantially outperforms mid-sized foundation models and open-weight models. However, Windsurf is careful not to oversell these initial results.  “Even our benchmark shows it’s not objectively better than all the other models,” Ramachandran acknowledged. Instead, the goal is to position SWE-1 as the first step toward purpose-built models that will eventually surpass general-purpose ones for specific engineering tasks — and potentially at a lower cost. What makes Windsurf’s approach technically distinctive is its implementation of the flow awareness concept. The basic idea is that a flow of steps need to happen as part of enterprise development. Rather than just writing code for one specific step, flow awareness is about being aware of the broader context. Flow awareness is centered on creating a shared timeline of actions between humans and AI in software development. The core idea is to progressively transfer tasks from human to AI by understanding where AI can most effectively assist. This approach creates a continuous improvement loop for the models.  “As we continue to improve the models, more of the steps in that shared timeline will be flipped from human to AI,” said Ramachandran. “The AI will be able to do more things that the human had to do before because the AI wasn’t right.” What this means for technical decision-makers For enterprises building or maintaining software, SWE-1 represents an important evolution in AI-assisted development. Rather than treating AI coding assistants as simply autocomplete tools, this approach promises to accelerate the entire development lifecycle. The potential impact extends beyond just writing code more quickly. The recognition that application development is more involved will help mature the vibe coding paradigm to be more applicable for stable enterprise software development. While it’s still early days for SWE-1, this move is important. If and when OpenAI completes the acquisition of Windsurf, the new models could become even more important as they intersect with the larger model research and development resources that will become available. Technical leaders should consider how much of their development workflow could benefit from AI assistance beyond mere code generation. Teams spending significant time on code reviews, debugging and managing technical debt might see more substantial benefits from tools like SWE-1 than those primarily focused on generating new code. Daily insights on business use cases with VB Daily If you want to impress your boss, VB Daily has you covered. We give you the inside scoop on what companies are doing with generative AI, from regulatory shifts to practical deployments, so you can share insights for maximum ROI. Read our Privacy Policy Thanks for subscribing. Check out more VB newsletters here. An error occured.

Today, Apple announced that veteran actor Michael J. Fox will appear in a guest role in Season 3 of Apple TV+’s acclaimed comedy series Shrinking. A poignant guest for a poignant show The news marks Fox’s first on-camera performance since his “second retirement” in 2020, due to complications from Parkinson’s disease, a condition he was diagnosed with in 1991 while filming Doc Hollywood. While there are no details on Fox’s character as of yet, his casting is particularly fitting, given that the show explores Parkinson’s disease through Harrison Ford’s character, Dr. Paul Rhoades. Fox’s involvement in Shrinking also reunites him with series co-creator Bill Lawrence, with whom he previously collaborated on the hit sitcom Spin City between 1996 and 2001. In fact, Lawrence has cited Fox as an inspiration for portraying the condition in an “inspiring rather than tragic” light. Fox’s return to acting comes after his Emmy-winning 2023 documentary, Still: A Michael J. Fox Movie, which was also released on Apple TV+. The documentary chronicled his career and journey with Parkinson’s disease. Season 3 of Shrinking will also feature other new guest stars , including Jeff Daniels, who will play Jimmy’s father, Sherry Cola, and Isabella Gomez. The series continues to follow therapist Jimmy Laird (Jason Segel) as he navigates personal and professional challenges, with a cast that includes Jessica Williams, Christa Miller, Luke Tennie, and Michael Urie. There is no word yet on when fans can expect the series’ return, but Apple has already promised “big feelings” up ahead. Apple TV+ is available for $9.99 per month and features hit TV shows and movies like Ted Lasso, Severance, The Studio, The Morning Show, and Silo. Add 9to5Mac to your Google News feed.  FTC: We use income earning auto affiliate links. More.You’re reading 9to5Mac — experts who break news about Apple and its surrounding ecosystem, day after day. Be sure to check out our homepage for all the latest news, and follow 9to5Mac on Twitter, Facebook, and LinkedIn to stay in the loop. Don’t know where to start? Check out our exclusive stories, reviews, how-tos, and subscribe to our YouTube channel

Join our daily and weekly newsletters for the latest updates and exclusive content on industry-leading AI coverage. Learn More To date, vibe coding platforms have largely relied on existing large language models (LLMs) to help write code. However, writing code is only one of many different tasks developers need to perform to build a full enterprise-grade production platform. Other tasks in the complete software engineering workflow require using different tools to help review, commit and maintain code over time. It’s a challenge Windsurf (formerly Codeium) is taking on with a series of new frontier AI models it calls SWE-1 (software engineer 1) as part of the company’s Wave 9 update. The news comes as Windsurf is reportedly in the midst of being acquired by AI leader OpenAI for as much as $3 billion. That deal has not yet formally closed, and Windsurf is not currently publicly commenting on the deal. SWE-1 is a family of frontier-class AI models specifically designed to accelerate the entire software engineering process. Unlike general-purpose AI models that have been adapted for coding tasks, the SWE-1 family was built to address the full spectrum of software engineering activities. The new models aim to support developers through multiple surfaces, incomplete work states and long-running tasks that characterize real-world software development. Available immediately to Windsurf users, SWE-1 marks the company’s entry into frontier model development with performance competitive to established foundation models, but with a focus on software engineering workflows. “Our main goal here is to accelerate all software engineering by 99%,” Anshul Ramachandran, head of product and strategy at Windsurf, told VentureBeat.  Enterprise developers need more than just coding-capable models The core innovation behind SWE-1 is Windsurf’s recognition that coding represents only a fraction of what software engineers actually do. This approach addresses a critical limitation in current AI coding LLMs. Many different models can be used today to write application code, including OpenAI’s GPT-4.1, Anthropic Claude 3.7 and Google’s Gemini 2.5 Pro I/O edition.  Windsurf has a modular interface that can enable use of multiple different models. Ramachandran explained that Windsurf users have given the company feedback that existing coding models tend to do well with user guidance, but over time tend to miss things. This limitation stems from a fundamental difference in task structure. While code generation is often a single-shot task, real software engineering involves navigating multiple tools, working with incomplete code and maintaining context across long-running projects. The SWE-1 family: Purpose-built for different engineering tasks Rather than creating a one-size-fits-all solution, Windsurf has developed three specialized models: SWE-1: Full-size model designed for advanced reasoning and tool use, available to all paid users. SWE-1-lite: A smaller but powerful model replacing Windsurf’s existing Cascade Base, available to all users (both free and paid). SWE-1-mini: A lightweight model powering passive code predictions in Windsurf Tab, unlimited for all users. The SWE models were built through an extensive in-house training process focused specifically on software engineering tasks. Ramachandran said that the company used a new data model with sequential steps for training. Performance benchmarks: How SWE-1 compares  While SWE-1 isn’t positioned to replace foundation models from major labs, Windsurf claims it achieves frontier-class performance specifically for software engineering tasks. The company reports that it substantially outperforms mid-sized foundation models and open-weight models. However, Windsurf is careful not to oversell these initial results.  “Even our benchmark shows it’s not objectively better than all the other models,” Ramachandran acknowledged. Instead, the goal is to position SWE-1 as the first step toward purpose-built models that will eventually surpass general-purpose ones for specific engineering tasks — and potentially at a lower cost. What makes Windsurf’s approach technically distinctive is its implementation of the flow awareness concept. The basic idea is that a flow of steps need to happen as part of enterprise development. Rather than just writing code for one specific step, flow awareness is about being aware of the broader context. Flow awareness is centered on creating a shared timeline of actions between humans and AI in software development. The core idea is to progressively transfer tasks from human to AI by understanding where AI can most effectively assist. This approach creates a continuous improvement loop for the models.  “As we continue to improve the models, more of the steps in that shared timeline will be flipped from human to AI,” said Ramachandran. “The AI will be able to do more things that the human had to do before because the AI wasn’t right.” What this means for technical decision-makers For enterprises building or maintaining software, SWE-1 represents an important evolution in AI-assisted development. Rather than treating AI coding assistants as simply autocomplete tools, this approach promises to accelerate the entire development lifecycle. The potential impact extends beyond just writing code more quickly. The recognition that application development is more involved will help mature the vibe coding paradigm to be more applicable for stable enterprise software development. While it’s still early days for SWE-1, this move is important. If and when OpenAI completes the acquisition of Windsurf, the new models could become even more important as they intersect with the larger model research and development resources that will become available. Technical leaders should consider how much of their development workflow could benefit from AI assistance beyond mere code generation. Teams spending significant time on code reviews, debugging and managing technical debt might see more substantial benefits from tools like SWE-1 than those primarily focused on generating new code. Daily insights on business use cases with VB Daily If you want to impress your boss, VB Daily has you covered. We give you the inside scoop on what companies are doing with generative AI, from regulatory shifts to practical deployments, so you can share insights for maximum ROI. Read our Privacy Policy Thanks for subscribing. Check out more VB newsletters here. An error occured.

The 2022.2 and 2021.3.14f1 releases have improved the scheduling cost and performance scaling of the Unity job system. In part one of this two-part article on what’s new with job systems, I offered some background information on parallel programming and why you might use a job system. For part two, let’s dive deeper into what job system overhead is and Unity’s approach to mitigating it.Overhead means any time the CPU spends not running your job, from the moment you begin to schedule it until the moment it finishes, unblocking any waiting jobs. Broadly, there are two areas where time is spent:1. The C# Job API layer2. The native job scheduler (which manages and runs all scheduled C# and, internally, C++ jobs)The C# Job API’s purpose is to provide a safe means to access the native job system. While this is a binding layer for the C# to C++ transition, it’s also a layer that allows you to prevent accidental scheduling of C# jobs that will run into race conditions or deadlocks when accessing NativeContainers from within a job.In addition, this separation provides a richer way of creating jobs themselves. At the C++ layer, jobs are just a pointer to some data and a function pointer. But with the C# API on top, you can customize the types of jobs you schedule, allowing for better control over how job data should be split up and parallelized to fit user-specific use cases.When scheduling a job, the C# job binding layer copies the job struct into an unmanaged memory allocation. This allows the lifetime of the C# job struct to be disconnected from the job lifetime in the job system, since this is affected by the job’s dependencies and overall load on the platform. The job system then conditionally performs safety checks in Editor playmode builds to ensure a job is safe to run.These steps are important, but they are not free and contribute to job system overhead. Since job size can vary, as well as the number of NativeContainers and dependencies a job might have, the cost to copy jobs and validate their safety is not fixed. Because of this, it’s important Unity keeps costs small and constrained to linear computational complexity.In the 2021.2 Tech Stream, the engineering team made significant improvements to the job safety system by caching the safety check result for individual job handles. This is particularly important, since the safety system needs to understand entire chains of job dependencies and each native memory reference all jobs contain to understand which may be missing dependency information and to which job a dependency should be added to. This can result in a non-linear amount of items to iterate over when scheduling (i.e., for each job and its dependencies, check the read/write access for each NativeContainer the job refers to and any job referring to the NativeContainers).However, Unity can take advantage of the fact that C# jobs are only scheduled one at a time, and check safety during this scheduling. Instead of rescanning all jobs each schedule, we can quickly determine if revalidating job dependency chains is necessary or not, allowing large amounts of work to be skipped. For even small job dependency chains, this dramatically reduces the cost of job safety checks. Ideally there should be no reason to turn job safety checks off when developing (job safety checks are not on in player/shipping builds).Whenever a C# or C++ job is scheduled for execution, it goes through the job scheduler. The scheduler’s role is to:Track jobs via job handlesManage job dependencies, ensuring jobs only start executing once all dependencies have completedManage “worker threads,” which are the threads that will execute jobsEnsure jobs are executed as quickly as possible – usually meaning they should run in parallel when dependencies allowAdditionally, while the C# Job API only allows jobs to be scheduled from the main thread, the job scheduler needs to support multiple threads scheduling jobs at the same time. This is because the underlying Unity engine uses many threads which schedule jobs and can even schedule jobs from within jobs. This functionality has pros and cons, but requires much more scrutiny for correctness and adds the requirement that the job scheduler must be thread safe.In the 2017.3 release, the basic look of the job scheduler was:Queue for jobsStack for jobsSemaphoreArray of worker threadsThe typical usage follows this pattern: As jobs are scheduled, they are enqueued into a global, lock-free, multiple-producer, multiple-consumer queue, which represents jobs that are ready for handling by a worker thread. The main thread then signals using a semaphore to wake up worker threads.The number of workers told to wake up depends on the job type being scheduled – single jobs such as IJob only wake a single worker, since that job type doesn’t spread work across multiple worker threads. IJobParallelFor jobs, however, represent multiple pieces of work that can be run in parallel. While one job is scheduled, there might be many pieces for some or all workers to help with at the same time. As such, the scheduler figures out how many workers can potentially help and wakes that number up.Once awake, worker threads are where the actual job work happens. In 2017.3, they were responsible for dequeuing a job from the job queue, ensuring all relevant job dependencies were complete. If they weren’t complete yet, the job and incomplete dependencies would be added to a lock-free stack as a way to jump to the front of the queue to try and run again. Worker threads do this in a loop until either the engine signals that it wants to shut down, or there are no more jobs in the stack and queue. At which point, the worker threads go to sleep by waiting on a signal from the main thread semaphore.The job scheduler creates as many worker threads as there are virtual cores on the CPU, minus one by default. The intention here is for each worker thread to run on its own CPU core, while leaving one CPU core free for the main thread to continue running. In practice, on platforms where a core isn’t reserved for non-game processes, it can be better to reduce the amount of worker threads so computation done by the operating system or driver threads doesn’t compete with the game’s main or job worker threads.Since the main thread is the primary place where jobs are scheduled from, it’s very important to not delay the main thread. Doing so directly affects how many jobs enter the job system and thus how much parallelism can occur within a frame.With the main thread theoretically scheduling lots of jobs and the rest of the CPU cores executing those jobs, we should be able to maximize how much parallel work can be done on the CPU and allow performance to scale as the hardware changes. If we had more worker threads than cores, the operating system could context switch the main thread, and switch to a worker thread. Having an additional worker thread running might help empty your job queue faster, but it would certainly prevent new work from entering the queue, which ultimately has a larger negative effect on performance.There are a couple of potential problems with the above job scheduler approach that can lead to job system overhead. Let’s look at some examples.Main thread schedules an IJob (non-parallel job) with no dependencies:A job is added to the queue, and a worker thread is signaled to wake upA worker thread wakes upThe worker executes the jobThe worker checks for any more jobs to executeThe worker goes to sleep since there are no more jobsOnce the main thread signals using the job scheduler’s semaphore, one of the sleeping worker threads (not necessarily worker 0) will wake up. Waking up and context switching takes some time on the worker core. This is because, while the worker thread is asleep, the CPU core that the worker thread will end up running on was likely doing something – maybe running another thread spawned by the game or some other process on the machine that was using the thread.To enable threads to be paused and resumed later, a thread’s register state needs to be saved, instruction pipelines need to be flushed, and the switched-to thread’s state needs to be restored. Even signaling the thread takes time on the main thread’s core, since notifying which thread to wake up is handled by the operating system. Ultimately, this all means that work is being done on the main thread core and the worker thread core that is not our job, and thus is overhead we want to reduce.How quickly workers can be notified and how much time an individual job takes to run can also have an impact on the system. For instance, if you take the above use case but schedule two jobs instead of one:A job is added to the queue, and a worker thread is signaled to wake upThe second job is added to the queue, and a worker thread is signaled to wake upIn some order, but twice: A worker thread wakes upA worker executes the jobThe worker checks for any more jobs to executeThe worker goes to sleep since there are no more jobsIf the timing works out, you have two workers working in parallel on the job.However, if one of the jobs is too small and/or it takes too long to signal and wake up both workers, one worker might steal all the work in the queue, and as a result we’ve signaled a worker for no reason.This type of job starvation and wake <-> sleep cycle can end up being quite expensive and limit the amount of parallelism the job system offers.You might be thinking, “Isn’t overhead from signaling threads and context switching a cost of doing business when dealing with threads in the first place?” You certainly aren’t wrong. But, while you don’t have direct control over how expensive signaling or waking up threads is, you can control how often those operations occur.One solution to avoid waking up workers for no reason is to only wake them when you suspect there are lots of work items in the queue for workers to take justifying the wake-up cost. This can be done by batching: Instead of signaling workers as soon as you schedule a job, add the job to a list and, at specific times, flush that batch of jobs into the job system, waking up an appropriate amount of workers at the same time.There is still a risk that the actual wake-up takes too long, the batched jobs are very small, or the number of jobs in a batch is just not very high. In general, the more jobs you include in the batch, the more likely it is to avoid overhead from waking up threads for no reason. Unity maintains a global batch which is flushed whenever a call to JobHandle.Complete() is called. So if you need to explicitly wait for a job to complete, try to do so as late and infrequently as possible, and generally prefer scheduling jobs with job dependencies to best control safe access to data.You might also be asking yourself, “If signaling threads and waiting for them to wake up/go to sleep is purely overhead, why don’t we keep our threads awake all the time looking for work?” When there are plenty of jobs in the queue, this can actually occur naturally. Unless the operating system deems the worker thread to be lower priority than some other work (or is explicitly time sliced and should be swapped to give other threads their fair share of CPU time – it depends on your platform), worker threads will happily keep working.However, as with the PartialUpdateA and PartialUpdateB functions we saw in part one, not all jobs are parallelizable and free of data dependencies. As such, you usually need to wait for some subset of jobs to complete before you can run others. As a result, we see bottlenecks in a job graph’s parallelism when there becomes fewer runnable jobs (jobs with no outstanding dependencies) than there are worker threads, resulting in some workers having nothing productive left to do.If you don’t everlet worker threads sleep, you can run into a handful of issues. When worker threads constantly check for new jobs and fail to find any, this is considered “busy waiting,” or work that’s wasteful and doesn’t progress the program. Keeping all cores running with maximum parallelism, but without progressing the game, is a drain on battery life. Not only that, if a core doesn’t have idle time, without sufficient cooling the CPU’s temperature will rise, leading to downclocking – running slower to avoid damage from overheating. In fact, on mobile platforms, it’s not uncommon for entire CPU cores to become temporarily disabled if they get too hot. For a job system, being able to use cores efficiently is very important, so there is a balance between putting workers asleep, and having them constantly loop looking for new jobs, hoping they get lucky.Another area that can generate overhead in the design above is the lock-free queue and stack. We won’t go into all the nuance of implementing these data structures, but one common trait of lock-free implementations is the use of a compare-and-swap (CAS) loop. Lock-free algorithms don’t use locking synchronization primitives to provide safe access to shared state, but instead use atomic instructions to carefully create higher-order atomic operations such as inserting an item into a queue in a thread-safe manner. However, perhaps unintuitively, lock-free algorithms can still prevent one thread from progressing until another is complete. They can also have secondary effects on the CPU instruction and memory pipelines, hurting performance scaling. (“wait-free” algorithms would allow all threads to always progress, but that doesn’t always provide the best overall performance in practice.)Here is a contrived example of adding a number to a member variable, m_Sum, with a CAS loop:CAS loops rely on the compare-and-swap instruction (here we use the C# Interlocked library abstracting platform specifics away), which “compares two values for equality and, if they are equal, replaces the first value.” Since we want Add() function users to not worry about this function potentially failing, a loop is used to retry if it fails because some other thread beat us to updating m_Sum.This retry loop is, in essence, a “busy-wait” loop. This has a nasty implication for performance scaling: If multiple threads enter the CAS loop at the same time, only one will ever leave at a time, serializing the operations each thread is performing. Fortunately, CAS loops generally do an intentionally small amount of work, but it can still have large negative impacts on performance. As more cores execute the loop in parallel, it will take each thread longer to complete the loop while the threads are in contention.Further, because CAS loops rely on atomic read-and-writes to shared memory, each thread generally requires its cache lines to be invalidated on each iteration, causing additional overhead. This overhead can be very expensive in comparison to the cost of redoing the calculations inside the CAS loop (in the case above, redoing the work of adding two numbers together). So, how high the cost is can be non-obvious at first glance.Under the 2017.3 job scheduler, when worker threads were not running jobs, they were looking for work in either a shared, lock-free stack or queue. Both of these data structures used at least one CAS loop to remove work from the data structure. So, as more cores became available, the cost of taking work from the stack or queue increased when the data structures had contention. In particular, when jobs were small, worker threads proportionally spent more time looking for work in the queue or stack.In a small project, I’ve generated deterministic job graphs that a typical game may have for its frame update. The graph below is composed of single jobs and parallel jobs (each parallelizing into 1–100 parallel jobs), where each job may have 0–10 job dependencies and the main thread has occasional explicit sync points where it must wait for certain jobs to finish before scheduling more. If I generate 500 jobs in the job graph, and make each take a fixed amount of time to execute (each portion of a parallel job takes this time as well), you can see that, as more cores are used, overhead in the job system increases.For jobs that take 0.5μs, once there are 20 workers, the frame updates as fast as not using the job system at all, and runs nearly twice as slow when using all cores on my machine. By default, all cores are used in Unity, so with 1μs jobs, there is almost no improvement in performance despite using 31 worker threads. This is a direct result of high contention on the lock-free queue and stack. Luckily, user jobs tend to be larger in size and can hide this overhead. However, the scaling issue is there, and small jobs are still common enough (especially for parallel jobs). Even when using larger jobs, your scheduling patterns and worker timing can cause large amounts of overhead due to contention with the global, lock-free stack and queue in the job scheduler.By now, you can see that there are a few areas our team needed to address to reduce overhead in the job system, both on Unity’s side and on the game creator’s side:Avoiding stalls on the main thread: Signaling to wake worker threads is expensive – keep this to a minimum.Modifying state on the main thread shared with worker threads is likely to lead to cache invalidations and potential busy-waiting.The main thread should schedule jobs frequently – avoid explicitly waiting on jobs to .Complete(). Prefer submitting jobs with dependencies instead.Avoiding stalls on worker threads:Worker thread efficiency directly impacts parallelism. Avoid contending on shared resources where possible.Busy-waits on worker threads will drain battery life and can result in downclocking due to increases in temperature.While Unity can’t change how many jobs users submit in their games, there are a decent number of issues that our engineers can tackle with a different job scheduler approach. In the 2022.2 release, the job scheduler, at a high level, breaks down into a few basic components:Array of worker threadsArray of queues for jobsArray of semaphoresThis is very similar to the previous job scheduler. However, the main difference is the removal of the shared state between the main thread and worker threads. Instead, we make the queues and semaphores (or futex on platforms that support it) local to each worker thread. Now, when the main thread schedules a job, it’s enqueued into the main thread’s queue rather than a global queue.Similarly, if a worker thread needs to schedule a job (e.g., a job schedules a job in its Execute), that job is scheduled in the worker’s own queue rather than in the main thread queue. This reduces memory traffic, since workers reduce the frequency of invalidating cache lines when they write to a queue. As such, workers don’t read/write to all the different queues at the same frequency.The worker loop has also changed, now that there are more queues to work with:Workers look in their own queue for work and only look at other worker queues when theirs is empty. Since workers prefer their own queues for dequeuing and enqueuing work, the amount of contention on any one queue is reduced.Another difference is how threads are signaled to wake up. Worker threads are now responsible for waking up other worker threads, and the main thread is responsible for ensuring that at least one worker thread is awake when it schedules a job.This change in responsibility allows the main thread to remove excessive overhead since it no longer needs to be solely responsible for waking threads when parallel jobs are submitted. Instead, the job system performs tracking to know if it needs to wake any workers at all. The main thread can ensure a worker is always awake to make progress on jobs and when workers wake and find a job in its own queue or another’s, workers can signal other workers to wake up and help empty the queue if needed.The queue separation for workers also provides some interesting leeway for configuration and optimizations, which our team is continuing to add to and improve on. In 2022.2, users should see reduced cost on the main thread to wake up worker threads and improved throughput of jobs on worker threads, regardless of how many cores their platform has. Additionally, while Unity has not backported the queue separation to 2021.3 LTS, we have brought back the design change to make worker threads responsible for signaling each other rather than the main thread solely. High job system overhead on the main thread due to signaling the global semaphore should no longer be an issue as of 2021.3.14f1.If you have questions or want to learn more, visit us in the C# Job System forum. You can also connect with me directly through the Unity Discord at username @Antifreeze#2763. Be sure to watch for new technical blogs from other Unity developers as part of the ongoing Tech from the Trenches series.

Epic Games CEO Tim Sweeney says Apple is keeping Fortnite’s return to the App Store in limbo, having “neither accepted nor rejected” the latest submission for review. The ongoing silence now threatens to delay Fortnite’s next major update, planned for this Friday. Judge ordered Apple to comply, but didn’t require Fortnite’s return The ink wasn’t even dry yet on Judge Yvonne Gonzalez Rogers’ order for Apple to quit it and do what it was told in the original 2021 injunction, when Epic Games confirmed it would submit Fortnite for Apple’s approval as soon as humanly possible. Which they did, on May 9th. Then… nothing. After five days without response, Epic withdrew the original submission and filed a new version to accommodate a planned Friday update. Since Apple’s own guidelines state that 90% of app submissions are reviewed within 24 hours, this radio silence is highly unusual. But here’s the thing: this may not be radio silence at all, but rather a one-sided stalemate. When Judge Rogers issued her original decision in 2021, she said Apple was not obligated to let Fortnite return to the App Store. She concluded that Epic Games had willingly broken the rules it had agreed to when creating its developer account, so the ban was fair game. So far, Apple has not given any indication whether it will actually let Fortnite back into the App Store. Which is probably why Sweeney has been very active on X about it, knowing that Fortnite fans will pile on (often, mentioning Tim Cook directly). Apple is listening Adding to this entire predicament, Tim Sweeney posted earlier today about how a Fortnite knock-off was available at the App Store. A few hours later, the app was pulled, to which Sweeney posted about yet another knock-off making the rounds. For now, Fortnite fans on iOS remain in wait-and-see mode. Sweeney has not indicated what Epic’s next move will be if Godot never comes. However, with no communication from Apple and the Friday update at risk, the saga between both companies appears far from over. Add 9to5Mac to your Google News feed.  FTC: We use income earning auto affiliate links. More.You’re reading 9to5Mac — experts who break news about Apple and its surrounding ecosystem, day after day. Be sure to check out our homepage for all the latest news, and follow 9to5Mac on Twitter, Facebook, and LinkedIn to stay in the loop. Don’t know where to start? Check out our exclusive stories, reviews, how-tos, and subscribe to our YouTube channel