标签：#m

MacPaw is building a local version of its AI assistant Eney using Liquid AI's models.

Robinhood's latest financial instrument intends to let any retail investor feel like they, too, can make money by backing Y Combinator startups.

submitted by /u/mareek [link] [留言]

TL;DR MCP servers are powerful, but they can provide access to production systems if...

Disney is introducing fan-created TikTok content to its Disney Plus app in its latest attempt to break into short-form creator videos. The Walt Disney Company announced today that it's partnering with TikTok to bring "an expansive collection of thoughtfully curated Disney-centric fan-created content" to the Verts video feed it launched on Disney Plus earlier this […]

submitted by /u/TheSwedeheart [link] [留言]

A startup has created beagles without the gene that causes runny noses and watery eyes for allergy sufferers.

A new study shows how the big cats cause deer to move away from roads and deeper into the forest, where they pose less of a hazard to motorists.

WindBorne Systems has raised $37 million Series B round to scale its weather balloons and AI forecasts.

Mitti Labs plans to expand beyond India and enter the Philippines and Indonesia while growing its carbon credits and agricultural data business.

Laurence Tratt discusses yk, an open-source meta-tracing JIT compiler framework. He shares how to automatically speed up C-based language interpreters like Lua and MicroPython with minimal, non-invasive code changes. He explains the inner workings of tracing loops, optimizing compiled traces using developer hints, and managing complex deoptimization back to the interpreter. By Laurence Tratt

“Myst” sold over 6 million copies in the ’90s. Its latest sequel couldn’t shore up any funding, pointing to an existential crisis among double-A games.

submitted by /u/ZuleZI [link] [留言]

Mugshawtys and similar pages often frame mugshots as thirst traps. The women featured are humiliated and are sometimes harassed for months and years after their arrests.

Hi everyone, I'm an independent researcher sharing Monodratic, a sparse causal-attention architecture with learned product-hash routing. The idea is that after RoPE, source blocks are assigned to bounded causal posting lists, while each query probes product addresses, reranks the returned candidates, selects a fixed number of remote source blocks, adds guaranteed local blocks, and then runs exact causal softmax over just those tokens. I implemented it as a stateless [batch, sequence, width] -> attention-delta mixer, so normalization, residual updates, feed-forward layers, and inference scheduling are left to the host model. What I found is that -learned routing with 2 selected remote blocks out of 5 eligible: 763/768 correct associative-recall answers across three seeds (99.35% mean, 98.05% minimum). -an equally wide untrained router: 425/768. Local-only attention: 151/768. -forcing the labelled target block while keeping the same maximum R2 attention budget recovered all five remaining errors, reaching 768/768. -sparse selected-set attention agreed with an independent dense selected-mask oracle to a maximum absolute error of 1.43e-6. -the packed CPU routing implementation showed a fitted timing exponent of 0.993 from 4,096 to 32,768 tokens under the fixed, balanced configuration. -all reported learned-route and scaling runs recorded zero posting overflow. The limitations are that the experiments are synthetic, the implementation is portable PyTorch rather than a fused kernel, and the report does not claim natural-language quality, asymptotic linear construction, or deployment speed. Paper: https://github.com/Misul-Computing/Monodratic/blob/main/output/pdf/monodratic_proof.pdf Code and reproduction: https://github.com/Misul-Computing/Monodratic I would particularly appreciate technical feedback on the routing construction, the controls, and what the strongest next evaluation should be. submitted by /u/dttdrv [link] [留言]

People type 2+2 into Google. They type 9+10 . They type 7*8 when they can't remember whether it's 54 or 56. Each of those is a real, high-volume search query — and most of the results are identical calculator widgets. So when I built Wrongulator , a calculator that returns a confidently wrong answer on purpose, I had a question worth asking: what if every expression were its own page, ranking for the exact arithmetic people already search? That is programmatic SEO — generating a page per parameter instead of writing pages by hand. And doing it across 17 languages means programmatic SEO with hreflang, where each generated page also declares its 16 translated siblings. The trap is that most programmatic surfaces are thin, duplicative, and get buried by Google. This one isn't, for a specific reason: every page has a real, unique answer baked into the HTML before any JavaScript runs. This post is about how — and the honest costs nobody mentions. Why a Permalink Per Expression Is Even Possible A page per expression only works if /2+2 reproduces the same result for everyone, forever, with no database behind it. That property isn't free — it's the result of one design decision I cover in detail in why a viral toy must be wrong the same way every time : the wrong answer is a pure function of the expression, seeded by a stable hash, with no per-user state. The relevant consequence here is what that property unlocks for SEO. Because f("2+2") always returns the same wrong answer, the server can compute that answer on demand for any expression in the URL, with zero storage. There's no pages table, no CMS, no pre-generation job. A request for /64+5 runs the engine, gets 67 ("the only correct number"), and renders a complete page around it. The programmatic surface is, in effect, infinite — but it costs nothing to hold, because nothing is stored. The pure function is what makes thousands of unique pages possible without a database. That's the foundation. Everything below is about

Is the Future of Enterprise AI Local? For the past couple of years, the standard approach to AI has been pure brute force: take the biggest, most expensive cloud-hosted frontier model you can get hold of and throw it at every single problem. But this "one-size-fits-all" approach is not going to last forever. We are approaching a transition phase where the capabilities of local models will soon pass the threshold of "good enough," just as the growing costs of frontier models become impossible for businesses to ignore. Here is why I believe the pendulum is about to swing firmly toward local, controlled hardware. 1. The Looming API Cost vs. Value Reality Check Right now, companies are actively encouraging their staff to jump on the AI bandwagon. But this honeymoon phase will eventually hit a wall. In the near future, businesses are going to start heavily scrutinising the cost-versus-reward ratio of their AI deployments. Consider the typical enterprise token burn: If an engineer is burning through £10,000 worth of tokens each month on API calls, are they actually adding £10,000 worth of value? Or have they just established an expensive new habit to climb the internal AI usage leaderboard? When CFOs eventually demand budget cuts, teams relying entirely on cloud APIs are going to be forced to unlearn those expensive habits overnight, or find alternative options. Beyond raw cost, cloud providers will likely continue introducing workflow friction. We've already seen instances where providers shrink token allowances, enforce dynamic rate-limiting based on the time of day, or push traffic to lower-tier models during peak utilisation. Building your core workflows on a third-party API means you will never truly control the throttle. This is not even considering the data ownership issue, up until now the only powerful models were closed weight and there was not much choice in ownership, however now that open weight models are available that can offer similar performance and can

Samsung's latest memory and storage tech is mostly designed for data centers, not consoles or PCs.

Sites that start from a stock theme tend to look like it. This one did too — until recently it was the default PaperMod screen. The editorial homepage and unified article styling you're looking at came out of a single day of customization. This guide is that work written down, with the code. One principle drove all of it: never fork the theme. The theme stays a submodule and keeps receiving updates; you win with site-level files only. Hugo resolves same-path site files ahead of theme files, which makes this possible. The entire customization of this site is a handful of files: layouts/index.html ← full homepage replacement data/home/ko.yaml, en.yaml ← homepage copy (per language) assets/css/extended/home.css ← homepage styles assets/css/extended/custom.css ← unifying every other page The starting point is a Hugo site with PaperMod as a submodule, deployed to GitHub Pages. Basic installation is well covered by the PaperMod wiki , so I'll skip it. 1. Replace the homepage wholesale Create a single layouts/index.html and the homepage is yours. The theme's home template stays untouched. The key move: don't hardcode copy into the markup — pull it from data files. On a bilingual site, one template then serves both languages: {{- $copy := index .Site.Data.home .Site.Language.Lang -}} {{- $posts := first 4 (where .Site.RegularPages.ByDate.Reverse "Section" "blog") -}} <section class= "editorial-hero" > <p class= "editorial-eyebrow" > {{ $copy.hero.eyebrow }} </p> <h1> {{ range $i, $line := $copy.hero.titleLines }}{{ if $i }} <br> {{ end }}{{ $line }}{{ end }} </h1> <p class= "editorial-intro" > {{ $copy.hero.intro }} </p> </section> data/home/en.yaml holds nothing but words: hero : eyebrow : " IDEAS · PRODUCTS · OPPORTUNITIES" titleLines : - " Where ideas become products," - " and products become new opportunities." Copy edits stop requiring template changes, and adding a language is one more yaml file. Latest posts are pulled dynamically as above — handle the {{ else }} emp

A demo Andrej Karpathy posted over the weekend stuck with me. He gave Opus 5 a million-token context and the first paragraph of The Lord of the Rings, and asked for a procedural 3D rendering of the scene in Three.js. The model worked alone for about two hours, wrote 5,500 lines, and coordinated polygon placement, camera paths, and animation on its own. Total cost: about $10. The result is faster to watch than to describe. Most reactions read it as the next step past "draw a pelican SVG" benchmarks. Something else looked bigger to me. What changed isn't the model's artistry. It's the unit of delegation. The unit of delegation changed Until now, the work we handed agents came in prompt-sized pieces. One function, one bug, one file. Anything bigger, we decomposed ourselves. The reason was simple: with a small context, the early parts of a long job slide out of view, and coherence goes with them. A million tokens erases that premise. Everything the model wrote and tried across a two-hour session stays in view. When the desk is big enough, there is no reason to hand work over in slices. Delegation moves from the task to the session. That is the difference between a function call and a work session. The first, we decompose and supervise. The second, we hand over material and intent, and receive a result. Karpathy's entire contribution was picking the paragraph and watching the output two hours later. Where the builder's work moves When execution costs $10 and two hours, execution is no longer the bottleneck. Two things remain. On the way in: the brief. What goes into the context. Karpathy's input was one paragraph, but choosing it was the design act. Translated to our work, it becomes choosing which spec, brand guide, reference, or codebase goes in whole — and what stays out. On the way out: judgment. By what standard do you accept the result? Reviewing 5,500 lines one by one doesn't match session-sized delegation. Instead, you define "done" before the run, then judge the