README.md

The Open-Source Data Operating System

Getting Started · Docs · Bug reports · Discussions

OpenFoundry is an open-source operational data platform inspired by the capability model of Palantir Foundry, implemented as auditable, extensible software. It combines 52 service directories, 38 shared libraries, Protobuf/OpenAPI contracts, generated SDKs, a React 19 + Vite + TypeScript web console, and declarative infrastructure for Kubernetes.

Unlike closed data platforms, OpenFoundry ships as a single Go monorepo with stable contracts, GitOps-native delivery, and governance that lives next to the code. The goal is to provide a reproducible foundation for teams that need to connect sources, version datasets, model an ontology, expose APIs, automate workflows, govern access, and operate analytical or AI workloads with end-to-end traceability.

Working with this codebase as an AI agent? Start at CLAUDE.md. It is the canonical onboarding guide for commands, conventions, security-critical zones, and what not to read by default.

Feature & Status

• Cloud-Native Architecture: Small Go services with one entrypoint per service, delivered through Helm, ArgoCD, and Terraform.
• Ontology at the Core: Object types, actions, functions, object views, lineage, and stable contracts for building applications on operational data.
• Contracts First: Protobuf as the source of truth, generated OpenAPI, and synchronized TypeScript, Python, and Java SDKs.
• Integrated Governance: Authentication, authorization, Cedar policies, audit, tenancy, SSO/MFA, and egress controls.
• Observability by Default: /healthz, /metrics, Prometheus, Grafana, Mimir, structured logs, and OTel traces.
• Developer Platform: CLI tooling, SDK generation, service templates, VitePress docs, and unit/integration test paths.
• Single Go Module: One root go.mod keeps libs/ and services/ synchronized without version drift.

Capability	Status	Capability	Status
Datasets & Versioning	✅ Available	Ontology Services	✅ Available
React Web Console	✅ Available	Generated SDKs	✅ Available
Protobuf/OpenAPI Contracts	✅ Available	AuthN/AuthZ Foundations	✅ Available
Observability Stack	✅ Available	Helm/ArgoCD Delivery	✅ Available
Kafka/NATS Integrations	✅ Available	Lakehouse / Iceberg	🚧 Under active development
AI / Agent Runtime	🚧 Under active development	Production Hardening	🚧 In progress

OpenFoundry vs Closed Data Platforms

Feature	OpenFoundry	Closed Data Platforms
Control	Auditable Code & Contracts One monorepo with services, libraries, SDKs, and infra fully inspectable.	Vendor Lock-in Strong provider dependency and limited implementation visibility.
Extensibility	Open Ecosystem Services, libraries, SDKs, and docs evolve with your needs.	Bounded by APIs Limited by external APIs and vendor roadmaps.
Deployment	GitOps-Native Kubernetes, Helm, ArgoCD, Terraform, and Compose for reproducible environments.	SaaS-First Managed deployments with less operational control.
Governance	In-Tree Policies & Audit Policies, audit, and tenancy live beside the platform code.	Coupled to Product Governance is tied to the vendor's commercial boundaries.
Developer Flow	Standard Tooling Go, TypeScript, Python, Java, Protobuf, and Makefile workflows.	Proprietary Tooling Local workflows that are harder to automate.
Contracts	Wire-Compatibility Invariants Pinned by golden tests; RIDs, JWT claims, and resource registries are stable.	Opaque Contracts Internal APIs change without notice.
Licensing	AGPL-3.0-only Strong copyleft, transparent governance, no hidden terms.	Closed Source Opaque pricing and IP boundaries.

Staying ahead

Star OpenFoundry on GitHub and be instantly notified of new releases.

Quickstart

To get started with OpenFoundry, follow these steps:

1. Clone the repository

git clone https://github.com/DioCrafts/OpenFoundry.git
cd OpenFoundry

2. Local development (Option 1)

Install the Go tools used by the monorepo into ./bin, including buf, golangci-lint, sqlc, and gofumpt:

make tools

Run the canonical local gate (tidy + vet + lint + contract checks + unit tests):

make ci

For faster iteration:

make test              # unit tests with -race + coverage
make build             # compile all packages
make contracts-check   # verify OpenAPI + SDK drift

3. Frontend (Option 2)

The web console lives in apps/web/ and uses React 19, Vite, and TypeScript:

pnpm install
pnpm --filter @open-foundry/web dev      # vite dev server
pnpm --filter @open-foundry/web check    # tsc -b --noEmit
pnpm --filter @open-foundry/web test     # vitest

4. Helm / Kubernetes (Option 3) - Cloud Native

Delivery assets live in infra/: Helm charts, ArgoCD apps, Terraform, and operational runbooks. Kubernetes is the only supported deployment target.

make gitops-bootstrap     # bootstrap ArgoCD applications
make gitops-status        # check sync status
make build-services       # one binary per service into ./bin/

5. Code generation (Option 4)

Regenerate Protobuf Go, sqlc, OpenAPI, and SDKs whenever contracts change:

make gen
make contracts-check

Heads-up: make lint baselines pre-existing issues via .golangci.yml (new-from-rev: HEAD). To audit the full backlog, run golangci-lint run --new-from-rev= ./....

---

Accessing OpenFoundry

1. Web Console: Open http://localhost:5173 (Vite dev server) or the URL exposed by your Kubernetes ingress.
2. APIs: Each service exposes /healthz, /metrics, and a versioned /api/v1/... surface.
3. CLI: Use of-cli from tools/of-cli/ for service introspection, contract checks, and route audits.

Repository layout

openfoundry-go/
├── apps/web/         React 19 + Vite + TypeScript frontend
├── services/         50 Go microservices (copy docs/templates/service-skeleton/ for new ones)
├── libs/             36 shared Go packages (auth, observability, kernels, …)
├── proto/            Protobuf source of truth; Go generated into libs/proto-gen/
├── sdks/             Generated TypeScript, Python and Java SDKs
├── infra/            Helm, ArgoCD, Terraform, Compose and operational runbooks
├── docs/             VitePress capability-oriented documentation site
├── tools/            CLIs and lint/helper tools
├── images/           Project branding assets, including this README logo
├── go.mod            Single Go module for the entire monorepo
└── Makefile          Canonical local task runner

Documentation

For detailed documentation, including configuration options, API references, ADRs, and advanced usage, please visit:

• docs/ — capability-oriented technical documentation.
• docs/architecture/index.md — high-level architecture overview.
• docs/architecture/adr/ — dated architectural decisions.
• CLAUDE.md — concise onboarding for AI agents.
• CONTRIBUTING.md — PR process, RFC requirements, and DCO policy.
• SECURITY.md — how to report vulnerabilities.

Getting Help

If you have any questions or need assistance:

• Check the existing GitHub Discussions for common issues and solutions.
• Ask questions and share your experiences in Discussions.
• Open an issue on GitHub Issues for bug reports or feature requests.

Links

• Documentation — The manual you should read
• Changelog — Releases and notable changes
• GitHub Discussions — Where the community lives

Contact

• Bugs: GitHub Issues
• General Discussion: GitHub Discussions
• Security: SECURITY.md
• Contributing: CONTRIBUTING.md

Contributors

OpenFoundry is a community-driven project, and we appreciate all contributions. Check out the Contributors page to see the amazing people who have helped make OpenFoundry better.

Star History

License

AGPL-3.0-only

OpenFoundry is a trademark of the OpenFoundry project. All other trademarks are the property of their respective owners.