image
Akan.js
DocsBlog
English
image
Akan.js
DocsBlog
DocsBlog
Released under the MIT License
Official Akan.js Consulting onAkansoft
Copyright © 2026 Akan.js All rights reserved.
System managed bybassman
One line, every platform

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.config.tsWebiOSAndroidServerDBType-safePlugins

Akan.js

Business code becomes the whole product

1 → All
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

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 devs1

Web's fine — but the app is blocking you?

The same business code becomes SEO-ready web and native-feeling iOS/Android screens.

App devs2

Shipping the app, but server and DB drag you down?

Bun server, SQLite, API contracts, and validation follow — no hand-wiring.

Solo / small teams3

Doing it all alone, or with one teammate?

One full-stack developer owns all five surfaces. One person, a quarter of the time.

8 in 1

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.

Before

Adding one field the traditional way

Adding a single business field usually means wiring all of this by hand.

1Define the DB schema
2Add the query field
3Add the service logic
4Add the API field
5Add the fetch field
6Declare the client type
Rules Create Quality

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.

Platform Surfaces

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

Generated From Intent

Stop repeating the same plumbing

Akan turns business declarations into docs, APIs, queries, state, and loading behavior so repetitive work disappears.

1

Schema becomes DB documentation

Business schema is not only runtime code. It becomes documentation your team can inspect together.

2

Endpoint becomes live API docs

API contracts stay close to implementation, and the generated surface can be tested as you build.

3

Query condition expands into reads

One query condition can power list, detail, and statistics reads without repeating the same plumbing.

4

Slice removes spaghetti state

Declare a slice once and get list loading, pagination, statistics, state, and loading behavior together.

Native-Feeling App Packaging

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.

bottomup

Open focused flows from the bottom without leaving the CSR client.

fade

Change context calmly when the next screen is not a deeper page.

scale

Guide attention into the next page with a light zoom transition.

stack

Push detail screens over lists with layered client navigation.

See the business, not the system

These demos show how one convention-driven workspace carries business intent through multiple surfaces.

$ bunx create-akan-workspace@latest

How Conventions Expand Your Business Definition

01

Cross-Platform Development

One page can become SEO-ready web and app-ready client screens with native-feeling transitions.

02

Database & API Integration

Schema changes flow into database, validation, API contracts, and generated clients without hand wiring.

03

Full-Stack Type Safety

Database schema changes automatically influence server, API, state management, and UI types.

04

Domain-Driven State Management

State, loading, pagination, and statistics follow the domain so UI code stays predictable.

05

Agent-Ready Code Generation

Official patterns and plugins give agents predictable blocks for upload, login, admin, chat, boards, and alerts.

Built for developer happiness

Run the business with one quarter of the code.

Less code means fewer tokens, clearer intent, easier reviews, and calmer updates. Akan is optimized for the happiness of developers who ship real products.

$ bunx create-akan-workspace@latest
7Declare the state management
8Declare the UI prop

Change one place, chase eight. Miss one, and types break — or it blows up at runtime.

After — Akan.js

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.