Introduction

Sumeru is Go with the ERP pieces already in place: a kernel, an addon contract, PostgreSQL underneath, and server-rendered screens on top. No Node. No message broker.

What Sumeru Is

Sumeru is an open-source modular ERP framework written in Go. Business functions ship as addons: contacts, products, CRM, sales, invoicing. Each addon is a folder with a manifest, Go models and XML views. The kernel discovers it, resolves dependencies, creates tables and wires menus.

The repository layout is three Go modules linked by replace directives:

A project can begin with an empty workspace pointed at the core and standard modules. From there the same application model grows into CRM pipelines, quotations, invoices and custom addons without replacing the architecture.

Core Concepts

Sumeru is built around a small set of concepts that appear consistently across the framework.

These concepts recur in the same shape. Reading one addon teaches you how to read the next.

A Simple Example

A model is metadata. The kernel turns it into a table, a form surface and an API resource.

1package models2 3import "sumeru/core/sdk"4 5type AccountJournal struct {6	sdk.Model `sumeru:"model=account.journal"`7 8	Name sdk.String `sumeru:"required,string=Name"`9	Code sdk.String `sumeru:"required,string=Code"`10	Type sdk.String `sumeru:"string=Type,selection=sale:Sales,purchase:Purchase,cash:Cash,bank:Bank,general:General"`11}

What is happening:

• The sumeru:"model=…" tag is the stable identity used in views, security and the API.
• Typed field markers plus tags declare columns; the ORM syncs schema on install. Run make generate after adding a struct.
• Runtime records are maps keyed by field name, not Go structs.
• XML views and access rules elsewhere in the addon bind UI and permissions to this name.

What Is Already in Place

First-party pieces in the framework and standard addons today:

• Go kernel packages: core/orm, core/module, core/engine, core/server, core/event, core/sdk, core/scheduler, core/applog, core/cache, core/importgen
• Core addons: base, mail, automation (partial), sumeru_ai (placeholder)
• Standard addons: contacts, product, crm, sale (partial), sale_crm, account, purchase (partial), hr (partial)
• Setup wizard, Apps install UI, multi-company switcher
• JSON-RPC API with API keys
• Lead -> won -> quotation -> sales order -> invoice -> posted journal entries

What Can You Build With Sumeru?

• CRM pipelines that convert to quotations and sales orders
• Customer invoicing with double-entry journal entries
• Purchase orders that draft vendor bills
• Custom business addons using the same manifest / model / view contract
• Internal tools that need server-rendered screens without a Node build

Not available yet: taxes, payments / bank reconciliation, computed order totals, inventory, manufacturing, automated tests on business addons. CSV/PDF export and bulk CSV import are available on views that enable Report (see Report engine).

Who Is Sumeru For?

Sumeru is for developers and organisations building serious business software in Go.

It is especially useful for:

• engineers who want an ERP-shaped kernel without Node, Docker or a message broker
• product teams extending lead-to-cash with their own addons
• operators evaluating Apps, roles and multi-company once an engineer has stood the system up
• agencies that want a repeatable Go backend for client operational software

It is a poor fit if you need a finished commercial ERP tomorrow, multi-tenant SaaS isolation built in, or a framework that only does HTTP routing.

Why Sumeru?

Writing a form or a SQL table is rarely the hard part. The time goes into making modules agree on models, menus, access rights and what happens when a lead is won.

Sumeru puts those pieces on one contract:

• Strong defaults, open boundaries: declare a model once; tables, forms and API follow.
• Addons never import each other; they integrate through events and registry lookups.
• PostgreSQL only: no Node, no broker, no external cache or job queue required.
• Documentation is part of the interface: these guides describe what the system actually does, including gaps.

Comparison

Sumeru is not a drop-in clone of another ERP. The difference is scope and stack.

Ecosystem size and years in production are real advantages elsewhere. Sumeru's argument is coherence and a small operational footprint, not maturity.

How the pieces fit

You run the server from the workspace module. Config points at PostgreSQL and an addons_path. On boot the module loader discovers manifests, the ORM syncs schema for installed addons, and the engine serves server-rendered screens plus JSON-RPC.

Around that core sit optional subsystems: scheduler, cache, mail, automation. An application that only needs contacts and CRM installs those addons and nothing else.

Addons stay isolated: depends orders install; runtime integration uses the event bus.

What to read next

Developers. Installation -> Configuration -> First boot -> Creating an addon -> Models & fields. Add Events when addons must talk, and JSON-RPC when external systems call in.

Business teams. Business overview -> Apps & install -> Lead-to-cash. Then Contacts & CRM or Sales & invoicing for the screens you will actually use.

Anything going further. Security overview and Isolation model before you plan multi-company or API access.

A note on this documentation

These guides document what the framework does, including where it is incomplete. Where a feature is partial or missing, the page says so.

That is deliberate. A guide that only describes intended behaviour costs you an afternoon the first time reality differs. Callouts marked caution or danger flag verified gaps and sharp edges.

Conventions used throughout

• Commands run from sumeru_custom_addons unless a page says otherwise.
• -i installs, -u reloads. Name the addons, or use -i all to install remaining modules in dependency order.
• Go changes need a rebuild (make run). XML and manifest data need -u because views and access rules live in the database once installed.
• Every page ends with "What not to do" where advice is concrete enough. Those lists are the compressed version of the page.

Getting help

The sidebar mirrors how the product is organised: start here, build, concepts, business, security. If you know whether you are installing, writing an addon or operating Apps, you can find the page.

For questions the guides do not answer: GitHub, the product FAQ, and the source. Most kernel packages are small enough to read.

Prerequisites

• Go 1.26 or newer
• PostgreSQL
• Comfort with HTTP (methods, status codes) and basic SQL

No Node, Docker, message broker or external cache is required for a local install.

A first application

The smallest path that runs:

$psql -U postgres -c "CREATE DATABASE sumeru;"$cd sumeru_custom_addons$cp sumeru.conf.example sumeru.conf$make replace-sumeru SUMERU_ROOT=../sumeru$make replace-sumeru-addons ADDONS_ROOT=../sumeru_addons$make generate$make run#visit http://localhost:8080/setup

That boots setup mode. Everything else in these guides (addons, models, events, API) is something you add when you need it.

Next step

Continue with Installation to wire the three modules and get a database ready.

What not to do

• Do not run pre-alpha in production.
• Do not expect addons to import each other; use depends and events.
• Do not skip the setup wizard looking for a default admin password. There is none.

Sumeru is pre-alpha (no tagged release, no upgrades). Part of Project Meru.