voxleone

I’ve been working on something we call the Functional Universe (FU), a modeling framework and experimental codebase that treats systems as sequences of irreversible functional transitions, rather than objects evolving against a global clock.

It started as a computational experiment, but it’s been interesting how naturally it lines up with ideas from QM (aggregation vs collapse), relativity (proper time), and distributed systems (event-driven causality). Still very much a work in progress, but already useful as a way to think clearly about time, causality, and scheduling in real systems.

- Concept>> https://github.com/VoxleOne/FunctionalUniverse/blob/main/doc...

- Code >> https://github.com/VoxleOne/FunctionalUniverse/tree/dev

One thing I think the “LLM as new high-level language” framing misses is the role of structure and discipline. LLMs are great at filling in patterns, but they struggle with ambiguity, the exact thing we tolerate in human languages.

A practical way to get better results is to stop prompting with prose and start providing explicit models of what we want. In that sense, UML-like notations can act as a bridge between human intent and machine output. Instead of:

“Write a function to do X…”

we give:

“Here’s a class diagram + state machine; generate safe C/C++/Rust code that implements it.”

UML is already a formal, standardized DSL for software structure. LLMs have no trouble consuming textual forms (PlantUML, Mermaid, etc.) and generating disciplined code from them. The value isn’t diagrams for humans but constraining the model’s degrees of freedom.

I don't get the down voting. Yes, it lacks primitive ontology, exactly.

I’m involved in the development of the Functional Universe (FU) framework [0], and I see some interesting intersections with Wolfram’s ruliology.

Both start from the idea that simple rules / functions can generate complex structure. Where FU adds a twist is by making a sharp distinction between possibility and history. In FU, we separate aggregation (the space of all admissible transitions - superpositions, virtual processes, rule applications) from composition (the irreversible commitment of one transition that actually enters history).

You can think of ruliology as exploring the space of possible rule evolutions, while FU focuses on how one path gets selected and becomes real, advancing proper time and building causal structure. Rules generate possibilities; commitment creates facts.

So they’re not the same thing, but I think they’re complementary: ruliology studies the landscape of rules, FU studies the boundary where possibility turns into irreversible history.

[0]https://github.com/VoxleOne/FunctionalUniverse/blob/main/doc...

>Has anyone tried creating a language that would be good for LLMs?

I’ve thought about this and arrived at a rough sketch.

The first principle is that models like ChatGPT do not execute programs; they transform context. Because of that, a language designed specifically for LLMs would likely not be imperative (do X, then Y), state-mutating, or instruction-step driven. Instead, it would be declarative and context-transforming, with its primary operation being the propagation of semantic constraints. The core abstraction in such a language would be the context, not the variable. In conventional programming languages, variables hold values and functions map inputs to outputs. In a ChatGPT-native language, the context itself would be the primary object, continuously reshaped by constraints. The atomic unit would therefore be a semantic constraint, not a value or instruction.

An important consequence of this is that types would be semantic rather than numeric or structural. Instead of types like number, string, bool, you might have types such as explanation, argument, analogy, counterexample, formal_definition.

These types would constrain what kind of text may follow, rather than how data is stored or laid out in memory. In other words, the language would shape meaning and allowable continuations, not execution paths. An example:

@iterate: refine explanation until clarity ≥ expert_threshold

Wrong link the OP, sorry

https://en.wikipedia.org/wiki/Idiocracy

My bad, Sorry.

https://en.wikipedia.org/wiki/Idiocracy

Idiocracy

https://pt.wikipedia.org/wiki/Idiocracy

Helping, in Rogaway’s sense, means refusing both neutrality and despair. Collapse is not an excuse for nihilism; there are still objective ways to help, even if they’re costly and uncertain. That looks like rejecting work that accelerates surveillance, extraction, or environmental damage; pushing back inside institutions; redirecting skills toward public-interest, climate, or civic work; and engaging politically rather than hiding behind technical detachment.

The harder question Rogaway implicitly raises is not what should be done but how many of us actually have the disposition to accept the blood, toil, tears, and sweat required to fight, rather than retreating into comfort, irony, or resignation. Technical excellence is abundant; moral endurance is not.

By 1994, I was in triumphant optimism. I was young-ish, my country was in for its most beautiful decade ever, and the internet seemed to herald a time of final Liberation, with the Earth becoming home to a single, global scientist-philosopher society.

And so, suddenly, we find ourselves mired between traditionalist discomfort and pragmatic acceptance, an unglamorous terminus for earlier dreams of Human synthesis.

It’s worth acknowledging the real challenges raised in this thread: desktop Linux still has rough edges for some use cases, hardware support isn’t always perfect, and niche professional software may lack native support or require workarounds. But these obstacles are not intrinsic technical limitations so much as ecosystem and investment gaps, areas where community projects, standards efforts, and wider adoption could drive improvement without sacrificing freedom.

Viewed through the lens of digital autonomy and citizenship, the question isn’t simply “Is Linux perfect?” but rather: Do we want our fundamental computing environment to be ultimately under our control, or controlled by private interests with their own incentives?

Radical openness can slide into naïveté if it ignores power, incentives, and bad actors. “Be vulnerable and good things will happen” is only true in constrained contexts, where norms, reciprocity, and consequences exist. Outside those, vulnerability can absolutely be exploited.

Ina perfect world openness is not surrender; humility is not passivity; trust is not indiscriminate access.

The forester-notes.org page is not a traditional blog or essay. It’s a hypertext note node.

Container ships are the fastest!

I sometimes feel a peculiar resonance with these models: they catch the faintest hints of irony and return astoundingly witty remarks, almost as if they were another version of myself. Yet all of the problems, inconsistencies, and surprises that arise in human thought stem from something profoundly differen, which is our embodied experience of the world. Humans integrate sensory feedback, form goals, navigate uncertainty, and make countless micro-decisions in real time, all while reasoning causally and contextually. Cognition is active, multimodal, and adaptive; it is not merely a reflection of prior experience a continual construction of understanding.

And then there are some brilliant friends of mine, people with whom a conversation can unfold for days, rewarding me with the same rapid, incisive exchange we now associate with language models. There is, clearly, an intellectual and environmental element to it.

The inevitable AI angle: researchers are increasingly exploring perception, self-modeling, and grounded interaction as the foundation for the next wave of AI systems, ones that behave in ways more aligned with human-like awareness than LLMs alone can provide (see work like MUSE or situational awareness in vision-language reasoning).

Systems like the electronic nose described here highlight what many think is missing in current AI approaches: continuous physical sensing combined with explicit novelty detection and decision boundaries that let a system say “this is real”, “this is happening now”, or “this is outside what I know”. Human-like behavior is unlikely to emerge from language models in isolation; it appears to come from closed perception-reasoning loops that are causally coupled to the environment. Without sensory grounding, AI tends to optimize for plausibility rather than correctness, and scaling or prompting alone doesn’t seem to address that gap.

Regarding the “supersonic is now viable because LNG” argument, but for a different reason than usual.

Even if supersonic flight becomes cheaper via new fuels or propulsion, that doesn’t reset the baseline. The same advances (materials, engines, fuel handling, manufacturing) will also apply to subsonic aircraft, where the physics are already far more energy-efficient. So if supersonic gets “cheap,” traditional jets will get much cheaper. Airlines will always arbitrage toward the lowest energy-per-seat-km for most routes, and supersonic flight is structurally disadvantaged there (drag, noise, routing constraints).

Historically, faster transport doesn’t replace slower transport wholesale; it creates a premium tier while pushing the mass market down to a lower cost/energy equilibrium. Concorde didn’t kill widebodies, widebodies got cheaper. My intuition: supersonic may of course exist as a niche (time-sensitive, premium), but its biggest impact would be indirect, accelerating efficiency gains that make conventional aviation even more dominant and cheaper.

Thing was stupid from start. I'm appalled that it's come thus far

I think a lot of businesses don’t actually need cloud AI at all. Once workloads stabilize, cloud is mostly a convenience tax. Most business use cases (docs, forecasting, monitoring, support, control systems) don’t need frontier models or hyperscale elasticity. Efficient models running locally are already “good enough”. Continuous inference + data gravity + latency/privacy constraints make owned edge hardware economically and operationally sensible again.

It offers testable predictions, which is rare in quantum gravity models.

Argentine newspaper Clarín reports some resistance.

https://www.clarin.com/mundo/respuesta-nicolas-maduro-explos...

Welcome to the Linux desktop club. One small heads-up from experience: if you’re running NVIDIA hardware, expect a few bumps along the way. The proprietary drivers work well once set up, but kernel updates, Wayland quirks, and driver installs can be more hands-on than with AMD or Intel. Not a dealbreaker, just something to be aware of.

Overall though, solid choice. Hope 2026 really is your year of the Linux desktop.

If only form factors like these could run general use/free OS's...

this is great>>@FTX_crisis - (@guilt_tone - @guilt_topic)

Using LLm for tasks that could be done faster with traditional algorithmic approaches seems wasteful, but this is one of the few legitimate cases where embeddings are doing something classical IR literally cannot. You could also make make the LLM explain the query it’s about to run. Before execution:

“Here’s the SQL and semantic filters I’m about to apply. Does this match your intent?”

It does read like a subtle parody or ironic commentary. It’s the style of someone poking fun at common narratives about polarization by showing how absurdly “offline radicalization” might look.

If i had to give advice to young programmers, it would be this: be comfortable with set theory and notation. It’s interesting that once you collect use cases, sketch the objects, and express everything in a set-theoretical fashion, the programs almost write themselves. You can even feed this set-theoretic notation directly to an LLM and get code in return. It’s a perfectly honest way to incorporate LLMs into your workflow.

No judgement here whatsoever, but i think LLM would be "the" tool for this job. I also wonder if there's any point to "Ask" sections in websites after LLM's.

Just a minor aside: When exporting geometry for FEM, you generally should not make $fn very high (values around 32–64 are usually fine). High $fn improves visual smoothness, but it often hurts FEM meshing and solver performance without improving accuracy, since FEM accuracy is governed by the solver’s mesh rather than the CAD tessellation.

I'd put it this way: CAD = Computer-Aided Design, i.e., software that assists in the creation, modification, analysis, or optimization of a design.

OpenSCAD clearly qualifies because it creates precise 2D/3D models; supports parametric modification; enables reproducible designs; produces manufacturable geometry (STL, DXF, etc.). The fact that it is code-based does not disqualify it. By the same logic, CadQuery, SolidPython, or FeatureScript would also not be CAD - which is not a position held in engineering practice.

The Himalayas formed because the Indian craton moved exceptionally fast northward (all the way from Antarctica) and collided with Eurasia, one of the fastest sustained plate motions known in geological history.

The collision with Asia began around 50–55 Ma and is still ongoing, which is why the Himalayas are still rising today.