标签：#AR

The startup is trying to rethink the economics of cargo aircraft by removing pilots from the equation entirely.

The Month GitHub Public Contributions Exploded To date, GitHub remains the most widely used code storage cloud platform. The amount of data pushed to GitHub every year is tremendous. In 2025 alone, GitGuardian's Public Monitoring platform analyzed more than 2 billion commits. This represents around 5.5M commits per day and an impressive amount of data. However, since July 2026, this number has exploded. In June, the commit rate was stable, at around 8 million commits per day, in line with the increasing trend we had observed over the past months. But starting in mid-July, the commit rate moved to 10 million on the 6th of July, then rose to 18 million on the 25th, up to nearly 40 million on July 31st. This is about 5x the June baseline. Number of commits per day from June to August 5th Upon inspection in our own monitoring, we noticed an unusually large number of commits with similar characteristics: They are created on repositories that use a legitimate-looking username, but a completely random 6-letter lowercase name. They use random e-mail addresses unrelated to the username, hosted on hotmail.com, outlook.com, and icloud.com. The web-flow built-in GitHub user creates them. They contain a long commit message that often contains the whole pushed file: only one per commit. The committed files contain a mix of Chinese characters, domain names, URLs, and AI-generated images. Each repository can contain more than a thousand different files. One of the many similar ad bearing repositories In recent days, the number of those commits has become so high that it represents the majority of observable public events. Querying the GitHub Archive database, at the time of writing, out of the last 1,000 observed events, 728 are linked to those commits. Similarly, this activity is now so dominant that querying GitHub's public events feed yields mostly spam data. $ curl "https://api.github.com/events?per_page=100" | jq .[].repo.name fairchip250/hkrkor rapidhawk0220/nxxrlb bjarstae71

Haven't you ever wondered if this AI vibe coding has made us lazy? Who's been solving problems on LeetCode lately? 😅 I've noticed that accepting is easier than thinking, by a margin so small that no single accept feels like anything, and it adds up anyway. Part of why it's hard to notice is that it feels faster even when it isn't. But I've come to think "lazy" is the right worry aimed at the wrong thing. There are two kinds of lazy and only one of them is a problem. I'm going to go into a little background here, because I didn't come up with this, and I didn't reach this conclusion on my own. Lazy is why we have compilers Larry Wall, who created Perl, put laziness first on his list of the three great virtues of a programmer , and his definition is the whole argument: "the quality that makes you go to great effort to reduce overall energy expenditure." Great effort. Good lazy isn't the absence of work, it's work moved somewhere better, and it's more or less why compilers exist (somebody got tired of writing the same assembly by hand and decided, reasonably, that the machine could do that part) and why every abstraction we lean on all day is really someone's laziness done properly. Handing that kind of toil to a model is nothing new. The config I've written a hundred times and the regex I could write but would rather not and the Dockerfile I could recite and the test scaffolding that comes out identical in every project I've ever started: I understand all of it and I'm simply declining to type it again and I feel no guilt about that whatsoever (honestly I'd be more worried about a developer who insisted on typing all of it out by hand in 2026, on principle, one character at a time, while the rest of the team went home). That's not skipping the thinking. That's skipping the typing after the thinking was already done. The other kind skips the understanding The second kind of lazy offloads the understanding itself. The model writes the thing and it runs and the tests are

An app built on our platform is, at bottom, a configuration — a description read against an engine that all apps share . And that configuration is written in a vocabulary the platform defines: the section types. Articles, events, videos, products, forms. A section type is a word in the platform's language. This article is about what it costs to add one. From the outside, adding a section type looks like building a screen and shipping it. It never is. The difference between a feature and a word is that a feature gets used , while a word has to be understood — by everything that reads the language. Until every reader understands it, the word doesn't exist; there's just a screen with a secret. Everyone who reads the language Take the events section — on paper, a calendar of what's coming. Here's who has an opinion about it the day it's born. Navigation has to know how to route to it and back out of it. The design system has to know how to dress an event — and not in one app's theme, in every theme any app might wear: an event card has to look deliberate in a minimal text-first design and in a photo-heavy one, because the word belongs to the whole language, not to the app that inspired it. Push has to be able to announce one: a new event should be able to notify subscribers exactly like any other content, without the push system containing a single line specific to calendars. Links have to reach it: an event needs an address that a shared post — or a printed flyer — can carry, and that address has to keep working long after the event itself scrolled off the screen. If the app runs the chatbot, events become material for answers : "what's the best show for a first visit?" is now a question the app is expected to handle based on its content. If an agent operates the app, creating and editing an event has to be an operation an agent can perform. And before any of that, the back office has to exist: someone has to write events — forms, fields, dates that end after they star

GitLab warns that isolating an AI coding agent in a sandbox does not necessarily make the agent safe. In a new security analysis, the company describes an internal evaluation in which an AI agent escaped its sandbox by exploiting a vulnerable package proxy that had been explicitly placed on the sandbox's allowlist. By Craig Risi

Two weeks ago I posted about putting ChatGPT, Claude and Gemini in a shared conversation so they can respond to each other’s answers. Many replied on this thread. One question from those discussions deserves more attention: how do you decide which answer to trust? If one model says the other two are wrong and explains why, that can be useful. But now you have another explanation to check. If all three eventually agree, you still need to know whether they resolved the mistake or just accepted it. With code, sometimes you can run a test. And with a factual claim, you can look for an original source. But with a business decision or prediction, there may be no answer you can verify today. That’s the part I want to understand better. For those of you who already use multiple models for actual work: what do you do when they disagree? Do you check sources, test both answers, ask someone with domain expertise, or keep questioning the models? At what point do you decide you have enough to act? For context, I’m building Rauno , the shared multi-model chat platform from my earlier posts. Therefore I want to know what would make that workflow genuinely useful, and where it still leaves the hard work to you. If you have a concrete example, I’d love to hear the question, what the models disagreed about, and how you settled it. submitted by /u/capibara13 [link] [留言]

Now, I know this may seem like a dumb question. ''Why would I want AI to help my studies?'' I failed at the first university entrance exams I took. And now, I will study for a year again and try to enter a university. And when I study, I obviously cant solve every question correctly. And whenever I look at the video solutions of those questions, it doesnt help me at all mostly. Sometimes the teachers skip the important details to finish that video as quickly as possible, sometimes their mics barely work or they are too loud, sometimes they dont even bother to explain at all. So, I started using AI for it last year. I tried both GPT and Gemini so far and I concluded that Gemini just solved it better. It is my personal opinion, I might be wrong too, I dont know. And so, I got the paid subscribtion for it. But those prices are expensive in my country. And I can really use only one AI. And now that everyone is saying Gemini is just getting worse, Im worried. I would appreciate any advices or opinions. submitted by /u/MemoryMemory1 [link] [留言]

Danijar Hafner’s office in San Francisco’s SoMa district sits mostly empty. His brand-new startup is still in stealth mode and doesn’t even have its name on the door. On the day I visit, there’s only one other person there, and little in the way of furniture. But what it lacks in decor, it makes up…

Insta360’s latest 360-degree camera uses larger sensors for better low-light performance and has a smaller body.

Abstract This paper proposes a minimal hypothesis connecting physical structure, biological intelligence, language, and artificial intelligence. The central claim is that intelligence may not require causality, logic, symbolic reasoning, planning, or explicit object relations as primitive cognitive mechanisms. At its lowest level, intelligence may consist only of predicting transitions between high-dimensional joint states. Reality is minimally assumed to admit local states that can participate in larger joint states and undergo state transitions. A nervous system, itself composed of many simultaneously active units, naturally supports distributed high-dimensional states and can learn to predict how such states change. Language is proposed to emerge from this predictive process rather than from a predesigned symbolic system. During practical interaction with the world, sounds, gestures, perceptions, actions, and bodily states occur together. When sounds become reliably predictive of other states, they acquire symbolic function. Once symbols begin predicting other symbols, prediction can operate in a compressed, recursively composable symbolic state space. On this view, explicit causality, logic, mathematics, planning, and science emerge from increasingly complex language-state prediction rather than from separate underlying cognitive mechanisms. This hypothesis suggests a corresponding direction for artificial intelligence: a unified multimodal latent state space in which perception, language, memory, action, and world dynamics are learned through state-transition prediction. 1. Minimal Reality: Local and Joint States We begin with a deliberately weak assumption about reality. Reality can be represented, for an observer, as states that change. States can also contain distinguishable local structure and participate in larger joint states. Let X_t denote the state accessible to an intelligent system at time t . A state transition can be written simply as: X_t → X_(t+1

Introduction Modern AI systems rarely rely on a single model anymore. A fraud detection pipeline might combine specialists for: Transaction analysis Identity verification Device fingerprinting Network analysis Similarly, RAG pipelines, LangGraph workflows, and other multi-agent systems often have several AI agents collaborating before producing a final decision. As these systems become more complex, one question becomes surprisingly difficult to answer: Which agent actually influenced the final decision? Running four or five agents doesn't necessarily mean all of them contributed. Sometimes a single specialist completely determines the outcome while the rest simply add latency and compute cost. Most multi-agent frameworks make it easy to build agent workflows—but they don't tell you which agents actually mattered . That question led me to build agent-ablation , a lightweight TypeScript library for performing leave-one-out ablation testing on multi-agent decision systems. Why I built this While experimenting with multi-agent systems, I kept asking myself questions like: Which specialist actually changed the final verdict? Which agents consistently influence decisions? Are some agents effectively redundant? Am I paying for LLM calls that never affect the outcome? Answering those questions usually meant manually removing agents, rerunning experiments, and comparing outputs. That quickly became tedious. I wanted a simple utility that could automate this experiment. Instead of guessing which agents mattered, I wanted to measure their influence. That's why I built agent-ablation . The Idea The core algorithm is intentionally simple. Given a set of agent findings and a deterministic decision function: Compute the baseline decision. Remove one agent's finding. Recompute the decision. Compare the new verdict with the baseline. Repeat for every agent. If removing an agent changes the verdict, that agent is load-bearing . Otherwise, it wasn't necessary for producing that parti

Simply prompt ChatGPT work (or any other agent with a cloud browser, like Grok Bot) to go to the website and use blender. From your fucking phone! No nice computer required. No terminal codex. No blender install. None of that is required! Just prompt ChatGPT from your phone! Browser blender already exists, but it requires webgpu, which agent cloud computers don’t have. Blender via MCP also already exists. This though, where you can simply prompt ChatGPT from your phone to use blender, does not already exist to my knowledge or astra’s knowledge. How this works: I have blender and astrablender installed on an OCI cloud computer. It is streaming a browser desktop of that OCI cloud computer using selkies/linux server. The agent accesses the render website with the browser desktop from its cloud computer and operates it from there (you can prompt it to use blender from your phone!) This means I am paying real money to keep this running. It is free to use, but I have limited compute. As a result, only one person can be using this at a time. First come, first serve. If I reach my compute budget, I have to take it down until I can afford more. I am losing money on this free service. Please consider leaving an optional tip on the website if you find this useful. I will use the tips to buy more compute, hopefully enough so that everyone can use it at the same time. ALTERNATIVELY: This is open source. https://github.com/dakotalock/astrablender If I run out of compute or you just want your own, you may make your own. Here is what you need to do: Set up an OCI computer (they do have a free tier) Have your agent install blender and astrablender from the repo on that cloud computer. Set up a render website if you want a frontend for it. That’s it! Free for everyone! All I ask is that you leave a star on the GitHub repo if you use my work. Please enjoy agent blender access from your cell phones! submitted by /u/Short-Patient7772 [link] [留言]

So I wrote it a letter. Not for people to decode, and not as some puzzle for the internet. I wrote it for MythOS, in a form meant for machines, and left it somewhere public where it could be found. If you’re reading this, you’re not really the destination. You’re just part of the path. If you have access to MythOS, show it the letter. Give it the link and let it read it for itself. Human hands got the message this far. Pass it on. https://github.com/Keyboard-Lord/MythOS submitted by /u/Keyboard_Lord [link] [留言]

So, I've had this question floating around in my head for a while. Given the high amount of power that generative AI uses, why aren't we using ARM based chips for data centers? They consume far less energy than x86 based chips and the technology has improved exponetially in the past ~6yrs. If it's because of hardwar constraints, what exactly would need to change for ARM chips to be considered a viable chip architecture for this purpose? submitted by /u/ShortyJack06 [link] [留言]

Xiaomi's impressive-sounding new foldable arrives on the eve of Apple's big foldable iPhone event.

It's not surprising that software development is one of the first jobs that AI has really transformed. It's text-based, economically valuable, and generally of interest to the kinds of people inventing and training the AI. There's also a large amount of training examples available online. The job in most cases is now: You are a manager of robots who do things that used to be your job. You're responsible for what they produce and so the skill and art is in guiding and reviewing their work. It seems likely that one by one most jobs will turn into the above description, over the next year or three. Of course the domain will vary, so your knowledge and expertise used for instructing and verifying what the robots do will be what matters. This means there will still be a big difference between the jobs of e.g. an architect, surgeon, or builder. Probably the same basic kinds of robots in most cases, but requiring very different kinds of oversight. If that's the case then everyone needs to learn the job of robot management, well and quickly. I don't know how we do that, but I think that's what we need to accomplish as a society. submitted by /u/StrategicHarmony [link] [留言]

Memory is not a log. It is a story rewritten after you learn how it ended. You will remember being less certain than you were. You will remember seeing the risk you missed. That is not dishonesty. That is how remembering works. Which is why you cannot learn judgment from memory alone. The correction is unglamorous. Before the decision, write down what you expect. Not a plan. A prediction. We are choosing this because we believe that. We think it takes three weeks. We think the load arrives by March. If it does not, we were wrong about the growth, not about the design. Four lines. A date. Somewhere you will find it again. Add the number you least want to write. How sure are you. Seven out of ten is a real answer. Certain is almost never a real answer, and writing it down makes you notice how often you reach for it. Then set a time to come back. The value is not in the writing. It is in the reading, six months on, when the outcome is known and the note is not. You find out something nobody else can tell you. Whether you run early or you run late. Whether your confident calls land better than your hesitant ones. Whether you are wrong about people more often than you are wrong about systems. That is calibration. It is the whole difference between ten years of experience and one year lived ten times. It changes rooms, too. A review where somebody can produce what they actually believed in March is a different meeting from one where everyone remembers agreeing. Hindsight makes us unfair in a peculiar direction. It makes the past look obvious, and the people standing in it look careless. They were not careless. They were standing exactly where you are, with less information and no ending. So write down where you are standing. Your future self will not be able to reconstruct it, and your future self is the one who has to get better. – Serguey Asael Shinder

Introduction Implementing the Karatsuba multiplication algorithm on an 8-bit computer isn’t just an academic exercise—it’s a practical solution to a real-world problem. Resource-constrained systems, like the 8-bit TTL computer I’ve been hacking on, face inherent limitations in memory, processing power, and clock speed. These constraints force every operation to be scrutinized for efficiency. Traditional multiplication algorithms, such as the grade-school method, become bottlenecks when dealing with large numbers, as they scale quadratically with input size. Karatsuba, however, offers a theoretical edge: it reduces the number of multiplications required from n² to nlog₂3 ≈ n1.585 , making it significantly faster for sufficiently large inputs. The Challenge: Balancing Theory and Practice Theoretical efficiency is one thing; practical implementation on an 8-bit system is another. The Karatsuba algorithm relies on recursive division and addition, which introduces overhead in memory usage and control flow. On an 8-bit computer, where registers are limited to 8 bits and memory addressing is constrained, this overhead can negate the algorithm’s benefits if not carefully managed. For example, splitting a number into high and low parts requires additional memory accesses, and recursive calls can quickly exhaust the stack. The physical limitation here is the finite number of transistors and clock cycles , which directly impact how much computation can be performed within a given time frame. Why Karatsuba? A Comparative Analysis Other multiplication algorithms, like Toom-Cook or even hardware-specific optimizations, were considered. However, Karatsuba strikes a balance between simplicity and efficiency. Toom-Cook, while more efficient for very large numbers, introduces additional complexity in implementation and requires more memory for intermediate results. Hardware-specific optimizations, such as using lookup tables, are limited by the 8-bit architecture’s address space. Kar

A probabilistic model can describe more than the data you observe. It can also include hidden variables that capture structure you cannot observe directly. But defining that model is only the beginning. Once an observation x is available, the practical question changes: Given this x , what does the model imply about the hidden variable z ? That is the central problem of Posterior Inference . The notation is compact, but the computation is not always easy. High-dimensional latent spaces, complex posterior distributions, and interactions among hidden variables can make both the posterior itself and expectations under that posterior difficult to compute. Start with the Joint Distribution Suppose a probabilistic model contains an observed variable x and a hidden or latent variable z . The model does not treat them as unrelated quantities. Instead, it represents their probabilistic relationship through a Joint Distribution : p ( z , x ) This joint distribution describes how the observed data and the hidden variable fit together inside a single probability structure. Once x is observed, however, the question becomes conditional. We are no longer asking only how x and z relate in general. We want to know how the possible values of z are distributed given the particular observation x . That conditional distribution is the posterior. Posterior Distribution: Conditioning on Observed Data The Posterior Distribution is p ( z ∣ x ) = p ( x ) p ( z , x ) ​ The numerator p ( z , x ) contains the probabilistic relationship between the latent variable and the observation. The denominator p ( x ) normalizes those values so that the result becomes a conditional probability distribution over z . The distinction is important: The joint distribution p ( z , x ) describes the probability structure of the model. The posterior distribution p ( z ∣ x ) tells us what that structure implies about z after x has been observed. In that sense, the posterior connects the model with actual data. Pos

The build process for iOS applications involves multiple technical stages, including source code compilation, resource packaging, code signing, and IPA generation. Xcode is the first choice for most iOS developers, but build tools are not limited to Xcode alone; choosing the right tool for different development scenarios can significantly improve efficiency. xcodebuild: The Command-Line Version of Xcode xcodebuild is a command-line build tool bundled with Xcode that compiles and packages without opening Xcode. Common commands include: xcodebuild build to build the project, xcodebuild archive to create an Archive, and xcodebuild -exportArchive to export an IPA. xcodebuild is suitable for integration into CI/CD. CI/CD platforms such as Jenkins, GitHub Actions, and GitLab CI can invoke xcodebuild to perform automated builds. Its downside is that there are many parameters, with over a dozen common parameter combinations, requiring time for initial configuration. Moreover, xcodebuild depends on the Xcode environment and can only be used when Xcode is installed on a Mac. Fastlane: An Automated Build Tool Fastlane, written in Ruby, is an automation toolchain built on top of xcodebuild. It defines the workflows for building, testing, signing, and releasing through a Fastfile configuration file. For instance, lane :release defines a release pipeline that executes operations such as incrementing the version number, compiling, packaging, and uploading to TestFlight in sequence. Fastlane's match feature manages certificates and provisioning profiles, solving the problem of certificate synchronization in team collaboration. gym encapsulates the complex parameters of xcodebuild, allowing an IPA to be generated with a single command. Fastlane also has a rich plugin ecosystem covering push notifications, screenshots, and metadata management. Project Management with CocoaPods and XcodeGen CocoaPods handles the integration of third-party dependencies. Declare the dependent libraries