between
Between
Some thoughts arrive fully formed. Most do not.
They begin as a sentence overheard in passing, a photograph with no obvious purpose, a place worth remembering, a sound, a sketch, or a question that should remain open for a while.
Traditional note-taking tools tend to ask what these things are too early. They want a title, a folder, a document, a category. The thought becomes an object before it has had time to become anything else.
I built Between for the stage before that.
Independent projectExplore 'between'Safekeeping for small moments.Open project (opens in a new tab)Fragments, not documents
Between is a private, spatial tool for collecting small fragments and arranging them into fields.
A fragment can be text, an image, a drawing, a recording, or a location. It does not need a name or a destination. You can capture it quickly, place it somewhere, connect it to something else, stack it with related fragments, or move it later when its meaning changes.
The field is not a page to complete. It is a place where fragments can remain separate while still existing in relation to one another.
Sometimes the useful thing is not the fragment itself, but the distance between two fragments. A repeated shape. An accidental grouping. A connection that becomes visible only after something is moved.
Between is designed to leave room for that.
A tool that stays provisional
I often use physical notes this way. Ideas accumulate on walls and desks before I understand what they belong to. Their position matters. Moving one can change the meaning of several others. The arrangement remains temporary, but it is not arbitrary.
I wanted to preserve that quality digitally without turning it into a conventional whiteboard or productivity system.
There are no rigid templates, required hierarchies, or prescribed workflows. Fields can be orderly or scattered. Connections can be meaningful, uncertain, or purely visual. A fragment can appear in a field without being permanently defined by it.
The system provides enough structure to work with ideas, but tries not to close around them.
Think in pencil.
Designed around direct manipulation
Between is primarily a tactile interface.
Fragments can be dragged directly from the panel into a field. Cards can be repositioned, connected, grouped, and stacked. Drawings are created in place. Audio fragments appear as waveforms and become active when played. On a touchscreen, the field feels especially natural: less like operating software and more like handling a collection of small objects.
That physical quality shaped much of the design.
The cards are deliberately simple so the user’s material supplies the visual character. The interface recedes while the field grows. Controls remain available, but they do not dominate the canvas or turn the experience into a dashboard.
Between is desktop-first because the space is part of the tool. Mobile interfaces often compress everything into lists. Between needs room for distance, placement, and movement to remain meaningful.
Local by default
Between does not require an account, a server, or an AI agent.
Everything is stored locally in the browser using IndexedDB. Fields can be exported for safekeeping and imported again later. Nothing is uploaded or analyzed elsewhere.
This does not make the current version encrypted or indestructible. Browser data can still be cleared, devices can fail, and exports still matter. The onboarding explains that without forcing the user through a wall of warnings and consent language before they can begin.
The goal is not to make grand claims about privacy. It is simply to collect less, expose how the system works, and give the user direct control over their material.
No servers. No backend. No account. Your fragments remain yours.
Building Between
I built the first complete version of Between in roughly eight hours.
That speed did not come from having the entire product planned in advance. The idea became clearer through use. I built the smallest version that could hold the interaction, tried it, noticed what felt wrong, and revised it repeatedly.
“Arrangements” became “Fields.” A nested panel was changed after it interrupted the rhythm of retrieving fragments. Drag-and-drop became as important as the add button. The onboarding evolved from a warning into an invitation. The example field became something the user could inherit and alter rather than a disposable demonstration.
Most of the work was not adding features. It was paying attention to the small doorways between actions: entering the app, capturing something, locating it again, removing it from one field without destroying it everywhere, and understanding what would persist.
The result is still intentionally small. It is not a platform, a knowledge graph, or an attempt to replace every notes application. It is one focused environment for catching things before they disappear and seeing what forms around them.
What remains open
There are directions Between could grow: stronger encryption, additional field behaviors, richer ways to revisit older fragments, and deeper support for portable local archives.
But I do not want growth to erase the quality that made the first version worth building.
Between should continue to feel like a place where something unfinished is allowed to remain unfinished.
A living process should not be mistaken for a finished object.
Capture something. Move it around. Leave the question open.
Enjoyed this? Like or share.