An experimental processor architecture where memory pages exist independently and processors receive temporary access to them.
Most computer architectures are described around the processor.
The CPU executes instructions, reads data from memory, transforms it, and writes the result back. Memory is usually presented as a resource supporting the processor.
This model has worked extremely well.
But it is not the only possible way to organize computation.
While designing Memora8, I started with a different question:
What if memory pages were treated as independent parts of the system rather than passive storage owned by a running program?
Memora8 is an experimental processor architecture built around this idea.
The processor is usually the center
In a conventional system, computation is organized around programs running on processors.
The operating system gives each process an address space. The process reads and modifies memory through addresses. Data is interpreted mainly through the program currently using it.
This creates a familiar model:
Program
↓
CPU
↓
Memory
The processor is active.
Memory is passive.
Memora8 explores the reverse perspective.
Pages exist independently
In Memora8, memory is divided into pages.
A page is not merely a temporary piece of a process address space. It exists independently of the processor that currently works with it.
The page can contain:
- input data;
- an intermediate result;
- program state;
- structured records;
- information moving between processing stages.
A CPU does not permanently own the page.
Instead, the system temporarily allows a processor to work with it.
The relationship becomes:
Memory Page
↓
Temporary ownership
↓
Processor performs a task
↓
Page is released or transferred
The data retains its identity while different parts of the system process it.
Temporary ownership
Temporary ownership is one of the central ideas behind Memora8.
When a processor receives a page, it receives the right to work with that page for a defined period or operation.
Other processors should not modify the same page simultaneously.
When the task is complete, ownership can return to the system or move to another processor.
This makes an important relationship explicit:
A processor can modify a page only while it owns that page.
The goal is not merely to restrict access.
The goal is to make data movement and responsibility easier to understand.
At any moment, the system should be able to answer:
- Where is the page?
- Which processor currently owns it?
- Who is allowed to modify it?
- Where should it go next?
Computing as page processing
This model makes it possible to describe computation as a sequence of operations over pages.
For example:
Input Page
↓
Parser
↓
Structured Page
↓
Analysis
↓
Result Page
Each processing stage receives access to the page, performs its work, and passes the result forward.
The processor is no longer the permanent center of the system.
It becomes a temporary worker assigned to data.
Why explore this model?
Modern systems contain many hidden relationships between processors, memory, operating systems, and applications.
Data may be copied several times.
Ownership may be implied rather than explicit.
Multiple components may access the same memory through complex synchronization rules.
Memora8 asks whether some of this complexity can be reduced by making pages and ownership central architectural concepts.
Potential advantages include:
- clearer responsibility for data;
- controlled access to memory;
- fewer ambiguous shared-memory relationships;
- more explicit movement of information;
- an architecture that is easier to reason about;
- stronger foundations for later verification.
These advantages are still hypotheses.
Memora8 is an experimental architecture, not a claim that conventional processors should be replaced.
Its purpose is to explore another way of organizing computation.
Connection with Reganta OS and Sekura JS
Memora8 is being designed together with two other projects.
Reganta OS organizes execution around modules, pages, and streams.
Sekura JS is a programming language intended to describe programs for that execution model.
The projects influence each other:
Sekura JS
Programming model
↓
Reganta OS
Execution and orchestration
↓
Memora8
Memory and processing model
The language should express the concepts supported by the operating system.
The operating system should use the concepts supported by the processor.
Designing the layers together makes it possible to avoid abstractions that exist only to compensate for mismatched assumptions.
Preserving the architecture with Sekura Noda
A processor architecture contains many interconnected decisions.
Changing one rule about pages may affect the operating system, programming language, and verification model.
These decisions cannot remain only in source code, diagrams, conversations, or the architect’s memory.
I use Sekura Noda to preserve the knowledge behind Memora8, Reganta OS, and Sekura JS.
Definitions, accepted decisions, rejected alternatives, constraints, and relationships can be maintained as explicit knowledge that both people and AI can use.
Sekura Noda helps experts use AI to accumulate, improve, and monetize their unique expertise.
In this project, Noda allows AI to assist with architectural work without giving the model authority over the architecture itself.
AI can suggest possibilities.
The accepted knowledge remains controlled by a person.
A different center of computation
Memora8 begins with a simple change in perspective.
Instead of asking:
What memory belongs to this processor?
It asks:
Which processor temporarily owns this page?
That change may lead to a different relationship between hardware, operating systems, programming languages, and data.
The processor still performs computation.
But memory is no longer treated only as a passive resource surrounding it.
Pages become independent parts of the system, and processors temporarily work on their behalf.
That is the central experiment behind Memora8.
AI was used for English translation and editorial refinement. The ideas, architecture, and technical decisions described in this article are the author’s own.
Top comments (0)