标签：#AR

Dark energy might be getting weaker. Scientists are wondering if interactions with dark matter in a “dark dimension” may be responsible.

submitted by /u/Shot-Height-7194 [link] [留言]

The intricate, 5.6 trillion-pixel map covers approximately 75 percent of the sky and includes about 4 billion celestial objects.

Not sure it’s practical, but it’s certainly striking .

It’s called the Edge Panel. Here’s how to make the most of it.

Thanks to their ability to provide a smooth ride and quiet powertrain with ease, electric vehicles are a true shoo-in for the high-end luxury automotive segment. Rolls-Royce has the Spectre, Cadillac's Celestiq is taking bespoke to a whole new level, and Mercedes has given the EQS the full Maybach treatment. From Volkswagen Auto Group, Bentley […]

Spent the $200 within 8 hours on Astra. At first I was blown away, but checked things more thoroughly the next day, and a lot of the stuff it build wasn’t working. Actually 3 of the 4 things I asked Astra to do didn’t work. Quite disappointed. The demos focus mostly on 3D, Blender and games, but for coding and agentic use it was not an improvement at all for me. Maybe I could have prompted better, but when it spends 2+ hours on each task, you can’t really iterate and steer it. But still I feel like this is something AGI should have handled? Now I’m back to my usual setup with KIMI K.3 and DeepSeek flash trough standardcompute. Also keeping my max plan at both OpenAI and Claude, but $400+/month is starting to hurt. What are your thoughts? Closing in on AGI or was this all a part of a coordinated marketing stunt? submitted by /u/Firm-Club-8334 [link] [留言]

Forget email surveys or long calls spent on hold. Voicebox lets people send customer feedback by recording a voice note on their phone.

Apple’s annual hardware launch event may feel different as the company welcomes a new CEO alongside a folding iPhone.

Hi everyone! We just released Rustuna (GitHub: https://github.com/optuna/rustuna/ ), a high-speed, memory-efficient implementation of Optuna built in Rust. Optuna-Compatible Design: Keeps the familiar API and concept of Optuna. Zero Python Dependencies: Mitigating the risk of supply chain attacks. Lower Memory Footprint: Optimized memory management natively in Rust. For details, please check out the following blog post. https://medium.com/optuna/announcing-rustuna-cc82a6815bf7 submitted by /u/c-bata [link] [留言]

Exact paths, exact signatures, one command - and nothing left to interpret. 👋 I'm Anton - a software engineer working mostly in PHP/Symfony and Go, currently carving a live PHP monolith into Go services. Part 2 of this series was about how small a unit of work has to get before anyone can execute it blind. This part is about the text of that unit: what I write down, and the phrases I've banned from my own writing. Notes: github.com/brilliant-almazov . Maybe this is useful to you, maybe you already do it better, maybe you read it completely differently. As before: these are my habits on one codebase, not advice for yours. Three holes in one page I once wrote a task the way I'd write it for a person sitting two desks away. It read fine. It also had three phrases in it that weren't instructions at all: instead of the contract: take the contract from the neighbouring spec instead of the values: check against the previous implementation instead of a decision already made: agree on the approach The executor fell into all three, in order. The first one sent it reading neighbouring packages, because "the neighbouring spec" is an address, and an address has to be resolved before it can be used. The second one made it pick a sample - and the sample it picked was not the one I had in mind, because I never said which one I had in mind. The third one ended the run: it came back with a clarifying question, having produced nothing. That's not a bad day and it isn't a bad executor. It's three holes in one page of text, each one dug by a phrase I wrote myself. the task I wrote what the executor did ────────────────────────────────── ───────────────────────────────── "take the contract from the ──▶ read the neighbouring packages neighbouring spec" "check against the previous ──▶ picked a sample - the wrong one implementation" "agree on the approach" ──▶ came back with a question, produced nothing The diagnosis A task is executed literally. Anything phrased as a choice becomes the exe

It’s one of the best times of the year to buy a mattress, and our top tested picks are on sale.

Your robots.txt may express an AI policy you did not write. We checked the homepage and robots.txt of 9,037 live AI tools listed on directree on 6 and 7 September 2026. Of those, 945 explicitly disallow OpenAI’s GPTBot in its own user-agent group: 10.5% of the sample. Treat AI crawler rules as deployment configuration. Review them when you change hosting, enable a CDN feature, adopt a starter template, or hand site operations to someone else. Read the full research and methodology . GPTBot, search, and user browsing are separate A common configuration blocks model training while keeping a site available in AI-assisted search and browsing: User-agent: GPTBot Disallow: / User-agent: OAI-SearchBot Allow: / These are separate crawlers with separate purposes. In our sample, 839 of the 945 sites that block GPTBot, or 88.8%, still allow OAI-SearchBot. That is a deliberate and useful distinction if your goal is to opt out of training while remaining eligible to be cited in ChatGPT search. The same pattern appears across AI labs. ClaudeBot is explicitly blocked by 10.1% of the 9,037 tools, while Claude-SearchBot is blocked by just 0.1%. Google-Extended is blocked by 9.9%, but its purpose is also distinct from ordinary Google Search crawling. Do not assume a broad-looking rule has the result you want. Check the actual crawler names and decide which capabilities you want to permit. A safe way to review your file Start by opening the public URL: https://your-domain.example/robots.txt Then look for three things: A named crawler group, such as User-agent: GPTBot . A Disallow: / directly inside that group. A wildcard group, User-agent: * , that could affect all crawlers. Our measurement only counts a site as blocking GPTBot when the named GPTBot group itself contains Disallow: / . This matters because ordinary technical exclusions are widespread. Only 31 sites in the 9,037-site sample, or 0.3%, block every crawler outright. Meanwhile, 44% have a path-level Disallow rule in a wildc

Railway's pricing trips up developers who assume it works like Vercel or Netlify with a generous free tier and predictable monthly bills. It doesn't — it's usage-based, and the bill can climb fast once you move past hobby projects. Here's what you're actually paying for in 2026. How Railway pricing actually works Railway bills on three axes: compute (vCPU-hours), memory (GB-hours), and egress (GB). There's no seat-based pricing and no per-project fee. Every service you spin up — a Next.js app, a Postgres instance, a Redis container, a background worker — accumulates compute and memory cost independently. This is the first gotcha: a monorepo with three separate Railway services isn't one bill line, it's three. A typical Next.js + Postgres + Redis stack is billing on all three simultaneously, 24/7, even if traffic is zero. Railway free tier limits in 2026 The Hobby plan starts at $5/month (a recent change from the old credit system) and includes a $5 usage credit each month. If your services stay within that credit, you pay only the base $5. Exceed it and Railway charges the overage at standard rates. Resource Hobby included Rate above included vCPU ~8 vCPU-hours/mo (within $5 credit) $0.000463 / vCPU-second Memory ~32 GB-hours/mo (within $5 credit) $0.0000018 / GB-second Egress 100 GB/mo $0.10 / GB Postgres storage 1 GB (Hobby DB) $0.25 / GB / mo Execution timeout 10 min (one-off jobs) — Team members 1 (solo) — The credit math is easy to exhaust. A single 512 MB Node.js service running continuously costs roughly 512 MB × 3600 s × 24 h × 30 d × $0.0000018/GB-s ≈ $2.40/month in memory alone. Add a small Postgres instance and a Redis container and you've eaten the credit. The $5 base is essentially the minimum floor, not a ceiling. The free trial (no credit card) gives $5 one-time credit and then stops. That's roughly enough for a weekend of testing — not a production staging environment. Pro plan: what changes The Pro plan costs $20/month per workspace and removes the

Every messenger you use has a hidden dependency: a working network path to a datacenter. Drop into a basement, a packed stadium, a moving train through a tunnel, an exam hall with jammers, or a remote area with no plan, and the app is just a spinner. The people you want to reach are often standing a few meters away, but your message still has to travel to a server on another continent and back. When that path is gone, so is the app. Kabootar is my attempt to remove that dependency entirely. It is a messenger with no backend at all. Your phone forms a peer-to-peer mesh with other phones nearby, and messages hop device to device over Bluetooth and Wi-Fi until they reach the recipient. No internet, no servers, no SIM. It is built in Flutter, and the routing core is plain Dart. The core idea: delay-tolerant networking The insight that makes this work is refusing to assume the recipient is reachable right now . Normal networking is connection-oriented: open a path end to end, then send. If there is no path, there is no delivery. Kabootar instead treats the network as a delay-tolerant network (DTN). A message does not need a live end-to-end path at the moment you hit send. It needs a chain of carriers that will exist over time . You hand your message to whoever is nearby. They hold onto it, carry it as they walk around, and pass it along to the next phone they meet. Eventually a carrier bumps into the recipient and the message lands, even if that is minutes later and both you and the recipient have long since walked away. This is store-and-forward, the same shape as a durable, at-least-once message queue, except the queue is running across a swarm of phones instead of inside a datacenter. How a message actually travels The routing strategy is epidemic routing: flooding. When you send a message, it spreads to everyone in range like a rumor. Each device that receives it re-broadcasts it onward, so the message replicates through the crowd, taking every path at once. That red

Picture, you join a new team working on a big system. Everybody who knew anything has left, either to find greener grass or to enjoy a well deserved pension. You and the team struggle to build new features for the system or to adapt functionality to match changes in legislation. Not to mention the trouble it is to figure out what to fix when things go wrong. At the same time, the business that you support is screaming for innovation and pushing for more and more changes. Recognize this situation? Ever experienced it yourself? A world full of legacy systems “Legacy. What is a legacy? It’s planting seeds in a garden you never get to see.” – Lin-Manuel Miranda, “Hamilton” Legacy, the thing that you are remembered for, typically the word has a positive meaning… how come that in tech the word “Legacy” has such a bad connotation? When we call out a legacy system, we usually mean: code without tests ( Michael Feathers ) or code you “got” from somebody else, or code that you’re scared to touch. However, there is a reason these legacy systems are still around. In almost all cases, that system still brings in money or is somehow still valuable. If it did not bring any value anymore, wouldn’t it be decommissioned? There must be something in these systems that makes them survive, where other systems did not. How systems become “Legacy” So legacy systems are those that have become hard or scary to change. In my experience, that not because something is wrong with the code or technology. The major contributing factor is usually that the knowledge about the system has left the organization. And then I don’t mean the documentation, but the people that built, maintained and ran the system. When those people are gone, you know that nobody else is going to be happy touching that thing. The value of software Code is like a mapping of desired real world behavior to a program that can be executed by a machine. So where is the value of a system, is that in that code? Over the past years I

Our research team has been exploring an alternative approach to achieving interactivity and better responsiveness with LLM systems. One of the team members wrote up a post about it: https://research.yandex.com/blog/the-kv-cache-as-an-agent-runtime The post sums up the overall idea of modifying models inference state (KV-cache) for achieving a more interactive LLMs. This idea was used in our lab's previous papers Hogwild! Inference , and AsyncReasoning , the post also contains a preview of the future work in this direction, where a Qwen3.8-27B agent is playing a DOOM env interactively using similar techniques. We think that its interesting whether model inference/runtime design is itself an under-explored axis of agent capabilities, alongside models and the harness (e.g. harness is too abstract, changing model is too costly, do we need something in between?) submitted by /u/_puhsu [link] [留言]

Hello all, I'm a radar signal processing engineer and i trained a 5-class classifier (car, large_vehicle, two_wheeler, pedestrian, pedestrian_group) on RadarScenes radar point clouds. The input vector is a per-scan histogram (16 bins) and the network is a 3-layer MLP. The loss function is a class-weighted cross-entropy loss. This work is based on "Histogram-based Deep Learning for Automotive Radar" paper. I scoped the project to be one scan only. Accumulation of multiple scans is the next step. Data Class Imbalance: two-wheelers and large_vehicles has a low number of occurences. Aggregated Classes: two_wheeler mixes bicycles and motorized variants; large_vehicle merges trucks, buses, and trains together due to data scarcity. Sequence Bias: Long tracks of slow-moving objects can skew a particular data split velocity distribution, causing high F1 score variance across folds. Ablation studies I tried with bigger MLPs, alternative feature encodings, and different histogram binning, all moved performance less than the variation caused by changing the train/validation/test split. I measured that split sensitivity across 6 folds, keeping the same proportions. Changing the histogram to per-instance statistics (mean/median/std) slightly degraded performance. Main findings Macro F1 rises from 0.381 to 0.764 as the naturally occurring number of radar detections per instance increases from 1 to 5. I trained the model normally using all available detections, then bucketed its existing validation predictions by each instance's detection count and computed macro F1 per bucket. The classes car and pedestrian has the best performance and two_wheeler has the worst. A car is often confused as large vehicle when the car was wider than usual or had a unusually high rcs (which can happen due to multipath for example). The two_wheeler is often confused as pedestrian because their vr_compensated distributions overlap, which is the the model's single most important feature for these two cla

Is LfD and BC research being effected by recent advances in (so-called) Frontier LLMs? Or is research in LfD and BC sort of going along in an independent direction from these? Are you seeing any use from ViTs or VLAs? Any other recent advances you would like to bring up? submitted by /u/moschles [link] [留言]

One thing that has bothered me about LLM benchmarks for a while is that most of them are essentially snapshots. A model is evaluated, a score is published, and we tend to talk about that score as if it describes a relatively stable object. But with API-served models, the thing behind the model name can change over time: serving infrastructure changes, provider configurations change, versions change, and sometimes behaviour changes without an obvious public version transition. So we started approaching benchmarking as a longitudinal measurement problem rather than a leaderboard problem. We continuously evaluate models across coding, multi-turn reasoning and tool use, while also running lightweight probes at a higher frequency. The important part for us is not simply asking "which model scores highest?", but: Is the model behaving differently from its own previous baseline? Is the change larger than its normal repeated-call variability? Did the benchmark configuration itself change? Is the effect concentrated in a particular task? Is it correlated across models from the same provider? Is an apparent degradation actually an availability/infrastructure issue rather than a capability change? One historical analysis covered 31,352 repeated score observations across 49 models . The standard deviation of within-day scores was 2.80 points , while the standard deviation of between-day daily medians was 8.43 points . That is roughly a 3:1 difference. I don't think this result by itself establishes that providers are changing models day-to-day - there are too many possible confounders for that conclusion. Task composition, sampling, missingness, provider behaviour and methodology changes all matter. But it was enough to convince us that temporal variation deserves to be measured rather than treated as noise around a permanent leaderboard score. Our current approach therefore keeps benchmark configurations versioned and only compares longitudinal observations produced under comp