📰 English IT Daily · 2026-06-25

OpenAI has unveiled its first custom chip, built with Broadcom. The new processor is designed for inference, which means running an AI model after training is complete. In simple terms, inference is the stage when a model answers questions, creates text, or processes user requests. The announcement shows that OpenAI wants more control over the hardware behind its services.

Broadcom is a major chip company, and working with it may help OpenAI design hardware that better fits its software needs. Instead of relying only on general-purpose or third-party AI chips, OpenAI is now moving toward a custom approach. A custom chip is made for a specific job, so it can improve efficiency, reduce delays, and possibly lower operating costs at large scale.

The move also reflects a wider trend in the AI industry. As AI products become more popular, companies need more computing power to serve users quickly and reliably. This has increased interest in specialized hardware for different parts of the AI pipeline. Training usually needs huge amounts of compute, while inference focuses on delivering fast results to users in real time.

For businesses and engineers, the news is important because hardware choices can affect performance, cost, and product design. If a company can optimize inference, it may support more customers with the same resources or build new features with lower latency. Although many technical details are still limited, the announcement suggests that AI companies are investing more deeply in the full stack, from models and software to chips and systems.

A new data center cooling design is drawing attention because it can run liquid at up to 45°C and still cool powerful AI systems effectively. This matters because cooling has long been a major part of data center power use. In many facilities, cooling can take a large share of total electricity, so even small efficiency gains can reduce costs and energy demand at scale.

The design described by NVIDIA uses 100% liquid cooling in a closed loop. In simple terms, the heat is removed directly from chips and networking components by liquid, instead of relying on fans and large amounts of cool air. Because the system can operate with warmer liquid than older designs, it can send heat to outdoor dry coolers more easily. In favorable climates, this may allow chiller-less operation for much of the year.

One of the biggest reported benefits is water savings. Traditional cooling-tower systems may use large volumes of water, especially in hot weather. By contrast, a closed-loop system recirculates the same liquid again and again, so it does not need constant new water for evaporation-based cooling. According to the source, this can reduce facility cooling water use to near zero in some cases, while also lowering mechanical cooling needs.

The wider importance of this approach is not only about one company’s hardware. If more AI infrastructure moves to full liquid cooling, data center operators may rethink how they design power, cooling, and sustainability plans. For cloud and platform engineers, the key lesson is that infrastructure efficiency now depends on system-level design, where server architecture, ambient conditions, and facility cooling must work together rather than as separate parts.

A major recent change in Python is the rise of a free-threaded version of the language. This version removes the global interpreter lock, or GIL, which has long limited how Python threads run. At PyCon US 2026, CPython core developer and steering council member Thomas Wouters discussed the history, purpose, and current status of this effort. He also shared his view of where free-threaded Python may lead in the future.

Threads let a program do more than one task at the same time inside a single process. They are often used for performance because a CPU can work on another task while one task is waiting for memory or a slow operation. Threads can also help when software must call blocking APIs or use third-party libraries that expect thread-based access, such as some database tools. Compared with multiple processes, threads usually have lower overhead and share the same address space.

For many years, CPython used the GIL as its way to support threads. The GIL protects Python objects, reference counts, and some internal parts of the interpreter. Reference counts are small numbers that track whether an object is still being used. However, the GIL also prevents true parallel execution of Python code in many cases. Wouters said that threads are still hard to use correctly, and the GIL does not fully protect user code or C and C++ extensions from thread-safety problems.

The free-threaded interpreter aims to allow multiple threads to run in parallel inside Python itself. This could improve performance for some workloads and make Python more flexible in systems that already depend on threads. At the same time, removing the GIL is not a simple win for every program, because safety, compatibility, and performance must all be balanced. The talk showed that free-threaded Python is both a technical change and a long-term shift in how developers may design Python applications.

Cloudflare has announced self-managed OAuth for all customers, opening a tool that was previously limited to a small group of partner integrations. OAuth is a standard way for users to let an app access a service without sharing their password. In the past, many developers building their own integrations with the Cloudflare API had to use API tokens instead. Those tokens can work well for some tasks, but they are harder to manage in cases where one application needs delegated access from a user.

With this change, developers can create their own OAuth clients and offer a standard consent flow. This means users can clearly see which application is asking for access and what permissions it wants. They can also revoke access more easily if they no longer trust or use the app. According to Cloudflare, this should make it easier to build SaaS integrations, internal developer platforms, and newer agentic tools while giving users more control over their data and application permissions.

The company said it spent the last year improving the security model behind its OAuth system before opening it more widely. It updated the consent experience, added revocation controls in the dashboard, and made app ownership easier to see. These steps are designed to reduce abuse and help prevent OAuth phishing attacks, where a malicious app tries to trick users into granting access. The goal is to scale the app ecosystem while keeping delegated access clear and secure.

Cloudflare also explained that wider OAuth support required major upgrades to the underlying engine that powers the service. It has used Hydra, an open-source OAuth engine, for years, but growing platform usage and more agentic workflows increased the need for better performance and new capabilities. Rather than making one large upgrade, the company planned two smaller sequential upgrades. Even so, database schema migrations and other backend changes still required careful planning to limit user interruption and protect data stability and security.

A software design document is a written plan for how a system or feature should work before developers build it. According to guidance shared by Refactoring English, a strong design doc can save years of development time by forcing teams to think about difficult decisions early. It also helps teammates review ideas and give feedback before a project moves too far in the wrong direction.

The article explains that design docs are especially valuable for complex or risky work. For example, they are useful when several people must coordinate implementation, when a project may take months to complete, or when it will stay in production for years. They also matter when teams work across departments, when requirements are still unclear, or when early planning could prevent serious security or legal problems.

A design doc does not need to be the same for every project. Some projects may need only a short one-page summary, while others may require a much longer document with formal signoff from multiple teams. The right level of detail depends on factors such as risk, deadlines, team culture, and business goals. In some cases, the best decision may even be not to write one at all.

Typical sections in a design doc include the objective, background, goals, non-goals, constraints, interfaces, dependencies, security, privacy, monitoring, timeline, and alternatives considered. The main purpose is not to describe every tiny detail of the final code. Instead, it should clearly explain the hardest problems, the key decisions, and the trade-offs. In simple terms, a design doc is a communication tool that helps teams make better choices before implementation begins.

Ford has been rehiring experienced quality inspectors after some AI systems did not perform as well as expected in vehicle production. The move shows that even advanced automation can struggle in real factories, where small defects may be difficult for software to detect every time. In manufacturing, quality inspection means checking products for problems before they reach customers.

Automakers have invested in AI tools to improve speed, reduce costs, and make production more consistent. These systems can analyze images, sensor data, and patterns on the factory line. However, factory conditions are not always simple or stable. Lighting, dust, reflections, and slight differences between parts can reduce accuracy. When AI misses a defect or marks a good part as bad, it can create delays and extra work.

Ford's decision to bring back so-called 'gray beard' inspectors suggests that human experience still matters in complex tasks. The phrase refers to older workers with deep practical knowledge built over many years. These inspectors may notice unusual sounds, surface marks, or assembly issues that are hard to describe in training data. Their judgment can be especially useful when the problem is rare or when the system meets a new situation it has not learned well.

The case is a reminder that AI is often strongest when it supports people rather than fully replacing them. For business leaders, this means automation should be tested carefully and measured against real-world results. For engineers, it highlights the importance of data quality, system monitoring, and human oversight. In factories and in software, successful AI usually depends not only on the model itself, but also on the process around it.

A web project has shown that Half-Life 2 can run in a browser. The page suggests a playable version of the classic PC game without a normal local install. For many people, this is interesting because Half-Life 2 is known as a large 3D game from an earlier era of PC gaming. Seeing it open through a browser window makes old software feel new again.

The idea is important beyond gaming. A browser is usually used for websites, documents, and online tools, but modern browsers can also support complex graphics and sound. In simple terms, the browser becomes a runtime environment, which means a place where software can execute. If a game like this works well, it shows how far web technology has improved in performance and compatibility.

Projects like this also highlight the value of portability. When software runs through the browser, users may not need the same operating system or the same setup steps. That can reduce friction for testing and access. However, there are still technical limits. A fast internet connection may be needed to download assets, and the experience can depend on memory, device power, and browser support.

For developers, the project is a useful reminder that older applications can sometimes be adapted for new platforms. It also raises questions about preservation, user experience, and licensing. Even if this browser version is mainly a technical demo, it shows a practical lesson: software architecture matters. The more flexible the design is, the easier it can be to move software across environments in the future.

The Xteink X4 is a small e-ink reader reviewed by blogger Max Glenister. It costs about £40 and is designed to be light enough to carry in a pocket or attach to the back of a phone. The device has a 4.3-inch display with 220 PPI, which means 220 pixels per inch, so text looks sharp for its size. It does not have a front light or a touchscreen, but it includes a 16GB microSD card and supports larger storage.

According to the review, the X4 feels extremely light at 77 grams and is easy to carry around. The screen is described as crisp, and page turns are fast with no noticeable ghosting, a faint leftover image sometimes seen on e-ink displays. However, the stock operating system has limits. It offers only a few fonts and basic reading controls. The software also starts in Chinese by default, although the reviewer said it was still possible to switch the interface to English quickly.

One of the most interesting points is the device’s custom firmware ecosystem. The X4 uses an ESP32 processor and supports Wi-Fi, Bluetooth, USB-C, and battery life of up to 14 days with light daily reading. Several community-made firmware projects are available, including CrossPoint, Papyrix, and Inx. CrossPoint now offers over-the-air updates, many interface languages, and easier font installation. Flashing, which means installing new firmware, can be done with a terminal command or a web-based tool in a browser.

The review suggests that custom software greatly improves the reading experience. Papyrix focuses on typography, with advanced text layout, hyphenation, and support for multiple writing systems, including Arabic. Inx is described as broader and more polished, with a tab-based interface and extra features. Overall, the hardware appears strong for the price, while the software is the main reason power users may become interested. For people who enjoy modifying devices, the X4 shows how low-cost hardware can become much more useful through open development.

Dolphin Emulator, a popular open-source project for running GameCube and Wii games on modern devices, has published its Progress Report Release 2606. Progress reports are regular updates that explain what the development team has improved. Instead of focusing on one dramatic new feature, this kind of report usually shows how many small changes can improve stability, speed, and compatibility over time.

An emulator is software that copies the behavior of different hardware so old programs can run on new systems. This work is technically difficult because developers must match the original system very closely. Even a small error can cause a game to crash, freeze, or display graphics incorrectly. For that reason, the Dolphin team often works on bug fixes, performance improvements, and better compatibility across many games and platforms.

For users, these updates matter because they can create a smoother experience without requiring new hardware. Better performance means games can run more efficiently, while stronger compatibility means more titles work as expected. Stability is also important, especially for people who use the emulator for long play sessions, testing, or preservation. In software terms, preservation means keeping older digital content usable in the future.

The report also highlights a common truth in software engineering: progress often comes from continuous improvement rather than sudden change. Open-source projects depend on careful testing, community feedback, and collaboration between developers. Even when an update sounds technical, it can reflect larger lessons about maintaining complex systems. For engineers, Dolphin’s progress report is a useful example of how long-term development, clear communication, and incremental releases can build trust with users.

A recent blog post argues that ignoring DNSSEC can leave internet services open to man-in-the-middle, or MITM, attacks. DNSSEC is a security extension for the Domain Name System, which translates domain names into server addresses. It adds digital signatures so users and systems can check that DNS answers are authentic. The writer compares today’s resistance to DNSSEC with earlier resistance to HTTPS, when many people thought encryption was too complex, risky, or slow.

The post explains the risk with email. Many email clients automatically discover IMAP and SMTP servers through DNS records. If DNSSEC is not used, an attacker on the network may spoof those DNS responses and send the client to a malicious server. The TLS connection may still succeed because the attacker can present a valid certificate for the fake server name. For most users, this would be almost invisible, especially if the fake domain looks similar to a trusted one.

The same problem can affect email delivery between mail servers. A sending server uses MX records to find the receiving server for a domain. If an attacker poisons that DNS response, mail could be sent to the wrong server first. The post notes that this may leave more signs, such as delivery problems, but it is still possible. It also says that MTA-STS can help in some cases, yet it does not fully replace DNSSEC protection.

The article also mentions Matrix, a communication protocol that can delegate services through DNS in a similar way, making it exposed to the same kind of attack if DNSSEC is ignored. In contrast, XMPP works differently in some delegation cases because the TLS certificate must match the original domain, which can limit the attacker’s options. The broader message is that encryption alone is not enough if systems cannot trust the DNS answers that guide connections.