2026-01-25 03:00:19
Some recent trends in theoretical ML
2.1 Deep Learning via continuous-time controlled dynamical system
2.2 Probabilistic modeling and inference in DL
3.1 Kuramoto models from the geometric point of view
3.2 Hyperbolic geometry of Kuramoto ensembles
3.3 Kuramoto models with several globally coupled sub-ensembles
Kuramoto models on higher-dimensional manifolds
4.1 Non-Abelian Kuramoto models on Lie groups
4.2 Kuramoto models on spheres
4.3 Kuramoto models on spheres with several globally coupled sub-ensembles
5.1 Statistical models over circles and tori
5.2 Statistical models over spheres
5.3 Statistical models over hyperbolic spaces
5.4 Statistical models over orthogonal groups, Grassmannians, homogeneous spaces
6.1 Training swarms on manifolds for supervised ML
6.2 Swarms on manifolds and directional statistics in RL
6.3 Swarms on manifolds and directional statistics for unsupervised ML
6.4 Statistical models for the latent space
6.5 Kuramoto models for learning (coupled) actions of Lie groups
6.6 Grassmannian shallow and deep learning
6.7 Ensembles of coupled oscillators in ML: Beyond Kuramoto models
Examples
7.2 Linked robot’s arm (planar rotations)
7.3 Linked robot’s arm (spatial rotations)
7.4 Embedding multilayer complex networks (Learning coupled actions of Lorentz groups)
In 1994. Watanabe and Strogatz [69] demonstrated that the simple Kuramoto ensemble with globally coupled identical oscillators exhibits 3-dimensional dynamics. They have shown that dynamics of a large ensemble can be reduced to the system of ODE’s for three global variables. This implies that an ensemble consisting of N oscillators admits N − 3 constants of motion. This result initiated the new research direction which deals with symmetries and invariant submanifolds in simple Kuramoto networks.
\ The underlying symmetries have been exposed in 2009. by Marvel, Mirrolo and Strogatz [70].
\
\ Proposition 1. [70]
\
\ Further insights into the relation between hyperbolic geometry and Kuramoto models have been reported in [71]. It has been demonstrated that (under certain conditions on the coupling function f) Kuramoto dynamics of the form (6) are gradient flows in the unit disc with respect to hyperbolic metric. Potential function for dynamics (7) has particularly transparent geometric interpretation. It turns out that dynamics of Kuramoto ensembles with repulsive interactions uncover a point inside the unit disc that has the minimal sum of hyperbolic distances to the initial points on S1. In complex analysis this point is conformal barycenter [72] of the initial configuration.
\
:::info Author:
(1) Vladimir Jacimovic, Faculty of Natural Sciences and Mathematics, University of Montenegro Cetinjski put bb., 81000 Podgorica Montenegro ([email protected]).
:::
:::info This paper is available on arxiv under CC by 4.0 Deed (Attribution 4.0 International) license.
:::
\
2026-01-25 03:00:12
Today the Go team is pleased to release Go 1.25. You can find its binary archives and installers on the download page.
\
Go 1.25 comes with improvements over Go 1.24 across its tools, the runtime, compiler, linker, and the standard library, including the addition of one new package. There are port-specific changes and GODEBUG settings updates.
\
Some of the additions in Go 1.25 are in an experimental stage and become exposed only when you explicitly opt in. Notably, a new experimental garbage collector, and a new experimental encoding/json/v2 package are available for you to try ahead of time and provide your feedback. It really helps if you’re able to do that!
\ Please refer to the Go 1.25 Release Notes for the complete list of additions, changes and improvements in Go 1.25.
\ Over the next few weeks, follow-up blog posts will cover some of the topics relevant to Go 1.25 in more detail. Check back in later to read those posts.
\ Thanks to everyone who contributed to this release by writing code, filing bugs, trying out experimental additions, sharing feedback, and testing the release candidates. Your efforts helped make Go 1.25 as stable as possible. As always, if you notice any problems, please file an issue.
\ We hope you enjoy using the new release!
Dmitri Shuralyov, on behalf of the Go team
\ This article is available on The Go Blog under a CC BY 4.0 DEED license.
\ Photo by Francesco Gallarotti on Unsplash
2026-01-25 02:00:03
How a JSON or JSON-like language enables the next generation of safe human and AI-generated UIs
In The Future of AI-Generated UI, I pointed out that the raw JavaScript generated by AI-generated code is a security problem, and the flexibility of JavaScript without a framework can result in hard-to-manage code. I argued that we need declarative, sandboxed formats like A2UI or a Computational DOM (cDOM) with JSON Pointer Regular Expressions (JPRX if), if we want to trust an LLM to build our interfaces.
\ It also helps if the approach is based on industry standards for which there is lots of documentation and examples that have probably been consumed by LLMs during training. cCOM and JPRX do this; they incorporate concepts and syntax from JSON Pointers, JSON Schema, and XPath.
\ In my previous article, to show how a cDOM and JPRX work, I used a reactive counter, but let's be real: reactive counters and to-do lists are easy. Any framework looks elegant when the logic fits on a napkin. To prove a JSON-based approach actually holds up, you need a problem with messy state, edge cases, and distinct modes of operation. You need a calculator.
\ Calculators are inherently tricky:
\
So, I asked Claude Opus to build a fully functional, iOS-style calculator using zero custom JavaScript functions - just declarative cDOM and JPRX expressions. The fact that AI could produce a declarative calculator with little prompting purely from documentation demonstrates another point I made in my earlier article: cDOM and JPRX aren't just new syntax. They can be a protocol for human-machine collaboration. \n
\n The CodeTo reduce characters and quotation noise while allowing inline explanation, I am using cDOMC, a compressed version of a cDOM. A regular cDOM does not support comments and requires quotes around attributes and JPRX expressions. When represented with quotes and without comments, cDOM can be treated as regular JSON.
\
{
div: {
class: "calculator",
// A calculator feels stateless, but it's actually a strict state machine.
// You're never just "typing a number"; you're either entering the first operand,
// waiting for an operator, or entering the next operand.
onmount: =state({
display: "0", // What you see on the screen
expr: "", // History string, (e.g. "8 + 5 =")
prev: "", // value stored before an operation
op: "", // the active operator
waiting: false // true when expecting a new number vs operator
},{
name: "c", // the root name of our state, so we can express things like: /c/display
schema: "polymorphic", // allow type changes, e.g. "0" or 0
scope: $this // scope the path to the current element
}),
children: [
// Display area
{
div: {
class: "display",
children: [
{ div: { class: "expression",children[=/c/expr] }},
{ div: { class: "result",children[=/c/display] }}
]
}
},
// Button grid
{
div: {
class: "buttons",
children: [
// Row 1: AC, ±, %, ÷
{
button: {
class: "btn btn-clear",
onclick: =/c = { display: "0", expr: "", prev: "", op: "", waiting: false },
children: ["AC"]
}
},
{
button: {
class: "btn btn-function",
onclick: =/c = { display: negate(/c/display), waiting: true, expr: "" },
children: ["±"]
}
},
{
button: {
class: "btn btn-function",
onclick: =/c = { display: toPercent(/c/display), waiting: true, expr: "" },
children: ["%"]
}
},
// Divison is our first operator. This is where it gets tricky.
// When you click `+`, you can't just link `prev` to `display`.
// If you did, `prev` would update every time you selected a new digit for the**second**number,
// breaking the math. We need a snapshot of the value at that exact moment.
// Excel solves this with INDIRECT, effectively dereferencing a cell. JPRX borrows the same concept:
{
button: {
class: "btn btn-operator",
onclick: =/c = {
prev: indirect(/c/display), // Capture the value right now
expr: concat(/c/display, " ÷"),
op: "/", waiting: true
},
children: ["÷"]
}
},
// Row 2: 7, 8, 9, ×
// I have 10 number buttons. Do I write 10 handlers? Do I write a loop? In React or Vue,
// you'd probably map over an array. With JPRX, the DOM is the data key and although map is available,
// I represent the calculator using literals in this example. In a future article I will cover map.
// By giving each button an `id` (e.g., `id: "7"`), we write a uniform logic expression that adapts
// to whichever element triggered it. We just reference $this.id in JPRX and use an xpath to get the text
// content for the child node, #../@id. In cDOM (not JPRX) '#' delimits the start of an xpath expression
{
button: {
id: "7",
class: "btn btn-number",
onclick: =/c = {
display: if(/c/waiting, $this.id, if(/c/display==0, $this.id, concat(/c/display, $this.id))), waiting: false
},
children: [#../@id] // use xpath (starting char #) to get the text for the button from parent id
}
},
// Here's what is happening:
// Waiting for input? (e.g., just hit `+`) → Replace the display with the button's ID.
// Displaying "0"? → Replace it (avoids "07").
// Otherwise: → Append the button's ID.
// This is replicated identically for every number button. No loops, no external helper functions.
{
button: {
id: "8",
class: "btn btn-number",
onclick: =/c = {
display: if(/c/waiting, $this.id, if(/c/display==0), $this.id, concat(/c/display, $this.id))), waiting: false
},
children: [#../@id]
}
},
{
button: {
id: "9",
class: "btn btn-number",
onclick: =/c = {
display: if(/c/waiting, $this.id, if(/c/display==0, $this.id, concat(/c/display, $this.id))), waiting: false
},
children: [#../@id]
}
},
{
button: {
class: "btn btn-operator",
onclick: =/c = {
prev: indirect(/c/display), expr: concat(/c/display, " ×"), op: "*", waiting: true
},
children: ["×"]
}
},
// Row 3: 4, 5, 6, −
{
button: {
id: "4",
class: "btn btn-number",
onclick: =/c = {
display: if(/c/waiting, $this.id, if(/c/display==0, $this.id, concat(/c/display, $this.id))), waiting: false
},
children: [#../@id]
}
},
{
button: {
id: "5",
class: "btn btn-number",
onclick: =/c = {
display: if(/c/waiting, $this.id, if(/c/display==0, $this.id, concat(/c/display, $this.id))), waiting: false
},
children: [#../@id]
}
},
{
button: {
id: "6",
class: "btn btn-number",
onclick: =/c = {
display: if(/c/waiting, $this.id, if(/c/display==0, $this.id, concat(/c/display, $this.id))), waiting: false
},
children: [#../@id]
}
},
{
button: {
class: "btn btn-operator",
onclick: =/c = {
prev: indirect(/c/display), expr: concat(/c/display, " −"), op: "-", waiting: true
},
children: ["−"]
}
},
// Row 4: 1, 2, 3, +, use set and eq just to demonstrate equivalence with = and ==
// the buttons below use 'set' in place of the infix operator '=', just to show a different way of doing things
{
button: {
id: "1",
class: "btn btn-number",
onclick: =set(/c, {
display: if(/c/waiting, $this.id,
if(eq(/c/display, "0"), $this.id, concat(/c/display, $this.id))),
waiting: false
}),
children: [#../@id]
}
},
{
button: {
id: "2",
class: "btn btn-number",
onclick: =set(/c, {
display: if(/c/waiting, $this.id,
if(eq(/c/display, "0"), $this.id, concat(/c/display, $this.id))),
waiting: false
}),
children: [#../@id]
}
},
{
button: {
id: "3",
class: "btn btn-number",
onclick: =set(/c, {
display: if(/c/waiting, $this.id,
if(eq(/c/display, "0"), $this.id, concat(/c/display, $this.id))),
waiting: false
}),
children: [#../@id]
}
},
{
button: {
class: "btn btn-operator",
onclick: =set(/c, {
prev: indirect(/c/display),
expr: concat(/c/display, " +"),
op: "+", waiting: true }),
children: ["+"]
}
},
// Row 5: 0, ., =
{
button: {
id: "0",
class: "btn btn-number btn-wide",
onclick: =set(/c, {
display: if(/c/waiting, $this.id,
if(eq(/c/display, "0"), "0", concat(/c/display, $this.id))),
waiting: false }),
children: [#../@id]
}
},
{
button:
{
class: "btn btn-number",
onclick: =set(/c, {
display: if(/c/waiting, "0.",
if(contains(/c/display, "."), /c/display, concat(/c/display, "."))),
waiting: false }),
children: ["."]
}
},
// Finally, the math. We need to say:
// 1. Take the snapshot we stored
// 2. Apply the current operator
// 3. combine it with what's on screen now
// This is the job of calc(). If prev == 8 and op == * and display = 5, then calc would be evaluated as calc("8 * 5")
// To keep the syntax a little cleaner we also use $(<path>) as a shorthand for indirect.
{
button:
{
class: "btn btn-equals",
onclick: =set(/c, {
display: if(eq(/c/op, ""), /c/display, calc(concat("$('/c/prev') ", /c/op, " $('/c/display')"))),
expr: concat(/c/expr, " ", /c/display, " ="),
prev: "", op: "",
waiting: true }),
children: ["="]
}
}
]
}
},
// Branding
{
div: {
class: "branding",
children: [
{
span: {
children: [
"Built with ",
{
a: {
href: "https://github.com/anywhichway/lightview", target: "_blank",
children: ["Lightview"]
}
},
" cDOM • No custom JS!"
]
}
}
]
}
}
]
}
}
\
Lightview supports hypermedia capability similar to HTMX by allowing the use of the src attribute on almost any element.
\
Simply reference a cDOM file using src:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta name="description"
content="A beautiful calculator built with Lightview cDOM and JPRX reactive expressions - no custom JavaScript!">
<title>Calculator | Lightview cDOM</title>
<link rel="stylesheet" href="calculator.css">
<!-- Load Lightview scripts -->
<script src="/lightview.js"></script> <!-- DOM as JSON and reactivity support -->
<script src="/lightview-x.js"></script> <!-- hypermedia support -->
<script src="/lightview-cdom.js"></script> <-- cDOM/JPRX support -->
</head>
<body>
<!-- The calculator cDOM is loaded via Lightview's hypermedia src attribute -->
<div id="app" src="./calculator.cdomc"></div>
</body>
</html>
\
The src attribute works like an HTML <img> or <script> tag - Lightview automatically fetches the .cdomc file, parses it, and renders the reactive content into the target element. This approach:
You might look at concat("$('/c/prev') ...") and ask: Why in the world wouldn't you just write parseFloat(prev) + parseFloat(curr)?
\ If you are a human writing code for yourself? You probably would. Lightview supports standard JS handlers for exactly that reason.
\ But if you are building infrastructure for AI Agents, the calculus changes. Sticking to a declarative, JSON-based path offers things raw code can't:
\
Sandboxing: It executes in a controlled environment. The logic can't access `window`, make global fetch requests, or execute arbitrary secondary code. This makes it safe to "hot swap" UI logic generated by an LLM in real-time.
Portability: This entire UI—logic and all—is just data. It can be sent from a server, stored in a database, or streamed from an AI model.
Mental Model: It forces a clear separation between state transformations and view structure, which is exactly how LLMs reason best.
\n This calculator proves that "declarative" doesn't have to mean "dumb." With the right primitives - state, conditionals, and path-based referencing—you can build rich, complex interactions without ever leaving the data structure.
This series isn't just about a new library. It's about finding the right abstraction layer for the AI age.
\ In The Future of AI-Generated UI, we looked at the risks of letting LLMs write raw scripts and introduced the "Data as UI" philosophy.
\n In this article, we showed that "Data as UI" doesn't mean "dumb UI." We handled state, context, data snapshots, math, and DOM navigation with ‘xpath’ without executing a single line of custom JavaScript.
\n cDOM defines structure. JPRX defines behavior. It’s reactivity without the compilation and UI without the security risks.
The complete calculator is available at:
\
2026-01-25 01:30:04
The Rust team has published a new point release of Rust, 1.77.2. Rust is a programming language that is empowering everyone to build reliable and efficient software.
\ If you have a previous version of Rust installed via rustup, getting Rust 1.77.2 is as easy as:
rustup update stable
\
If you don't have it already, you can get rustup from the appropriate page on our website.
This release includes a fix for CVE-2024-24576.
\
Before this release, the Rust standard library did not properly escape arguments when invoking batch files (with the bat and cmd extensions) on Windows using the Command API. An attacker able to control the arguments passed to the spawned process could execute arbitrary shell commands by bypassing the escaping.
\ This vulnerability is CRITICAL if you are invoking batch files on Windows with untrusted arguments. No other platform or use is affected.
\ You can learn more about the vulnerability in the dedicated advisory.
Many people came together to create Rust 1.77.2. We couldn't have done it without all of you. Thanks!
The Rust Security Response WG
\ Also published here
\ Photo by holigil 27 on Unsplash
\
2026-01-25 00:02:00
How are you, hacker?
🪐 What’s happening in tech today, January 24, 2026?
The HackerNoon Newsletter brings the HackerNoon homepage straight to your inbox. On this day, Gold was discovered at Sutter's Mill in 1848, NASA's Voyager 2 spacecraft flew closely past distant Uranus in 1986, The Gonski Review was signed to reform education in Australia in 2012, and we present you with these top quality stories. From How You Can Test Your Kids Smart Toys For Privacy to HSM: The Original Tiering Engine Behind Mainframes, Cloud, and S3, let’s dive right in.
By @TheMarkup [ 10 Min read ] Are those toys secure? And precisely what data is being handed over when a kid is using these toys? Read More.
By @hennygewichers [ 5 Min read ] As AI makes authoritative text cheap, verification becomes the bottleneck. A police report failure shows why institutions are adding friction. Read More.
By @carlwatts [ 31 Min read ] From mainframe DFSMShsm to cloud storage classes: a practical history of HSM, ILM, tiering, recall, and the products that shaped modern archives. Read More.
By @dmitriy-tsarev [ 9 Min read ] A fine-tuned 3B model beat our 70B baseline. Heres why data quality and architecture innovations are ending the bigger is better era in AI. Read More.
🧑💻 What happened in your world this week?
It's been said that writing can help consolidate technical knowledge, establish credibility, and contribute to emerging community standards. Feeling stuck? We got you covered ⬇️⬇️⬇️
ANSWER THESE GREATEST INTERVIEW QUESTIONS OF ALL TIME
We hope you enjoy this worth of free reading material. Feel free to forward this email to a nerdy friend who'll love you for it.See you on Planet Internet! With love, The HackerNoon Team ✌️
2026-01-25 00:00:25
It’s barely been a month since the 4.3 release, but we had so many goodies queued up in the PR backlog that it’s been an early Christmas (or other gift-heavy holiday season) for contributors and testers.
\ We merged more than 200 PRs for the first dev snapshot, and just two weeks later, here we are with another batch of 350+ improvements for you to test and provide feedback on!
\ Many of the changes in this release are bug fixes that will be backported to Godot 4.3 and released in 4.3.1! So please test this release well so we can be confident with the changes and release 4.3.1 with them as soon as possible.
\ Keep in mind that while we try to make sure each dev snapshot is stable enough for general testing, this is by definition a pre-release piece of software. Be sure to make frequent backups, or use a version control system such as Git, to preserve your projects in case of corruption or data loss.
\ Jump to the Downloads section, and give it a spin right now, or continue reading to learn more about improvements in this release. You can also try the Web editor or the Android editor for this release. If you are interested in the latter, please request to join our testing group to get access to pre-release builds.
The original cover illustration is from Megaloot, an addictive inventory management roguelike, developed in Godot 4.3 by axilirate and published by Ravenage Games. It was recently released on Steam with big success. You can follow the development on Twitter.
In case you missed it, check the 4.4 dev 1 release notes for an overview of some key features which were already in that snapshot, and are therefore still available for testing in dev 2.
\ This new snapshot adds a lot more features which had been queued during the stabilization phase for Godot 4.3, and were thus ready for merging early on in the 4.4 development cycle.
\ Introducing…
Godot 4.0 introduced supported for typed arrays, but lacked support for typed dictionaries. This rapidly became one of the most requested features to add to the engine, and thanks to Thaddeus Crews, it is now implemented for Godot 4.4! This feature impacts the core engine, GDScript, and all other scripting languages when interfacing with Godot’s Dictionary type. You can now export typed dictionaries from scripts and benefit from a much improved Inspector UX to assign the right keys and values.
@export var typed_key_value: Dictionary[int, String] = { 1: "first value", 2: "second value", 3: "etc" }
@export var typed_key: Dictionary[int, Variant] = { 0: "any value", 10: 3.14, 100: null }
@export var typed_value: Dictionary[Variant, int] = { "any value": 0, 123: 456, null: -1 }
As a related improvement, support for StringName dictionary keys has also been optimized by Rune (GH-70096).
It is commonplace for Godot users using version control systems to exclude the .godot folder from their repositories, as it contains files which can be re-created by Godot the first time you edit the project.
\
One drawback of this system is that this first launch of the editor without .godot folder is typically quite noisy, with hundreds of errors spammed about missing resources, and various scripts failing to compile due to class_names not being known yet, addons not being registered yet, or yet unknown GDExtension classes.
\
Hilderin valiantly fought their way through this labyrinth of dependencies and multi-threading pitfalls, and brought us back the long awaited grail: error-less first import of projects, which should work without requiring an editor restart! This took a lot of effort with GH-92303 (for GDScript class_names, included in 4.3) and now GH-93972 (for GDExtensions) and GH-92667 (for plugins).
\
Moreover, with this newfound knowledge over the depths of EditorFileSystem, Hilderin also further improved that first project import experience to make the FileSystem dock more responsive while resources are being scanned (GH-93064).
Another long-awaited quality of life improvement was implemented by Samuele Panzeri in GH-76085, adding support for keeping track of the editor window’s state (fullscreen/windowed mode, screen, size, position) to restore it across sessions. This should be particularly welcome for users with big monitors or multi-monitor setups who want a different default behavior than fullscreen on the first screen.
A few popular quality of life improvements have been implemented by Yuri Rubinsky for the visual shader editor:
New material preview side dock (GH-94215).
Drag & drop of Mesh to create MeshEmitter in visual shaders (GH-93017).
Thanks to Godot’s unique feature of having an editor made with the engine itself, we’ve been able to bring the Godot editor to unconventional places, such as the web and Android devices. Building upon the latter, Fredia Huya-Kouadio completed the proof of concept started by Bastiaan Olij years ago, to add support for using the Android editor in an XR context using OpenXR (GH-96624)! You can test the current version by sideloading the APK, currently supported on Meta Quest 3 or Quest Pro.
There are too many exciting changes to list them all here, but here’s a curated selection:
SpriteFramesEditor to “guess” the amount of rows and columns of a sprite sheet when loading it for the first time (GH-95475).CSGShape3D debug collision shapes being visible in editor (GH-86699).WorkerThreadPool and ResourceLoader (GH-94169).GDExtensionLoader concept (GH-91166).Tree performance (GH-94748).StyleBoxFlat rectangles skewing independently (GH-96285).node->meta and back (GH-86183).AStarGrid2D performance when jumping is enabled (GH-93319).client_unsafe (GH-96172).OS.execute_with_pipe (GH-94434).JavaClassWrapper so it actually works (GH-96182).139 contributors submitted 376 improvements for this new snapshot. See our interactive changelog for the complete list of changes since the previous 4.4-dev1 snapshot.
This release is built from commit 97ef3c837.
Standard build includes support for GDScript and GDExtension.
.NET build (marked as mono) includes support for C#, as well as GDScript and GDExtension.
\ While engine maintainers try their best to ensure that each preview snapshot and release candidate is stable, this is by definition a pre-release piece of software. Be sure to make frequent backups, or use a version control system such as Git, to preserve your projects in case of corruption or data loss.
[] operator (GH-96772). A fix is already in the pipeline for the next dev snapshot.\ With every release we accept that there are going to be various issues, which have already been reported but haven’t been fixed yet. See the GitHub issue tracker for a complete list of known bugs.
As a tester, we encourage you to open bug reports if you experience issues with this release. Please check the existing issues on GitHub first, using the search function with relevant keywords, to ensure that the bug you experience is not already known.
\ In particular, any change that would cause a regression in your projects is very important to report (e.g. if something that worked fine in previous 4.x releases, but no longer works in this snapshot).
Godot is a non-profit, open source game engine developed by hundreds of contributors on their free time, as well as a handful of part or full-time developers hired thanks to generous donations from the Godot community. A big thank you to everyone who has contributed their time or their financial support to the project!
\ If you’d like to support the project financially and help us secure our future hires, you can do so using the Godot Development Fund platform managed by Godot Foundation. There are also several alternative ways to donate which you may find more suitable.
Rémi Verschelde
\ Also published here
\ Photo by Pisit Heng on Unsplash
\
