5.1 KiB
Unify Developer Manual
Build full applications with a single, unified codebase.
Unify is a full-stack application framework designed to remove the accidental complexity of modern web development. Instead of hand-wiring HTTP requests, state management, SQL queries, UI updates, permissions, and caching — Unify turns each domain object into a live application object that exists simultaneously on the server and client.
You write your application once. Unify takes care of syncing it everywhere it needs to be.
Why Unify?
Most web apps are assembled from disconnected technologies: React + REST + ORM + SQL + State Manager + WebSockets + UI Framework + Access Control…
Each layer requires boilerplate to keep everything in sync:
- serialize → send → parse → update → re-render → validate permissions
- write SQL + write endpoints + write frontend state logic for the same entity
Unify eliminates these seams.
One class = data + logic + UI + permissions + real-time behavior
The framework:
- turns your class into a database table (server)
- generates UI components from that class (client)
- syncs all changes via a structured WebSocket protocol
- applies permissions automatically based on user role
- integrates filtering, joins, pagination at the SQL level
- caches and updates only changed fields
You focus on the domain model. Unify handles the rest.
Why Unify Is AI-Optimized
Unify applications are self-describing graphs. The object structure defines:
UI layout
Backend relationships
Permissions
Sync rules
Navigation
A human developer may lose track of where objects live in the graph.
But AI can:
infer full graph topology
find optimal traversal paths
safely modify relationships
rewrite UI interactions without breaking structure
This means Unify enables:
AI-generated UI actions
AI-guided refactoring
AI-assisted CRUD creation
Automated join discovery
Intelligent navigation handling
What does development feel like?
Example: define a News class
export default class news extends table {
title = new text("Title");
body = new text("Message");
price = new number("Price");
permission() {
this.allow(groups.visitor, "READ");
this.allow(groups.admin, "WRITE");
}
}
And a list view:
export default class newsListTable extends gridView {
header = new newsListTableHeader();
body = new newsListTableBody(newsListItem, new collection(news));
}
You don’t manually:
- write SQL queries
- define REST endpoints
- build WebSocket handlers
- implement CRUD actions
- code client state syncing
- generate UI markup
Unify does all of that from your object graph.
Architecture: What’s inside
| Layer | Responsibility |
|---|---|
| Domain Objects | Single class shared by server + client |
| Render Collections | Auto-loaded lists with pagination + search |
| Table Controller | Database operations + joins |
| Socket Controller | Real-time communication layer |
| UI Runtime | Live elements, animations, events |
| Permission Engine | Automatic security per object/action |
This creates a Behavioral ORM:
- objects contain their own server logic
- queries are automatically composed from UI actions
- users see only what they are permitted to interact with
Why does this matter?
Modern software complexity isn’t caused by features — it’s caused by glue code. For every feature, you implement it 3–6 times: backend models, database schema, API routes, frontend state, UI bindings…
Unify collapses those layers into one source of truth.
The result:
- drastically fewer bugs
- ultra-fast iteration cycles
- real-time UX without extra work
- secure-by-construction access rules
- smaller teams can ship full apps
Current focus
The goal of this release is to give developers a working demonstration of:
- full-stack sync with no REST boilerplate
- real-time UI updates
- built-in permissions
- SQL searching / joining from the UI
- cross-platform dynamic UI rendering (Windows / Mac / Web)
The included News Application shows:
- search/filter with SQL operators (
LIKE,OR,>=) - item detail transitions + CRUD dialogs
- login + role-based access
- pagination
- dynamic view/layout behavior
Who is Unify for?
✔ Full-stack developers ✔ Product developers who hate glue code ✔ Teams who want to ship faster ✔ Anyone who believes software should be simpler
Status
Unify is actively developed and evolving. Contributions, feedback, and architectural discussion are welcome.
Help define the future of unified application development.
Get started
The source includes:
unify_source/– the core frameworkunify_application/– working reference application
Clone and run the app to see the architecture in motion:
git clone https://.../unify
cd unify_application
npm install
npm start
Documentation and complete API references are coming.