One line of business code ships web, iOS, Android, server, and database together.
No more framework assembly, duplicated declarations, or per-platform rewrites. Write business intent in one place, and five surfaces follow.
Akan starts with the result people feel first, then keeps the method explainable from database to UI.
Akan.js
Business code becomes the whole product
export class ProductInput extends via((field) => ({
name: field(String),
})) {}Web / App
SEO web and native-feeling client transitions.
Server / Realtime
Bun-powered HTTP and WebSocket surfaces.
Database / Validation
SQLite first, scalable, and schema validated.
Docs / Plugins
Live docs and official feature blocks.
Built for the pain you already feel.
Web, app, server, database, and team size all hurt in different ways. Akan lets each developer recognize their own bottleneck first.
Web's fine — but the app is blocking you?
The same business code becomes SEO-ready web and native-feeling iOS/Android screens.
Shipping the app, but server and DB drag you down?
Bun server, SQLite, API contracts, and validation follow — no hand-wiring.
Doing it all alone, or with one teammate?
One full-stack developer owns all five surfaces. One person, a quarter of the time.
One field. Eight layers follow.
This is why one developer can own web, app, server, and database at once: the scattered wiring compresses into a single business declaration.
Adding one field the traditional way
Adding a single business field usually means wiring all of this by hand.
Change one place, chase eight. Miss one, and types break — or it blows up at runtime.
One declaration becomes every layer
export class ProductInput extends via((field) => ({
name: field(String),
})) {}One field declaration — schema and type defined at once. All eight layers above are generated automatically.
Define the DB schema
Add the query field
Add the service logic
Add the API field
Add the fetch field
Declare the client type
Declare the state management
Declare the UI prop
Diagram: field(String) on the left, eight generated layers branching out on the right.
AI coding turns to spaghetti past a certain size.
The faster an agent writes code, the more file paths, names, structures, and declaration styles drift apart — until review and maintenance fall over. Akan stops this at the source with strict rules.
Config Hell Ends
Configure everything in akan.config.ts. Even when you configure nothing, defaults keep the product moving.
Strict Rules, Unified Style
File paths, names, structures, and declarations stay consistent. Code reads like one person wrote it.
Slice Removes Spaghetti State
Declare a slice once and get list loading, pagination, statistics, state, and loading behavior together.
Agentic Full-Stack, Redefined
Fixed blocks for upload, login, admin, chat, boards, and alerts let agents produce consistent code.
This is what we mean by agentic full-stack.
Strict rules suit AI agents best. On top of fixed blocks — upload, login, admin, chat, boards, alerts — agents produce nothing but consistent code. It is not an abstract idea, but quality that rules make.
Everything a business app needs, connected
Akan supports web, iOS, Android, server, database, validation, internationalization, and official plugins as one coherent stack.
SEO-ready server-side rendering
iOS / Android client rendering
Bun HTTP / WebSocket server
SQLite first, Postgres / Redis ready
Schema validation and secure middleware
Type-safe from DB to UI
Built-in internationalization
Official plugin blocks
Stop repeating the same plumbing
Akan turns business declarations into docs, APIs, queries, state, and loading behavior so repetitive work disappears.
Schema becomes DB documentation
Business schema is not only runtime code. It becomes documentation your team can inspect together.
Endpoint becomes live API docs
API contracts stay close to implementation, and the generated surface can be tested as you build.
Query condition expands into reads
One query condition can power list, detail, and statistics reads without repeating the same plumbing.
Slice removes spaghetti state
Declare a slice once and get list loading, pagination, statistics, state, and loading behavior together.
Packaged web, native-level transitions
Akan web pages are compiled and packaged into apps. Unlike ordinary web packaging that often feels like a wrapped website, Akan ships built-in screen transitions for list-detail flows, overlays, and context changes, so the packaged web can deliver a native-level user experience without a separate UI rewrite.
Open focused flows from the bottom without leaving the CSR client.
Change context calmly when the next screen is not a deeper page.
Guide attention into the next page with a light zoom transition.
Push detail screens over lists with layered client navigation.
bunx create-akan-workspace@latestSee the business, not the system
These demos show how one convention-driven workspace carries business intent through multiple surfaces.
How Conventions Expand Your Business Definition
Cross-Platform Development
One page can become SEO-ready web and app-ready client screens with native-feeling transitions.
Database & API Integration
Schema changes flow into database, validation, API contracts, and generated clients without hand wiring.
Full-Stack Type Safety
Database schema changes automatically influence server, API, state management, and UI types.
Domain-Driven State Management
State, loading, pagination, and statistics follow the domain so UI code stays predictable.
Agent-Ready Code Generation
Official patterns and plugins give agents predictable blocks for upload, login, admin, chat, boards, and alerts.