timp / Tim is on Nostr

Poastor, internet explorer, yolo coder #PardonSamourai

Last Notes

2026-01-30 23:31:32 UTC

https://blossom.primal.net/696265de5a5ce9e0ab8417146ad709326fb37e2626e37082c8c16960217f1411.png
My dad worked on computers before I was born, back when machines did not pretend to be friendly. He wrote the code, built the machines, wired them together, and listened for sounds that meant trouble. Fans had a pitch and drives had a rhythm. When something went wrong, you often heard it before you saw it.
In the eighties he became a system administrator, before that phrase turned into a job title. Back then it meant you owned the whole system. There was no one else to hand it off to. If something failed, it failed right there, in the same room. It left you with little choice other than rolling a cigarette and fixing it.
Back then, systems did not reach very far. That was not a limitation. It was the reason they worked. A disk could fail without pulling anything else down with it. A program could crash and stay crashed. You always knew where the edge was because it was right there in the room with you.
Trust lived inside those edges. If you gave something access, you knew what it could touch. If you handed someone a key, you knew which door it opened. When a mistake happened, the damage stopped where the system stopped. Abuse existed, but it demanded effort. You had to show up. You had to spend time and hardware and attention.
That way of working did not vanish because it was flawed. It vanished because it could not survive success.
More people started using computers. Machines began to speak across rooms, then across cities, then across continents. Software left the building and never came back. At some point nobody could point at the whole system anymore. Responsibility stretched thin and then dissolved. Nothing about that was reckless. It was scale doing what scale does.
The failures changed shape.
Now when an application disappears, your data goes with it. When an account closes, years of context vanish in the same motion. We pretend this is normal. We call it convenience. We accept it because pushing back feels futile. The old alternatives have faded far enough that we barely remember them.
These systems assume they will keep working. They assume the platform will still exist tomorrow. They assume nothing important will fail at the wrong time. When those assumptions break, everything breaks together.
That is also why abuse spreads so easily. Identity is cheap because it has no weight. Authority slips in unnoticed because it is never clearly granted. Reach appears by default. You do not earn it. You inherit it by showing up.
Moderation shows up after the damage is done. There is nowhere else for it to go. By that point the system has already chosen what spreads and what survives. At scale it turns into endless cleanup, not control.
We tried to fix it with cryptography. We locked the wires. We stamped messages. We built systems that promised safety if you followed the rules closely enough. What people got were setups that offered no forgiveness. One wrong move and the door slammed shut.
Most people stepped away because the price of a small error was total loss. Years could vanish without warning. That is not security. That is fragility. Even Phil Zimmermann, who invented PGP, has said he does not use it himself, because he couldn’t be bothered spending time learning how to set it up correctly.
The failure was not the math. It was where we placed it.
There is another way to approach this. It starts by letting go of the idea that software should be permanent. It accepts that things will fail. It treats that as normal instead of catastrophic.
This is where 2WAY comes in. It starts from a simple idea:
On 2WAY, your data does not belong to the application that happens to display it. It lives locally, shaped in a way other software can understand. An app can leave without dragging your history behind it. Another can step in and continue.
This changes how access works. Nothing acts just because it exists. Permission has to be given. Not once, not vaguely, and not forever. When something is allowed to do something, that allowance has a shape. When it ends, it ends cleanly.
You do not see the cryptography most of the time. It does its work quietly. What you see are moments where a decision is required. A choice to allow something. A choice to stop it later. Recovery is expected and mistakes do not poison the whole system. As a result, failure stops spreading.
If a service disappears, your data stays put. If software misbehaves, it cannot wander into places it was never invited to. If trust breaks, it breaks along a line you can point at.
Abuse becomes harder because it has to push against structure. New identities arrive without weight. They do not reach far unless other identities lay the groundwork for them. That takes time. It takes effort. It cannot be faked cheaply.
Misinformation looks different too. The problem was never that people lie. The problem is that content floats free of its past. In this kind of system, where something came from is not a mystery. What happened to it along the way leaves marks. You are not forced to believe any of it. You can see enough to decide.
This matters more as machines begin to act on our behalf. An assistant that can do everything is dangerous. One that can only act within clear limits is dull in the right way. When it fails, it stops instead of spreading the damage.
Something else happens along the way. Patterns that rely on quiet overreach stop working. An application cannot slowly take more than it was given. It cannot blur the boundary and hope no one notices. That kind of behavior becomes visible because it has to ask.
Power shifts.
Platforms lose their grip because they no longer own the ground beneath you. Software competes again on usefulness. Lock-in fades because there is nothing left to hold.
None of this fixes people. Conflict remains. Deception remains. But the systems stop amplifying the worst behavior just because it is cheap.
We are moving into a world filled with generated voices, synthetic images, and automated decisions. Implicit trust will not survive. Assumptions turn into attack surfaces. Silence becomes risk.
The only thing that scales safely is clarity. Clear authority. Explicit boundaries. Systems that know what they are allowed to do and nothing beyond that.
Software should be allowed to die. Your data should stay where it is. Your identity should not thin out or vanish because a service closed its doors.
That is what 2WAY is trying to make boring again.
It is not a product yet. It is a shape. The protocol and backend are written down. The boundaries exist. The hard parts are named. What exists today is the structure, not the machine that runs it.
I am still finalizing that structure. I am looking for weak joints. I am checking where assumptions leak. I want the limits to hold before anything is turned on.
When that work settles, I will start another build iteration.
The protocol and backend specifications are practically ready, MIT licensed, and live here:
https://github.com/livegnik/2way-poc-design
If this way of thinking aligns with you, the work is open. There is room to work on it together.

2026-01-17 17:53:47 UTC

- reply

Thanks for your time and interest. If you have any questions, I'd be happy to answer them. Any and all feedback is very welcome.

2026-01-17 14:40:41 UTC

- reply

GM!
On it.

2026-01-17 14:01:08 UTC

- reply

That sounds sensible and underappreciated indeed.
2WAY is concerned with what happens once data reaches the node and multiple parties can affect the same state. Shared state needs rules that are explicit and applied the same way everywhere, otherwise different nodes will reach different conclusions over time. In 2WAY those rules are enforced by the system itself rather than reconstructed by applications. It sounds like Reticulum can move data very well, but does not aim to define or enforce shared history, which is the problem 2WAY is built to solve.

2026-01-17 13:33:36 UTC

- reply

If you are familiar with Zen and want a clearer sense of how 2WAY differs, it helps to read sections “7. Security model,” “8. Incentives,” and “9. Privacy” first.
They explain the underlying assumptions and tradeoffs before the architecture details, which makes the rest of the design easier to place.

2026-01-17 13:26:26 UTC

- reply

Thanks for pointing it out. This is the first time I'm reading about it.
It seems Zen is about moving data across unreliable networks and making sure messages can get through without infrastructure, but seems to avoid defining what those messages mean, who is allowed to send them, how they should be ordered, or how shared history should work.
2WAY does all that too, by defining how state is validated, authorized, ordered, and shared so different parties can converge on the same result without relying on transport behavior or application-level convention.

2026-01-16 18:44:49 UTC

- reply

tl;dr:
https://blossom.primal.net/b711200667fee903a0e324655a7f6dac25de1957cac9d152f71776c44dd556d7.png

2026-01-16 18:44:22 UTC

Nostr's NIP-01 explains what an event looks like and how the cryptography works. It defines the data model.
It does not describe a clear validation model, and I could not find one elsewhere. So I tried to write one.
Feedback is very welcome.
https://github.com/nostr-protocol/nips/issues/2188

2026-01-16 13:08:59 UTC

GM
https://www.youtube.com/watch?v=RwP1liHjpI8

2026-01-13 22:27:59 UTC

I've just published my first NIP, "Strict Event Validation," to NostrHub. Hope it helps!
I'm relatively new to the Nostr protocol specs and am open to corrections. The NIP is meant as a starting point for discussions, not a final answer.
Comments, questions, or suggestions are welcome.
https://nostrhub.io/naddr1qvzqqqrcvypzqfx0wns3ykpna96jkjzru2y8mmwa76gs39hxaq4zmmmgepf86zq5qy2hwumn8ghj7erfw36x7tnsw43z7un9d3shjqqhwd68y6trwskk2an9de6z6anpd35kgct5d9hku7s9vy7

2026-01-13 22:21:56 UTC

- reply

How do you solve for cruising around your dyson sphere in hyperdrive without having to rely on Earth as a single point of time for timestamping though? This might be the biggest threat to Bitcoin's decentralization.

2026-01-13 16:56:21 UTC

- reply

Any and all feedback welcome.
#NIP #NostrDev #StrictValidation
cc @npub1xts…kk5s

2026-01-13 15:48:29 UTC

- reply

Working on something that addresses all of the points you mentioned. Currently in protocol design stage. Feedback welcome. AMA.
https://iris.to/note12p9w7eau9565nkqzzhfytg8dz085r6kad49pccvvy5uzk4ddwp5qu03jjc

2026-01-13 08:28:29 UTC

- reply

First thing I saw this morning when I opened Nostr. gg

2026-01-11 02:42:36 UTC

2WAY: P2P application protocol.
Users own their data, apps can talk directly to each other, and all state lives in a cryptographically secured graph that syncs with other nodes based on user-defined permissions.
AMA.
https://github.com/livegnik/2way-poc-design

2026-01-09 23:54:04 UTC

- reply

You can still use a graph offline.
https://iris.to/note1tlzzsszhk5xaghfdeuvlewajrz0hvxnsgdtln7uv7jff6zhtpdxqt4ndzx

2026-01-09 21:43:47 UTC

What if apps did not depend on a centralized backend?
I am working on 2WAY, a local-first, peer-to-peer, open-source (MIT) application protocol and backend, designed to run on practically any device. The goal is to move core infrastructure concerns out of individual apps and into a shared system layer that enforces permissions, stores state as a cryptographically secured graph in a relational database, and synchronizes that state directly between peers.
Apps focus on their data model and domain logic. The protocol handles persistence, ordering, synchronization, and trust between peers. This allows apps to work offline by default, survive node loss, and keep functioning without central servers or long-lived operators.
This enables classes of apps that are difficult or impossible to build on centralized systems. Apps where users keep control of their data instead of handing it to a provider. Apps that rely on cryptographic proofs as the source of truth rather than trusted networks or intermediaries. Apps that keep working through network splits. Apps that can interoperate without shared infrastructure or federation. Apps that do not break when a service shuts down, changes terms one-sided, or disappears.
The system is designed to fail locally and predictably under stress or abuse, with built-in resistance to Sybil attacks and denial-of-service.
This repository is a work in progress. I am currently focused on the protocol and architecture, which are about 95 percent complete, unless someone points out a fundamental flaw. The rest of the repository already defines the full system surface, including data, interfaces, security, flows, and more. The structure is in place, but these sections still need to be written and fleshed out.
Any questions, comments, or suggestions are welcome and appreciated.
Design repository with specs: https://github.com/livegnik/2way-poc-design