The AI-ready stack, for ambitious vibe-coded projects
S8 is a free, unified JAVA runtime and application stack. It lets a small team create servers, rich fronts, embedded databases, and the orchestration that binds them — without assembling a zoo of frameworks.
Mission. Collapse the distance between an idea and a running product. S8 exists so you can ship rich SaaS in one language and one process — Spring Boot, four steps ahead.
// LaunchServer.java
import com.s8.meta.api.S8;
import com.s8.meta.api.server.S8BootMethod;
import com.s8.meta.api.server.S8WebServer;
public class LaunchServer {
public static void main(String[] args) throws Exception {
S8WebServer server = S8.WEB_SERVER_FACTORY.createWebServer(
"/path/to/app-config.xml",
LaunchServer.class,
params -> params.addBootMethod(
S8BootMethod.MAIN_BOOT_PAGE, AppBoot.INSTANCE));
server.start();
}
}
// run on the S8 module path
// AppBoot.java — the front is a remote screen
import com.s8.meta.api.annotations.S8ObjectType;
import com.s8.meta.api.flow.S8SyncFlow;
import com.s8.meta.api.front.S8FrontObject;
import com.s8.meta.api.front.S8FrontSession;
import com.s8.meta.api.server.S8BootMethod;
public final class AppBoot implements S8BootMethod {
static final AppBoot INSTANCE = new AppBoot();
@Override
public void boot(S8SyncFlow flow) throws Exception {
S8FrontSession front = flow.front();
HomeScreen screen = new HomeScreen(front);
screen.setTitle("Hello S8");
screen.vertex.expose(0);
flow.refresh();
}
}
@S8ObjectType(name = "app.HomeScreen")
class HomeScreen extends S8FrontObject {
HomeScreen(S8FrontSession front) {
super(front, "app.HomeScreen");
}
void setTitle(String title) {
vertex.outbound().setStringUTF8Field("title", title);
}
}
// Flash persistency — annotate a row, put it, get it
@S8RowType(name = "user-v1")
public class UserRow extends RowS8Object {
public String email;
public UserRow(String id) { super(id); }
}
TablesDB db = flow.tables();
db.createTable(new CreateTableS8Request("users", true));
UserRow row = new UserRow("u-42");
row.email = "ada@stack8.tech";
db.putRow(new PutRowS8Request("users", row, true, true));
GetRowS8Response got = db.getRow("users", "u-42");
// Spaces hold object graphs — logical, stored, versioned
SpacesDB spaces = flow.spaces();
spaces.createSpace(new CreateSpaceS8Request(
"space/ada", new SpaceS8Object[]{ root }));
AccessSpaceS8Response res =
spaces.accessSpace(new AccessSpaceS8Request("space/ada", true));
if (res.status == AccessSpaceS8Response.Status.OK) {
Object[] exposed = res.objects;
}
flow.refresh();
# build.properties — identity of an S8 module
module.java = com.s8.pkgs.ui.aloe
# dependencies are target folder names under the stack root
dependencies = \
S8-meta-env, \
S8-meta-API, \
S8-pkgs-ui-carbide
target = S8-pkgs-ui-aloe
main = com.s8.pkgs.ui.aloe.LaunchServer
A stack, not a kit
S8 abstracts the parts every serious web product rediscovers: HTTP/2 and TLS, request mapping, the thread model, databases, and the front/back API. You write against one flow.
Secure
Paranoid mode enabled
Zero dependencies, so nothing extra sits in the foundation.
Learn more...
Synced
High concurrency architecture
Async from day one — you never meet a light thread.
Learn more...
Storage
Embedded DB and caching
Annotate your objects; caching and DB access come with them.
Learn more...
Structured
Graph DB, native version
Graph-shaped objects, attached resources, native versions.
Learn more...
Screen
Your front as a remote screen
Drive front components from the back; extend them with standards.
Learn more...
Scalable
Lake of nodes
Cluster S8 instances for resilience, load balancing, and backup.
Learn more...Get started in three steps
The loop is short on purpose. Edit, boot, look at the real app. The server comes up in less than a second on most machines.
Install the stack
Download v1.2.0 and point /etc/s8-conf.properties at your JAVA_HOME and stack roots.
Boot a server
Call S8.WEB_SERVER_FACTORY, register a boot method, and start().
Code against the flow
Use flow.front(), tables(), spaces(), and repositories() from one place.
Documentation for humans and AI
A new stack needs a strong doc. The S8 API is condensed in S8-meta-API.
The module overlay lives in S8-meta-env. The builder is S8-meta-build.
Pages are written for people; llms.txt is written for agents.
Code against S8
MDN-style reference for the flow, the front, tables, spaces, repositories, mail, and annotations.
The overlay
How sibling modules under a stack root resolve DEV vs PROD, web sources, and the static MODULE field.
build.properties
How S8StackBuilder walks the DAG, compiles with javac --module-path, and jars into prod.