voxleone

Quaternion graph traversal and control system

https://github.com/VoxleOne/SpinStep

There's a customary way to post it here. "Show HN":

https://news.ycombinator.com/show

It’s almost suspiciously elegant: focus on transformations and their composition, and the structure takes care of itself.

We're heading to a future where (when) friction is a luxury. Anyways, I thank the organizers for the rare opportunity. Long live Blogosphere.app, long live blogs.

We went from NASA Jet Propulsion Laboratory’s Power of Ten rules to ‘have you tried restarting Microsoft Outlook?’

https://en.wikipedia.org/wiki/The_Power_of_10:_Rules_for_Dev...

This. My personal style have always been llm-like, including the generous use of em-dashes, and "not-only-this-that" style mannerisms. It' increasingly difficult to retain reputation.

That’s a very good objection, and it’s pointing at a real pressure point in our framework.

Short answer: it’s close, but incomplete. It’s not that time organizes a log of reality; rather, reality is the accumulation of committed transitions. What you’re calling a ‘log’ it’s the ontological structure itself.

I gather you're basically saying: what we see as a transition ≠ what’s actually happening at the fundamental level. This is a legitimate and deep problem.

You’re right that observed transitions may not compose cleanly. In the Functional Universe, composition is a property of fundamental transitions. What we observe are often coarse-grained projections of many underlying transitions, which can obscure compositional structure.

Neural cellular automata are interesting because they shift learning from “predict tokens” to “model state evolution.” That feels much closer to a transition-based view of systems, where structure emerges from repeated local updates (transitions) rather than being encoded explicitly.

I'm working on a theoretical/computational framework, the Functional Universe, intended for modeling physical reality as functional state evolution. i would say it could be used to replicate your CA process. Won't link it here to signal my good faith discussing this issue - it's on my GH.

>> An LLM can't even learn mid-conversation.

There’s an implicit assumption that scaling text models alone gets us to human-like intelligence, but that seems unlikely without grounding in multiple sensory domains and a unified world model.

What’s interesting is that if we do go down that route successfully, we may get systems with something like internal experience or agency. At that point, the ethical frame changes quite a bit.

If the comment missed the mark, I’d genuinely like to know where. I was trying to connect the “active archive” idea to history-dependent bias in collapse. Dismissing without engaging doesn’t really move the discussion forward.

This is a very interesting direction. The idea that dark matter could be a record of past decoherence events that then feeds back into future structure formation reminds me of a more general principle: history-dependent dynamics. In your “active archive” picture, the gravitational field is encoding where previous quantum selections occurred, and then biasing where future ones are likely to happen. That effectively introduces a kind of “inertia in configuration space,” where past realizations constrain future possibilities without fully determining them.

What I find particularly compelling is that this connects to a broader class of ideas where gravity (or dark matter) behaves like an information/entropy-related phenomenon rather than a particle sector, similar in spirit to approaches like emergent gravity.

>>Where does engineering go?

Up the abstraction ladder; we conceive axioms and constraints; we define actors and objects; we direct rules, flows, sequences and say when and how each one of them lives and dies.

May you live interesting times (some say this is a curse)

There are great mid-sized towns along the the route, especially in Parana and Sao Paulo. I'd have liked to read about any impressions.

I've been coding since I was about 15 and still love it. These days I mostly build tailored applications for small and medium companies, often alone and sometimes with small ad-hoc teams. I also do the sales myself, in person. For me, not using LLMs would mean giving up a lot of productivity. But the way I use them is very structured. Work on an application starts with requirements appraisal: identifying actors, defining use cases, and understanding the business constraints. Then I design the objects and flows. When possible, I formalize the system with fairly strict axioms and constraints.

Only after that do LLMs come in, mostly to help with the mechanical parts of implementation. In my experience it's still humans all the way down. The thinking, modeling, and responsibility for the system are human. The LLM just helps move the implementation faster.

I also suspect the segment I work in will be among the last affected by LLM-driven job displacement. My clients are small to medium companies that need tailored internal systems. They're not going to suddenly start vibe-coding their own software. What they actually need is someone to understand the business, define the model, and take responsibility for the system. LLMs help with the implementation, but that part was never the hard part of the job.

These scans seem perfect for fabrication experiments.

I’ve been trying a workflow where the mesh is inverted and used to generate a 3D-printed mold, then I gelcast zirconia ceramic into it and sinter it. The result is a dense ceramic version of the sculpture.

If you downscale the models they work well as small desktop statues or relief friezes, and ceramic casting can preserve surprisingly fine detail from the scan.

I rank with those who think human-like intelligence will require embeddings grounded in multiple physical sensory domains (vision, touch, audio, chemical sensing, etc.) fused into a shared world representation. That seems much closer to how biological intelligence works than text-only models. But if this path succeeds and produces systems with something like genuine understanding or sentience, there’s a deeper question: what is the moral status of such systems? If they have experiences or agency, treating them purely as tools could start to look uncomfortably close to slavery.

In the 90s people hoped Unified Modeling Language diagrams would generate software automatically. That mostly didn’t happen. But large language models might actually be the realization of that old dream. Instead of formal diagrams, we describe the system in natural language and the model produces the code. It reminds me of the old debates around visual web tools vs hand-written HTML. There seems to be a recurring pattern: every step up the abstraction ladder creates tension between people who prefer the new layer and those who want to stay closer to the underlying mechanics.

Roughly: machine code --> assembly --> C --> high-level languages --> frameworks --> visual tools --> LLM-assisted coding. Most of those transitions were controversial at the time, but in retrospect they mostly expanded the toolbox rather than replacing the lower layers.

One workflow I’ve found useful with LLMs is to treat them more like a code generator after the design phase. I first define the constraints, objects, actors, and flows of the system, then use structured prompts to generate or refine pieces of the implementation.

Not sure i get the down vote. Real person here, maybe too vague and enthusiastic, but not malicious.

One interesting way to look at projects like this is that they’re essentially tiny universes defined by a functional update rule.

The grid + instruction set + step function form something like:

state(t+1) = F(state(t))

Once you have that, you get the same ingredients that appear in many artificial life systems: local interactions; persistence of information (program code); mutation/recombination; selection via replication efficiency. And suddenly you get emergent “organisms”. What’s interesting is that this structure isn’t unique to artificial life simulations. Functional Universe, a concept framework [0], models all physical evolution in essentially the same way: the universe as a functional state transition system where complex structure emerges from repeated application of simple transformations.

From that perspective these kinds of experiments aren’t just toys; they’re basically toy universes with slightly different laws. Artificial life systems then become a kind of laboratory for exploring how information maintains itself across transformations; how replication emerges; why efficient replicators tend to dominate the state space. Which is exactly the phenomenon visible in the GIF from the repo: eventually one replicator outcompetes the rest.

It’s fascinating because the same abstract structure appears in very different places: cellular automata, genetic programming, digital evolution systems like Avida, and even some theoretical models of physics.

In all cases the core pattern is the same: simple local rules + iterative functional updates → emergent complexity. This repo is a nice reminder that you don’t need thousands of lines of code to start seeing that happen.

[0] https://voxleone.github.io/FunctionalUniverse/

Working on Functional Universe (FU), a formal framework for modeling physical reality as functional state evolution, integrating sequential composition with simultaneous aggregation.

https://voxleone.github.io/FunctionalUniverse/

I can relate to some of what you’re describing, though from a different angle. I’ve always been somewhat of a loner, and as I’ve gotten older I’ve grown increasingly dissatisfied with the shallowness of many modern interactions: the constant glance at the screen, that black brick glued to the hand, the strange absence of attention even when you try to do something kind for someone. It often feels like we’re all performing a kind of theater of socialization.

One thing that helped me over the years was cultivating a richer inner life and maintaining some contact with nature. Long walks, quiet time, reading, building things slowly, the kinds of activities that don’t depend on an audience. At first that kind of solitude can feel oppressive, but with time it can also become a kind of freedom.

As you get older, or at least that has been my experience, you begin to realize how precious each moment is, and how little sense it makes to spend too much of it on interactions that feel hollow. Real presence, even if rare, becomes much more valuable.

Your situation is clearly different, and the transition you’re going through sounds genuinely hard. But sometimes these chapters also open space to rediscover parts of yourself that were quiet for a long time. I wish you strength navigating this change, and I hope you eventually find a rhythm that feels meaningful again.

Yes, anyone can generate code, but real engineering remains about judgment and structure. AI amplifies throughput, but the bottleneck is still problem framing, abstraction choice, and trade-off reasoning. Capabilities without these foundations produce fragile, short-lived results. Only those who anchor their work in proper abstractions are actually engineering, no matter who’s writing the code.

I’ve always designed systems along the classic path: requirements → use cases → schematization. With AI, I continue in the same spirit (structure precedes prompting), but now the foundational layer of my systems is axioms and constraints, and the architecture emerges through structured prompts. Any AI on the shift is an aide in building systems that are logically grounded. This is where the “all of us as AI engineers” claim becomes subtle. Yes, anyone can generate code, but real engineering remains about judgment and structure. AI amplifies throughput, but the bottleneck is still problem framing, abstraction choice, and trade-off reasoning.

What’s striking here is the convergence on a minimal axiomatic kernel (Lean) as the only scalable way to guarantee coherent reasoning. Some of us working on foundational physics are exploring the same methodological principle. In the “Functional Universe” framework[0], for example, we start from a small set of axioms and attempt to derive physical structure from that base.

The domains are different, but the strategy is similar: don’t rely on heuristics or empirical patching; define a small trusted core of axioms and generate coherent structure compositionally from there.

[0] https://voxleone.github.io/FunctionalUniverse

I’ve found a workflow that feels both structured and respectful of professional craft, especially in the context of this thread. I don’t just "vibe code" and let an LLM fill in the blanks. I use a classic design discipline (UML and use-cases) to document the process: 1. Start with requirements – 2.Define use cases - 3. Implement classes/objects (Architecture first, not after-the-fact refactors) 4. Add constraints and invariants (Contracts, boundaries, failure modes, etc.) - 5. Let the agent work inside that frame, pausing at milestones for human oversight.

Those UML/use-case/constraint artifacts aren’t committed as session logs per se, but they are part of the author’s intent and reasoning that gets committed alongside the resulting code. That gives future reviewers the why as well as the what, which is far more useful than a raw AI session transcript.

Stepping back, this feels like a decent and dignified position for a programmer in 2026: humans retain architectural judgement --> AI accelerates boilerplate and edge implementation --> version history still reflects intent and accountability rather than chat transcripts. I can’t afford to let go of the productivity gains that flow from using AI as part of a disciplined engineering process, but I also don’t think commit logs should become a dumping ground for unfiltered conversation history.

It is interesting that Google translates the first paragraph of the text like this>>

"And the word he spoke was all like this. He was a hired hand, and he was full of malice, and he was in ƿælfæst. He didn't remember the man's name. He was in gefeohte(...)"

It says Icelandic.:)

I think an important point in this discussion is that adopting FOSS requires a level of institutional openness that is not typical of governments in general. It’s not just a question of switching vendors; it’s about embracing transparency, auditability, and shared ownership of public infrastructure. The question is: are governments fully aware of what FOSS adoption actually implies?

Brazil is an interesting case. On paper, we have a strong legal mandate. Under Art. 16 of Lei 14.063/2020[0], information and communication systems developed exclusively by public bodies must be governed by an open-source license, allowing use, copying, modification, and distribution without restriction by other public entities.

However, implementation tells a different story. Take PIX, the instant payment system developed by the Brazilian Central Bank. As of today, only the API is open. The core system code remains unpublished[1]. If the system was developed exclusively by the public administration, this seems difficult to reconcile with the letter - and certainly the spirit - of the law.

So the issue is not only whether governments should reduce vendor lock-in. It’s whether they are prepared to follow through on what real openness demands once they commit to it.

[0] https://www.planalto.gov.br/ccivil_03/_Ato2019-2022/2020/Lei... [1] https://d1gesto.blogspot.com/2025/06/brazils-pix-system-face...

An existential crisis for the urban middle class, which in the 18th century corresponded to the bourgeoisie or trade classes, making the situation, if unresolved, a potential modern analogue of a French‑Revolution–style crisis. Instead of feudal oppression, it is driven by technological displacement and concentration of capital, both reinforced by feedback loops.

The folks who keep the power grid running, write compilers, secure the internet, and design dependable systems don’t get viral fame, but their contributions are far more critical. That imbalance is no small thing; it shapes who gets funded, who feels validated, and who decides to pursue a challenge that doesn’t promise a quick TikTok moment or a crypto-style valuation bump. A complex technological civilization depends on people willing to go deep, to wrestle with fundamentals, to think in decades rather than funding cycles. If the next generation of capable minds concludes that visibility is more rational than depth, we’re not just changing startup culture. You can survive a lot of hype. You can’t survive a steady erosion of mastery.

A conceptual critique of Bostrom’s simulation argument that focuses on how time and computation are treated. The article explores whether common assumptions about simulated realities hold in a functional view of the universe where state transitions are not simultaneous (require an irreducible duration).